Source code for mimiqcircuits.qasm.parser

# Copyright (C) 2023 QPerfect. All Rights Reserved.
# Proprietary and confidential.
#
import os
from dataclasses import dataclass, field
from typing import Any, Dict, List, Set, Union

from mimiqcircuits.qasm.exceptions import ParseError
from mimiqcircuits.qasm.lexer import Lexer
from mimiqcircuits.qasm.tokens import EMPTY_TOKEN, Token, TokenKind

# Directory containing standard includes
QASMINCLUDEDIR = os.path.join(os.path.dirname(__file__), "qasmincs")


[docs] @dataclass class QASMExpr: head: str args: List[Any] = field(default_factory=list) def __repr__(self): return f"QASMExpr({self.head}, {self.args})"
class ParserState: def __init__(self, lexer: Lexer, includedirs: List[str] = None): self.l = lexer self.isdone = False self.t = EMPTY_TOKEN self.nt = EMPTY_TOKEN self.nnt = EMPTY_TOKEN self.errored = False self.includedirs = [os.getcwd(), QASMINCLUDEDIR] if includedirs: self.includedirs.extend(includedirs) # Initialize lookahead self.readtoken() self.readtoken() def readtoken(self) -> Token: if self.isdone: return self.t try: nnt = self.l.next_token(start=True) # Skip comments and whitespace while nnt.kind == TokenKind.COMMENT or nnt.kind == TokenKind.WHITESPACE: nnt = self.l.next_token(start=True) except StopIteration: nnt = Token(TokenKind.ENDMARKER) self.t = self.nt self.nt = self.nnt self.nnt = nnt if self.t.kind == TokenKind.ENDMARKER: self.isdone = True return self.t def token(self): return self.t def peektoken(self): return self.nt def dpeektoken(self): return self.nt, self.nnt def expect(self, k: TokenKind) -> Token: t = self.token() if t.kind != k: self.errored = True raise ParseError(f"Found {t}, expected {k}", t, self) return self.t def expectnext(self, f: Union[TokenKind, Set[TokenKind]]) -> Token: t = self.peektoken() ok = False if isinstance(f, TokenKind): ok = t.kind == f else: # Set/List ok = t.kind in f if not ok: self.errored = True expected = f.name if isinstance(f, TokenKind) else str(f) raise ParseError(f"Unexpected {t.kind.name}. Expected {expected}", t, self) return self.readtoken() def accept(self, f: Union[TokenKind, Set[TokenKind]]) -> bool: t = self.peektoken() ok = False if isinstance(f, TokenKind): ok = t.kind == f else: ok = t.kind in f if ok: self.readtoken() return ok def parse_id(ps: ParserState) -> str: t = ps.expectnext(TokenKind.IDENTIFIER) return t.val def parse_integer_value(ps: ParserState) -> int: t = ps.expectnext(TokenKind.INTEGER) return int(t.val) def parse_real_value(ps: ParserState) -> float: t = ps.expectnext(TokenKind.REAL) return float(t.val) def parse_unsigned_value(ps: ParserState) -> int: t = ps.expectnext(TokenKind.INTEGER) return int(t.val) UNARYOP_TO_STR = { TokenKind.SIN: "sin", TokenKind.COS: "cos", TokenKind.TAN: "tan", TokenKind.EXP: "exp", TokenKind.LN: "log", TokenKind.SQRT: "sqrt", } def parse_unaryop(ps: ParserState) -> QASMExpr: # expectnext checks kind. Using Set for unary ops t = ps.expectnext( { TokenKind.SIN, TokenKind.COS, TokenKind.TAN, TokenKind.EXP, TokenKind.LN, TokenKind.SQRT, } ) op_str = UNARYOP_TO_STR[t.kind] ps.expectnext(TokenKind.LPAREN) expr = parse_expr(ps) ps.expectnext(TokenKind.RPAREN) return QASMExpr("call", [op_str, expr]) def parse_expr_atom(ps: ParserState): nk = ps.peektoken().kind if nk == TokenKind.REAL: return parse_real_value(ps) elif nk == TokenKind.INTEGER: return parse_integer_value(ps) elif nk == TokenKind.IDENTIFIER: return parse_id(ps) elif nk in UNARYOP_TO_STR: # UnaryOp return parse_unaryop(ps) elif nk == TokenKind.LPAREN: ps.readtoken() # consume ( expr = parse_expr(ps) ps.expectnext(TokenKind.RPAREN) return expr else: raise ParseError(f"Unexpected token {nk} in expression", ps.peektoken(), ps) def parse_expr_power(ps: ParserState): first = parse_expr_atom(ps) if ps.accept(TokenKind.CIRCUMFLEX_ACCENT): second = parse_expr_atom(ps) return QASMExpr("call", ["^", first, second]) return first def parse_expr_factor(ps: ParserState): if ps.accept(TokenKind.MINUS): return QASMExpr("call", ["-", parse_expr_factor(ps)]) elif ps.accept(TokenKind.PLUS): return parse_expr_factor(ps) return parse_expr_power(ps) def parse_expr_product(ps: ParserState): lhs = parse_expr_factor(ps) if ps.accept(TokenKind.STAR): rhs = parse_expr_product(ps) return QASMExpr("call", ["*", lhs, rhs]) elif ps.accept(TokenKind.FWD_SLASH): rhs = parse_expr_product(ps) return QASMExpr("call", ["/", lhs, rhs]) return lhs def parse_expr_sum(ps: ParserState): lhs = parse_expr_product(ps) # Precedence if ps.accept(TokenKind.PLUS): rhs = parse_expr_sum(ps) return QASMExpr("call", ["+", lhs, rhs]) elif ps.accept(TokenKind.MINUS): rhs = parse_expr_sum(ps) return QASMExpr("call", ["-", lhs, rhs]) return lhs def parse_expr(ps: ParserState): return parse_expr_sum(ps) def parse_arg(ps: ParserState) -> Union[str, QASMExpr]: id_str = parse_id(ps) if ps.accept(TokenKind.LSQUARE): idx = parse_integer_value(ps) ps.expectnext(TokenKind.RSQUARE) return QASMExpr("ref", [id_str, idx]) return id_str def parse_arglist(ps: ParserState) -> List[Any]: args = [] while True: args.append(parse_arg(ps)) if not ps.accept(TokenKind.COMMA): break return args def parse_idlist(ps: ParserState) -> List[str]: args = [] while True: args.append(parse_id(ps)) if not ps.accept(TokenKind.COMMA): break return args def parse_idlist_paren(ps: ParserState) -> List[str]: args = [] if ps.accept(TokenKind.LPAREN): if not ps.accept(TokenKind.RPAREN): args = parse_idlist(ps) ps.expectnext(TokenKind.RPAREN) return args def parse_exprlist(ps: ParserState) -> List[Any]: exprs = [] while True: exprs.append(parse_expr(ps)) if not ps.accept(TokenKind.COMMA): break return exprs def parse_exprlist_paren(ps: ParserState) -> List[Any]: exprs = [] if ps.accept(TokenKind.LPAREN): if not ps.accept(TokenKind.RPAREN): exprs = parse_exprlist(ps) ps.expectnext(TokenKind.RPAREN) return exprs def parse_gatecall(ps: ParserState): # expectnext(ps, [U, CX, IDENTIFIER]) t = ps.expectnext({TokenKind.U, TokenKind.CX, TokenKind.IDENTIFIER}) if t.kind == TokenKind.IDENTIFIER: name = t.val else: name = t.kind.name # U or CX # Check if we have parameters params = [] if ps.peektoken().kind == TokenKind.LPAREN: params = parse_exprlist_paren(ps) return QASMExpr("call", [name] + params) def parse_uop(ps: ParserState): # Gate call (name + params) gcall = parse_gatecall(ps) # Targets targets = parse_arglist(ps) ps.expectnext(TokenKind.SEMICOLON) return QASMExpr("unitary", [gcall] + targets) def parse_measure(ps: ParserState): ps.expectnext(TokenKind.MEASURE) qtarget = parse_arg(ps) ps.expectnext(TokenKind.ARROW) ctarget = parse_arg(ps) ps.expectnext(TokenKind.SEMICOLON) return QASMExpr("measure", [qtarget, ctarget]) def parse_reset(ps: ParserState): ps.expectnext(TokenKind.RESET) args = parse_arglist(ps) ps.expectnext(TokenKind.SEMICOLON) return QASMExpr("reset", args) def parse_barrier(ps: ParserState): ps.expectnext(TokenKind.BARRIER) args = parse_arglist(ps) ps.expectnext(TokenKind.SEMICOLON) return QASMExpr("barrier", args) def parse_if(ps: ParserState): ps.expectnext(TokenKind.IF) ps.expectnext(TokenKind.LPAREN) id_str = parse_id(ps) ps.expectnext(TokenKind.EQEQ) val = parse_unsigned_value(ps) ps.expectnext(TokenKind.RPAREN) qop = parse_qop(ps) condition = QASMExpr("call", ["==", id_str, val]) return QASMExpr("if", [condition, qop]) def parse_qop(ps: ParserState): nk = ps.peektoken().kind if nk in {TokenKind.U, TokenKind.CX, TokenKind.IDENTIFIER}: return parse_uop(ps) elif nk == TokenKind.BARRIER: return parse_barrier(ps) elif nk == TokenKind.MEASURE: return parse_measure(ps) elif nk == TokenKind.RESET: return parse_reset(ps) else: raise ParseError("Unexpected token in qop", ps.peektoken(), ps) def parse_goplist(ps: ParserState) -> List[QASMExpr]: gops = [] while True: nk = ps.peektoken().kind if nk in {TokenKind.IDENTIFIER, TokenKind.U, TokenKind.CX}: gops.append(parse_uop(ps)) elif nk == TokenKind.BARRIER: gops.append(parse_barrier(ps)) elif nk == TokenKind.MEASURE: gops.append(parse_measure(ps)) elif nk == TokenKind.RESET: gops.append(parse_reset(ps)) else: break return gops def parse_gatedecl(ps: ParserState): ps.expectnext(TokenKind.GATE) # Decl name and args t = ps.expectnext({TokenKind.U, TokenKind.CX, TokenKind.IDENTIFIER}) if t.kind == TokenKind.IDENTIFIER: decl_name = t.val else: decl_name = t.kind.name args = parse_idlist_paren(ps) targets = parse_idlist(ps) decl_sig = QASMExpr("unitary", [QASMExpr("call", [decl_name] + args)] + targets) ps.expectnext(TokenKind.LBRACE) body = QASMExpr("block", parse_goplist(ps)) ps.expectnext(TokenKind.RBRACE) return QASMExpr("gate", [decl_sig, body]) def parse_opaquedecl(ps: ParserState): ps.expectnext(TokenKind.OPAQUE) t = ps.expectnext({TokenKind.U, TokenKind.CX, TokenKind.IDENTIFIER}) if t.kind == TokenKind.IDENTIFIER: decl_name = t.val else: decl_name = t.kind.name args = parse_idlist_paren(ps) targets = parse_idlist(ps) decl_sig = QASMExpr("unitary", [QASMExpr("call", [decl_name] + args)] + targets) ps.expectnext(TokenKind.SEMICOLON) return QASMExpr("opaque", [decl_sig]) def parse_decl(ps: ParserState) -> QASMExpr: t = ps.expectnext({TokenKind.QREG, TokenKind.CREG}) type_kind = t.kind.name.lower() id_str = parse_id(ps) ps.expectnext(TokenKind.LSQUARE) size = parse_integer_value(ps) ps.expectnext(TokenKind.RSQUARE) ps.expectnext(TokenKind.SEMICOLON) return QASMExpr(type_kind, [id_str, size]) def parse_statement(ps: ParserState): nk = ps.peektoken().kind if nk in {TokenKind.QREG, TokenKind.CREG}: return parse_decl(ps) elif nk == TokenKind.GATE: return parse_gatedecl(ps) elif nk == TokenKind.OPAQUE: return parse_opaquedecl(ps) elif nk == TokenKind.IF: return parse_if(ps) elif nk == TokenKind.BARRIER: return parse_barrier(ps) elif nk in { TokenKind.MEASURE, TokenKind.RESET, TokenKind.U, TokenKind.CX, TokenKind.IDENTIFIER, }: return parse_qop(ps) else: raise ParseError("Unexpected statement", ps.peektoken(), ps) PARSED_INCLUDES: Dict[str, List[QASMExpr]] = {} def parse_include(ps: ParserState): ps.expectnext(TokenKind.INCLUDE) t = ps.expectnext(TokenKind.STRING) ps.expectnext(TokenKind.SEMICOLON) fname = t.val # Resolve file found_path = None for d in ps.includedirs: p = os.path.join(d, fname) if os.path.isfile(p): found_path = p break if not found_path: raise ParseError(f"Include file {fname} not found", t, ps) found_path = os.path.realpath(found_path) if found_path in PARSED_INCLUDES: return PARSED_INCLUDES[found_path] # Parse include with open(found_path, "r") as f: content = f.read() sub_lexer = Lexer(content) sub_ps = ParserState(sub_lexer, ps.includedirs) stmts = [] while sub_ps.peektoken().kind != TokenKind.ENDMARKER: stmts.append(parse_statement(sub_ps)) # Cache PARSED_INCLUDES[found_path] = stmts return stmts def parse_version(ps: ParserState): ps.expectnext(TokenKind.OPENQASM) version = parse_real_value(ps) ps.expectnext(TokenKind.SEMICOLON) if version != 2.0: raise ParseError(f"OpenQASM version {version} not supported", ps.t, ps) return version def parse_program(ps: ParserState): # Check for empty or comment only start? # Peek to see if OpenQASM header exists if ps.peektoken().kind == TokenKind.OPENQASM: version = parse_version(ps) else: version = 2.0 # Default if missing statements = [] while ps.peektoken().kind != TokenKind.ENDMARKER: if ps.peektoken().kind == TokenKind.INCLUDE: statements.extend(parse_include(ps)) else: statements.append(parse_statement(ps)) return QASMExpr("program", [version] + statements) def parseopenqasm(source: str, includedirs: List[str] = None): lexer = Lexer(source) ps = ParserState(lexer, includedirs) return parse_program(ps)