def __init__(self, comm_file_path): expression_spaced = Forward() expression = Forward() args_spaced = Forward() cb = Optional(',') + ')' # closing_brackets might include a ',' ob = Optional(' ') + '(' + Optional( ' ') # closing_brackets might include a ' ' value = (Or([ pyparsing_common.identifier.copy().setResultsName('id'), pyparsing_common.number.copy().setResultsName('number'), QuotedString("'").setResultsName('string') ])).setParseAction(Value).setResultsName('value') values = (ZeroOrMore( value.setResultsName('valueList', listAllMatches=True) + Optional(','))).setParseAction(Values) keyword = pyparsing_common.identifier.copy() keyword_argument = (keyword.setResultsName('keyword') + '=' + expression_spaced.setResultsName('expression') ).setParseAction(Keyword_argument) keyword_arguments = (keyword_argument.setResultsName( 'keyword_argument', listAllMatches=True) + ZeroOrMore(',' + keyword_argument.setResultsName( 'keyword_argument', listAllMatches=True)) ).setParseAction(Keyword_arguments) expression << (Or([ value, (ob + values.setResultsName('values') + cb), '_F' + ob + keyword_arguments.setResultsName('keyword_arguments') + cb, ob + expression.setResultsName('expression') + cb ])).setParseAction(Expression) expression_spaced << (Or([expression, ob + expression_spaced + cb])) left_side = pyparsing_common.identifier.setResultsName('left_side') operator_name = pyparsing_common.identifier.setResultsName( 'operator_name') paragraph = ( Optional(left_side + "=") + operator_name + ob + Optional(keyword_arguments.setResultsName('keyword_arguments')) + cb + Optional(';')).setParseAction(Paragraph) file = OneOrMore(paragraph).setResultsName( 'paragraphs').setParseAction(File) self.beam_data_model = file.parseFile(comm_file_path)
def parseTypes(path): msgs = set() types = {} for line in lineGen(path): number = Word(nums) word = Word(alphanums + "-_") wordList = Forward() wordList = word + ZeroOrMore(',' + word) par = (Literal('NetworkPartition').setResultsName('type') +\ '(' + Literal('Set') + '(' +\ wordList.setResultsName('p1') + ')' + ',' +\ Literal('Set') + '(' +\ wordList.setResultsName('p2') + ')' + \ ')') subType = (word + Optional(nestedExpr('(', ')'))).setResultsName('msg') msg = (Literal('MsgEvent').setResultsName('type') +\ '(' + word.setResultsName('src') + ',' +\ word.setResultsName('dst') + ',' +\ subType + ')') event = Word( nums ) +\ Literal('Unique') + "(" + (msg | par) + ',' +\ number.setResultsName('uid') + ')' result = event.parseString(line) key = result.uid if result.type == 'MsgEvent': msg = list2tuple( result.msg.asList() ) value = (result.type, result.src, result.dst, msg) msgs.add(msg) elif result.type == 'NetworkPartition': value = (result.type, result.p1, result.p2) types[key] = value return types
def parseTypes(path): msgs = set() types = {} for line in lineGen(path): number = Word(nums) word = Word(alphanums + "-_") wordList = Forward() wordList = word + ZeroOrMore(',' + word) par = (Literal('NetworkPartition').setResultsName('type') +\ '(' + Literal('Set') + '(' +\ wordList.setResultsName('p1') + ')' + ',' +\ Literal('Set') + '(' +\ wordList.setResultsName('p2') + ')' + \ ')') subType = (word + Optional(nestedExpr('(', ')'))).setResultsName('msg') msg = (Literal('MsgEvent').setResultsName('type') +\ '(' + word.setResultsName('src') + ',' +\ word.setResultsName('dst') + ',' +\ subType + ')') event = Word( nums ) +\ Literal('Unique') + "(" + (msg | par) + ',' +\ number.setResultsName('uid') + ')' result = event.parseString(line) key = result.uid if result.type == 'MsgEvent': msg = list2tuple(result.msg.asList()) value = (result.type, result.src, result.dst, msg) msgs.add(msg) elif result.type == 'NetworkPartition': value = (result.type, result.p1, result.p2) types[key] = value return types
def parser(text): """ str := \w+ str := '\w+' exp := Var=str exp := exp & exp exp := exp ^ exp """ # grammar #g_string = "'"+Word(alphas)+"'" | Word(alphas) g_quote = Literal("'").suppress() g_text = Regex("[\w\s\:\#\.]+").setResultsName("text") g_string = Optional(g_quote) + g_text + Optional(g_quote) g_equ = Literal("!=").setResultsName("connector") | Literal("=").setResultsName("connector") g_amp = Literal("&").setResultsName("connector") g_hat = Literal("^").setResultsName("connector") g_or = Literal("|").suppress() g_seq = Literal("->").setResultsName("connector") g_hash = Literal("#").setResultsName("hash") g_left_brack = Literal("[").suppress() g_right_brack = Literal("]").suppress() g_vals = Forward() g_vals << g_string + ZeroOrMore(Group(g_or + g_vals).setResultsName("or_group")) # working """ exp_basic = Group(Optional(g_hash) + g_string).setResultsName("left") + g_equ + Group(g_vals).setResultsName("right") exp = Group(exp_basic) exp = exp.setResultsName("left") + g_amp + exp.setResultsName("right") | \ g_left_brack + exp.setResultsName("left") + g_hat + exp.setResultsName("right") + g_right_brack | \ g_left_brack + exp.setResultsName("left") + g_seq + exp.setResultsName("right") + g_right_brack | \ exp_basic """ # recursion simpleq = Forward() complexq = Forward() exp = (simpleq | complexq).setResultsName("exp") exp_basic = Group(Group(Optional(g_hash) + g_string).setResultsName("left") + g_equ + Group(g_vals).setResultsName("right")) simpleq << (Group(exp_basic.setResultsName("left") + g_amp + simpleq.setResultsName("right")) | exp_basic) complexq << ( Group(g_left_brack + exp.setResultsName("left") + g_hat + exp.setResultsName("right") + g_right_brack) | \ Group(g_left_brack + exp.setResultsName("left") + g_seq + exp.setResultsName("right") + g_right_brack) ) return exp.parseString(text)
def parser(): global _parser if _parser is None: ParserElement.setDefaultWhitespaceChars("") lbrack = Literal("[") rbrack = Literal("]") lbrace = Literal("{") rbrace = Literal("}") lparen = Literal("(") rparen = Literal(")") reMacro = Suppress("\\") + oneOf(list("dwsZ")) escapedChar = ~reMacro + Combine("\\" + oneOf(list(printables))) reLiteralChar = "".join(c for c in string.printable if c not in r"\[]{}().*?+|") reRange = Combine(lbrack.suppress() + SkipTo(rbrack,ignore=escapedChar) + rbrack.suppress()) reLiteral = ( escapedChar | oneOf(list(reLiteralChar)) ) reDot = Literal(".") repetition = ( ( lbrace + Word(nums).setResultsName("count") + rbrace ) | ( lbrace + Word(nums).setResultsName("minCount")+","+ Word(nums).setResultsName("maxCount") + rbrace ) | oneOf(list("*+?")) ) reExpr = Forward() reGroup = (lparen.suppress() + Optional(Literal("?").suppress() + oneOf(list(":P"))).setResultsName("option") + reExpr.setResultsName("expr") + rparen.suppress()) reTerm = ( reLiteral | reRange | reMacro | reDot | reGroup ) reExpr << operatorPrecedence( reTerm, [ (repetition, 1, opAssoc.LEFT, create(Repetition)), (None, 2, opAssoc.LEFT, create(Sequence)), (Suppress('|'), 2, opAssoc.LEFT, create(Alternation)), ] ) reGroup.setParseAction(create(Group)) reRange.setParseAction(create(Range)) reLiteral.setParseAction(create(Character)) reMacro.setParseAction(create(Macro)) reDot.setParseAction(create(Dot)) _parser = reExpr return _parser
def parser(): global _parser if _parser is None: ParserElement.setDefaultWhitespaceChars("") lbrack = Literal("[") rbrack = Literal("]") lbrace = Literal("{") rbrace = Literal("}") lparen = Literal("(") rparen = Literal(")") reMacro = Suppress("\\") + oneOf(list("dwsZ")) escapedChar = ~reMacro + Combine("\\" + oneOf(list(printables))) reLiteralChar = "".join(c for c in string.printable if c not in r"\[]{}().*?+|") reRange = Combine(lbrack.suppress() + SkipTo(rbrack, ignore=escapedChar) + rbrack.suppress()) reLiteral = (escapedChar | oneOf(list(reLiteralChar))) reDot = Literal(".") repetition = ((lbrace + Word(nums).setResultsName("count") + rbrace) | (lbrace + Word(nums).setResultsName("minCount") + "," + Word(nums).setResultsName("maxCount") + rbrace) | oneOf(list("*+?"))) reExpr = Forward() reGroup = (lparen.suppress() + Optional(Literal("?").suppress() + oneOf(list(":P"))).setResultsName("option") + reExpr.setResultsName("expr") + rparen.suppress()) reTerm = (reLiteral | reRange | reMacro | reDot | reGroup) reExpr << operatorPrecedence(reTerm, [ (repetition, 1, opAssoc.LEFT, create(Repetition)), (None, 2, opAssoc.LEFT, create(Sequence)), (Suppress('|'), 2, opAssoc.LEFT, create(Alternation)), ]) reGroup.setParseAction(create(Group)) reRange.setParseAction(create(Range)) reLiteral.setParseAction(create(Character)) reMacro.setParseAction(create(Macro)) reDot.setParseAction(create(Dot)) _parser = reExpr return _parser
def build_grammer(): selectStmt = Forward() compoundselectStmt = Forward() subgraphselectStmt = Forward() sampleselectStmt = Forward() setStmt = Forward() selectToken = oneOf("select find get what search list", caseless=True) fromToken = Keyword("from", caseless=True) whereToken = Keyword("where", caseless=True) sampleToken =Keyword("sample",caseless=True) subgraphToken =Keyword("subgraph",caseless=True) neighborsToken =Keyword("neighbors",caseless=True) targetToken = oneOf("edges nodes node edge",caseless=True) ident = Word( alphas, alphanums + "_$").setName("identifier") columnName = Combine((oneOf("v u e")+"."+ ident)) | Combine(neighborsToken+"("+Word(nums).setResultsName("friends",listAllMatches=True)+")"+"."+ident) |ident whereExpression = Forward() runs_ = Keyword("number",caseless=True) and_ = Keyword("and", caseless=True) or_ = Keyword("or", caseless=True) in_ = Keyword("in", caseless=True) size_ = Keyword("size", caseless=True) identifier = Word(alphas+"_", alphanums+"_") E = CaselessLiteral("E") binop = oneOf("= != < > >= <= eq ne lt le gt ge", caseless=True) setop = oneOf("union intersect except", caseless=True) arithSign = Word("+-",exact=1) realNum = Combine( Optional(arithSign) + ( Word( nums ) + "." + Optional( Word(nums) ) | ( "." + Word(nums) ) ) + Optional( E + Optional(arithSign) + Word(nums) ) ) samplestmt = (sampleToken+"("+runs_+"="+Word( nums ).setResultsName("runs")+","+size_+"="+"["+Word( nums ).setResultsName("lb")+","+Word( nums ).setResultsName("sample")+"]"+")") subgraphstmt = (subgraphToken.setResultsName("type")+"("+Word(nums).setResultsName("startnode")+","+Word(nums).setResultsName("depth")+")") intNum = Combine( Optional(arithSign) + Word( nums ) + Optional( E + Optional("+") + Word(nums) ) ) columnRval = realNum | intNum | quotedString | columnName.setResultsName("column",listAllMatches=True) whereCondition = (columnName.setResultsName("column",listAllMatches=True)+ binop + columnRval )| ( columnName.setResultsName("column",listAllMatches=True) + in_ + "(" + columnRval +ZeroOrMore("," + columnRval) + ")" ) whereCondition2 = Group((columnName.setResultsName("column",listAllMatches=True)+ binop + columnRval )| ( columnName.setResultsName("column",listAllMatches=True) + in_ + "(" + columnRval +ZeroOrMore("," + columnRval) + ")" ) | ( "(" + whereExpression + ")" )) whereExpression << whereCondition + ZeroOrMore( ( and_ | or_ ) + whereExpression ) defstmt =ident.setResultsName( "graph")+"."+ targetToken.setResultsName( "type") + "="+ "{" + delimitedList( whereCondition2 ).setResultsName("compactwhere") + "}" function_call = identifier.setResultsName("func",listAllMatches=True) + "(" + ((delimitedList(identifier|Word(nums)).setResultsName("args",listAllMatches=True))) + ")" | identifier.setResultsName("func",listAllMatches=True) wfstmt = Optional(delimitedList(function_call)) selectStmt << ( selectToken + targetToken.setResultsName( "type" ) + fromToken + (ident.setResultsName( "graph"))+ Optional(whereToken + (whereExpression).setResultsName("where", listAllMatches=True) )) sampleselectStmt << ( selectToken +samplestmt+ targetToken.setResultsName( "type") + fromToken + (ident.setResultsName( "graph"))+ Optional(whereToken + (whereExpression).setResultsName("where", listAllMatches=True) )) subgraphselectStmt << ( selectToken +subgraphstmt + fromToken + (ident.setResultsName( "graph"))) compoundselectStmt << selectStmt.setResultsName("select",listAllMatches=True) + ZeroOrMore(setop.setResultsName("setop",listAllMatches=True) + selectStmt ) setStmt << ident.setResultsName("setname",listAllMatches=True) + ZeroOrMore (setop.setResultsName("setp",listAllMatches=True) + ident.setResultsName("setname")) SQL = sampleselectStmt|compoundselectStmt|subgraphselectStmt|setStmt bSQL = SQL SqlComment = "--" + restOfLine bSQL.ignore( SqlComment ) return bSQL
tMod = OneOrMore(Or(mkLit(s) for s in mods) ^ sizeMod).setParseAction(mkMod) tExpr = (lBvExpr | \ (xFun + tBase + to + sizeMod).setParseAction(pushXFun) | \ (funName + Optional(tMod) + Optional(tArgs))\ .setParseAction(pushTermFun)) var = Combine(percent + Word(alphanums)).setParseAction(pushExpr0( \ lambda i: Ident(i))) comment = Combine(Literal(";") + CharsNotIn("\n") + LineEnd()).suppress() comments = ZeroOrMore(comment).suppress() lineend = (LineEnd() + comments).suppress() tVarDef = (var + assign + tExpr + Optional(comment)).setParseAction(assignVar) side = OneOrMore(tVarDef).setParseAction(mkSide) nameLine = name + CharsNotIn("\n").setResultsName("name") + \ lineend.setParseAction(clearVars) preLine = (pre + lBoolExpr.setResultsName("pre") + (lineend | comment)) rule = (nameLine + \ Optional(preLine) + \ side.setResultsName("lhs") + \ Literal("=>") + \ side.setResultsName("rhs")).setParseAction(addRule) rules = OneOrMore(rule + comments) def testPre(s): print("testPre: " + s) try: r = preLine.parseString(s) print(" " + r['pre'][0].toString()) except Exception as exc: print("{}: {}".format(type(exc).__name__, exc))
insert_stmt = INSERT + INTO + table_name + VALUES +LPAR + insert_values + RPAR # Delete Statement # ================ delete_stmt = (DELETE + FROM +table_name + Optional(where_clause)) # Update Statement # ================ # <update> ::= UPDATE <table> # SET <list-set-clause> # [<where-clause>] # <list-set-clause> ::= <set-clause> [, <set-clause>]* # <set-clause> ::= <colname> = <update-source> # <update-source> ::= <arith-expr> update_source = arith_expr.setResultsName('update_source') set_clause = Group(column_name + equal_op + update_source) list_set_clauses = delimitedList(set_clause).setResultsName('list_set_clauses') update_stmt = (UPDATE + table_name + SET + list_set_clauses + Optional(where_clause)) # Select Statement # ================ # <select> ::= SELECT [DISTINCT] <select list> # <from-clause> # [<where-clause>] # [<order-by-clause>] # # <select list> ::= <start> | <derived-col> [<comma> <derived-col>]* # <derived-col> ::= <arith-expr> [AS <alias>]
def _setup_QASMParser(): """ Routine to initialise and return parsing blocks """ class _Op: """ Class to set up quantum operations """ def __init__(self, name, argParser, version="OPENQASM 2.0", qop=False, keyOverride=None): global cops global qops global _reservedKeys if name in qops or name in cops: raise IOError(dupTokenWarning.format("Operation", name)) self.operation = name if keyOverride is not None: self.parser = (keyOverride + argParser).addParseAction( lambda s, l, t: _override_keyword(t, name)) else: self.parser = CaselessKeyword(name)("keyword") + argParser self.version = parse_version(version) self.parser.addParseAction( lambda s, l, t: _set_version(t, self.version)) _reservedKeys.append(name) if qop: qops[name] = self else: cops[name] = self class _Routine(): """ Class to set up quantum gates, circuits, etc. """ def __init__(self, name, pargs=False, spargs=False, gargs=False, qargs=False, returnables=False, prefixes=None, version="OPENQASM 2.0"): global blocks global _reservedKeys if name in qops or name in cops: raise IOError(dupTokenWarning.format("Routine", name)) self.operation = name self.parser = Keyword(name)("keyword") + validName("gateName") if prefixes: localPrefixParser = Each(map(Optional, map( Keyword, prefixes))).addParseAction(prefix_setter) else: localPrefixParser = prefixParser self.parser = localPrefixParser + self.parser # Handle different args req = [] if pargs: req.append(Optional(pargParser)("pargs")) if spargs: req.append(Optional(spargParser)("spargs")) if gargs: req.append(Optional(gargParser)("gargs")) self.parser = self.parser + Each(req) if qargs: self.parser = self.parser + qargParser("qargs") if returnables: self.parser = self.parser + Optional(returnParser) self.version = parse_version(version) self.parser.addParseAction( lambda s, l, t: _set_version(t, self.version)) _reservedKeys.append(name) blocks[name] = self class _Block(): """ Class to set up blocks such as if, for, etc. """ def __init__(self, name, detParser, version="OPENQASM 2.0"): global blocks global _reservedKeys self.operation = name self.parser = Keyword(name)("keyword") + detParser self.version = parse_version(version) self.parser.addParseAction( lambda s, l, t: _set_version(t, self.version)) _reservedKeys.append(name) blocks[name] = self sign = Word("+-", exact=1) number = Word(nums) expo = Combine(CaselessLiteral("e") + Optional(sign) + number).setResultsName("exponent") pi = CaselessKeyword("pi") bitstring = Combine(OneOrMore(oneOf("0 1")) + Literal("b")) integer = Combine(number + Optional(expo)) real = Combine( Optional(sign) + (("." + number) ^ (number + "." + Optional(number))) + Optional(expo)) validName = Forward() lineEnd = Literal(";") _is_ = Keyword("to").suppress() _in_ = Keyword("in") _to_ = Literal("->").suppress() commentSyntax = "//" commentOpenStr = "/*" commentCloseStr = "*/" commentOpenSyntax = Literal(commentOpenStr) commentCloseSyntax = Literal(commentCloseStr) dirSyntax = "***" dirOpenStr = f"{dirSyntax} begin" dirCloseStr = f"{dirSyntax} end" dirSyntax = Keyword(dirSyntax) dirOpenSyntax = CaselessLiteral(dirOpenStr) dirCloseSyntax = CaselessLiteral(dirCloseStr) intFunc = oneOf("abs powrem countof fllog") realFunc = oneOf("abs powrem arcsin arccos arctan sin cos tan exp ln sqrt") boolFunc = oneOf("andof orof xorof") inL, inS, inR = map(Suppress, "[:]") vBar = Suppress("|") bSlash = Suppress("\\") brL, brR = map(Suppress, "()") intExp = Forward() realExp = Forward() boolExp = Forward() index = intExp.setResultsName("index") interval = Optional(intExp.setResultsName("start"), default=None) + inS \ + Optional(intExp.setResultsName("end"), default=None) \ + Optional(inS + Optional(intExp.setResultsName("step"), default=1)) interRef = Group(inL + interval + inR) loopRef = Group( inL + intExp.setResultsName("start") + inS + intExp.setResultsName("end") + Optional(inS + Optional(intExp.setResultsName("step"), default=1)) + inR) ref = inL + Group(delimitedList(index ^ interval))("ref") + inR regNoRef = validName("var") regRef = Group(validName("var") + Optional(ref)) regMustRef = Group(validName("var") + ref) regListNoRef = Group(delimitedList(regNoRef)) regListRef = Group(delimitedList(regRef)) inPlaceAlias = vBar + regListRef + vBar validQarg = regRef | inPlaceAlias aliasQarg = Group(regRef) | inPlaceAlias inPlaceCreg = bSlash + delimitedList(regRef | bitstring) + bSlash validCreg = (regRef | inPlaceCreg) def set_maths_type(toks, mathsType): """ Set logical or integer or floating point """ toks["type"] = mathsType intVar = integer | regRef realVar = real | integer | pi | regRef boolVar = interRef | regRef | realExp | intExp | validCreg | bitstring intFuncVar = (intFunc + brL + Group(Optional(delimitedList(intVar)))("args") + brR).setParseAction(Function) realFuncVar = ((realFunc ^ intFunc) + brL + Group(Optional(delimitedList(realVar)))("args") + brR).setParseAction(Function) boolFuncVar = (boolFunc + brL + Group(Optional(delimitedList(boolVar)))("args") + brR).setParseAction(Function) mathOp = [(oneOf("- +"), 1, opAssoc.RIGHT, Binary), (oneOf("^"), 2, opAssoc.LEFT, Binary), (oneOf("* / div"), 2, opAssoc.LEFT, Binary), (oneOf("+ -"), 2, opAssoc.LEFT, Binary)] logOp = [(oneOf("! not"), 1, opAssoc.RIGHT, Binary), (oneOf("and or xor"), 2, opAssoc.LEFT, Binary), (oneOf("< <= == != >= >"), 2, opAssoc.LEFT, Binary), (oneOf("in"), 2, opAssoc.LEFT, Binary)] intExp <<= infixNotation( intFuncVar | intVar, mathOp).setParseAction(lambda s, l, t: set_maths_type(t, "int")) realExp <<= infixNotation( realFuncVar | realVar, mathOp).setParseAction(lambda s, l, t: set_maths_type(t, "float")) boolExp <<= infixNotation( boolFuncVar | boolVar, logOp).setParseAction(lambda s, l, t: set_maths_type(t, "bool")) mathExp = intExp ^ realExp ^ boolExp cregExp = bitstring("bit") ^ validCreg("reg") prefixes = ["unitary"] callMods = ["CTRL", "INV"] def prefix_setter(toks): """ Pull out prefixes of gate calls and add them into list """ for prefix in prefixes: toks[prefix] = prefix in toks.asList() prefixParser = Each(map(Optional, map(Keyword, prefixes))).addParseAction(prefix_setter) pargParser = brL + delimitedList(validName)("pargs") + brR spargParser = inL + delimitedList(validName)("spargs") + inR gargParser = ungroup( nestedExpr("<", ">", delimitedList(ungroup(validName)), None)) qargParser = delimitedList(regRef) callQargParser = delimitedList(validQarg) callPargParser = brL + delimitedList(realExp) + brR callSpargParser = inL + delimitedList(intExp) + inR fullArgParser = Each( (Optional(pargParser("pargs")), Optional(spargParser("spargs")), Optional(gargParser("gargs")))) callArgParser = Each( (Optional(callPargParser("pargs")), Optional(callSpargParser("spargs")), Optional(gargParser("gargs")))) returnParser = Optional(_to_ + validCreg("byprod")) modifiers = ZeroOrMore(Combine(oneOf(callMods) + Suppress("-"))) commentLine = Literal(commentSyntax).suppress() + restOfLine("comment") commentBlock = cStyleComment("comment").addParseAction( removeQuotes).addParseAction(removeQuotes) comment = commentLine | commentBlock comment.addParseAction(lambda s, l, t: _set_version(t, (0, 0, 0))) directiveName = Word(alphas).setParseAction(downcaseTokens) directiveArgs = CharsNotIn(";") _Op("directive", directiveName("directive") + Suppress(White() * (1, )) + directiveArgs("args"), version="REQASM 1.0", keyOverride=(~dirOpenSyntax + ~dirCloseSyntax + dirSyntax)) def split_args(toks): """ Split directive arguments out """ toks[0]["keyword"] = "directive" toks[0]["args"] = toks[0]["args"].strip().split(" ") directiveStatement = directiveName("directive") + restOfLine("args") + \ Group(ZeroOrMore(Combine(Optional(White(" ")) + ~dirCloseSyntax + Word(printables+" "))))("block") directiveBlock = ungroup( nestedExpr( dirOpenSyntax, dirCloseSyntax, content=directiveStatement, ignoreExpr=(comment | quotedString )).setWhitespaceChars("\n").setParseAction(split_args)) directiveBlock.addParseAction(lambda s, l, t: _set_version(t, (2, 1, 0))) # Programming lines _Op("version", Empty(), version=(0, 0, 0), keyOverride=Combine( oneOf(versions)("type") + White() + real("versionNumber"))("version")) _Op("include", quotedString("file").addParseAction(removeQuotes)) # Gate-like structures _Op("opaque", validName("name") + fullArgParser + Optional(qargParser("qargs")) + returnParser, keyOverride=prefixParser + "opaque") _Routine("gate", pargs=True, qargs=True) _Routine("circuit", pargs=True, qargs=True, spargs=True, returnables=True, version="REQASM 1.0") # Variable-like structures _Op("creg", regRef("arg")) _Op("qreg", regRef("arg")) _Op("cbit", Group(regNoRef)("arg"), version="REQASM 1.0") _Op("qbit", Group(regNoRef)("arg"), version="REQASM 1.0") _Op("defAlias", regMustRef("alias"), keyOverride="alias", version="REQASM 1.0") # No more on-definition aliases _Op("alias", regRef("alias") + _is_ + aliasQarg("target"), keyOverride="set", version="REQASM 1.0") _Op("val", validName("var") + Literal("=").suppress() + mathExp("val"), version="REQASM 1.0") _Op("set", (Group(regRef)("var") ^ inPlaceCreg("var")) + Literal("=").suppress() + cregExp("val"), version="REQASM 1.0") # Operations-like structures _Op("measure", regRef("qreg") + _to_ + regRef("creg"), qop=True) _Op("barrier", regListNoRef("args")) _Op("output", regRef("value"), qop=True, version="REQASM 1.0") _Op("reset", regRef("qreg")) _Op("exit", Empty(), version="REQASM 1.0") _Op("free", validName("target"), version="REQASM 1.0") _Op("next", validName("loopVar"), qop=True, version="REQASM 1.0") _Op("finish", (Literal("quantum process") | validName)("loopVar"), qop=True, version="REQASM 1.0") _Op("end", validName("process"), qop=True, version="REQASM 1.0") # Special gate call handler callGate = Combine(Group(modifiers)("mods") + \ validName("gate")) + \ callArgParser + \ callQargParser("qargs").addParseAction(lambda s, l, t: _override_keyword(t, "call")) + \ returnParser callGate.addParseAction(lambda s, l, t: _set_version(t, (1, 2, 0))) # Block structures _Block("for", validName("var") + _in_ + loopRef("range"), version="REQASM 1.0") _Block("if", "(" + boolExp("cond") + ")", version="REQASM 1.0") _Block("while", "(" + boolExp("cond") + ")", version="OMEQASM 1.0") qopsParsers = list(map(lambda qop: qop.parser, qops.values())) + [callGate, directiveBlock] blocksParsers = list(map(lambda block: block.parser, blocks.values())) _Op("if", blocks["if"].parser + Group(Group(Group(Or(qopsParsers))))("block"), version="OPENQASM 2.0", keyOverride=Empty()) _Op("for", blocks["for"].parser + Group(Group(Group(Or(qopsParsers))))("block"), version="REQASM 1.0", keyOverride=Empty()) _Op("while", blocks["while"].parser + Group(Group(Group(Or(qopsParsers))))("block"), version="OMEQASM 1.0", keyOverride=Empty()) # Set-up line parsers reservedNames = Or(map(Keyword, _reservedKeys)) validName <<= (~reservedNames) + Word(alphas, alphanums + "_") copsParsers = list(map(lambda cop: cop.parser, cops.values())) operations = (( (Or(copsParsers) ^ Or(qopsParsers)) | # Classical/Quantum Operations callGate | # Gate parsers White() # Blank Line ) + lineEnd.suppress()) ^ directiveBlock # ; or Directives validLine = Forward() codeBlock = nestedExpr("{", "}", Suppress(White()) ^ Group(validLine), (quotedString)) validLine <<= ( ((operations + Optional(comment)) ^ (Or(blocksParsers) + codeBlock("block") + Optional(lineEnd)) ^ comment)) # Whole line comment testLine = Forward() dummyCodeBlock = nestedExpr( "{", "}", testLine, (directiveBlock | quotedString | comment)) + Optional(lineEnd) ignoreSpecialBlocks = (~commentOpenSyntax + ~commentCloseSyntax + ~dirOpenSyntax + ~dirCloseSyntax) testLine <<= ( comment | # Comments directiveBlock | # Directives (ignoreSpecialBlocks + ZeroOrMore(CharsNotIn("{}")) + dummyCodeBlock) | # Block operations (ignoreSpecialBlocks + ZeroOrMore(CharsNotIn("{};")) + lineEnd) ) # QASM Instructions testKeyword = (dirSyntax.setParseAction( lambda s, l, t: _override_keyword(t, "directive")) | Word(alphas)("keyword")) code = (Group(directiveBlock)) | Group(validLine) return code, testLine, testKeyword, reservedNames, mathExp
(oneOf("* /"), 2, opAssoc.LEFT, FOLBinOp), (oneOf("+ -"), 2, opAssoc.LEFT, FOLBinOp), (oneOf("< <= > >= "), 2, opAssoc.LEFT, FOLBinOp), ], ) # main parser for FOL formula formula = Forward() formula.ignore(comment) forall_expression = Group( forall.setResultsName("quantifier") + delimitedList(variable).setResultsName("vars") + colon + formula.setResultsName("args") ).setParseAction(FOLQuant) exists_expression = Group( exists.setResultsName("quantifier") + delimitedList(variable).setResultsName("vars") + colon + formula.setResultsName("args") ).setParseAction(FOLQuant) operand = forall_expression | exists_expression | boolean | term # specify the precedence -- highest precedence first, lowest last operator_list = [(not_, 1, opAssoc.RIGHT, FOLUnOp)] # operator_list += [ (equals, 2, opAssoc.RIGHT, FOLBinOp),
column_val = real_num | int_num | quotedString | column_idr select_stmt = Forward() where_expr = Forward() where_cond = Group( ( column_idr.setResultsName('left_operand') + binary_op.setResultsName('operator') + column_val.setResultsName('right_operand') ) | ( column_idr.setResultsName('left_operand') + in_ + Suppress("(") + delimitedList( column_val ).setResultsName('right_operand') + Suppress(")") ).setResultsName('in_list_condition') | ( column_idr.setResultsName('left_operand') + in_ + Suppress("(") + select_stmt.setResultsName('right_operand') + Suppress(")") ).setResultsName('in_query_condition') | ( Suppress("(") + where_expr + Suppress(")") ) ) group_by_expr = Group(column_idr + ZeroOrMore( "," + column_idr )) where_expr << where_cond + ZeroOrMore( (and_ | or_) + where_expr ) on_ = Keyword('on', caseless=True) join = ((oneOf('left right') + 'join' ) | (Optional('inner') + 'join') ).setResultsName('join_type') from_clause = table_idr.setResultsName('relation') + ZeroOrMore(Group( join + table_idr.setResultsName('relation') + on_ + where_cond.setResultsName('join_conditions') )).setResultsName('joins', listAllMatches=True)
# Individual parts of the signature SIGNATURE_POSITIONAL = ( (delimitedList(PARAMETER) + Suppress(",") + Suppress("/")).setName("[NAME ':'] TYPE {',' [NAME ':'] TYPE} ',' '/'" ).setResultsName("positional")) SIGNATURE_MIXED = (delimitedList(PARAMETER).setName( "[NAME ':'] TYPE {',' [NAME ':'] TYPE}").setResultsName("mixed")) SIGNATURE_ARGS = (Suppress("*") + (Optional( PARAMETER, default=None).setResultsName("args"))).setName("'*' [TYPE]") SIGNATURE_KEYWORDS = (delimitedList(NAMED_PARAMETER).setName( "NAME ':' TYPE {',' NAME ':' TYPE}").setResultsName("keywords")) SIGNATURE_KWARGS = ( Suppress("**") + Group(PARAMETER).setResultsName("kwargs")).setName("'**' TYPE") SIGNATURE_RETURN = Suppress("->") + TYPE.setResultsName("returns").setName( "-> TYPE") # Match for the entire parameter list # This does a recursive ``head + Optional(delimiter + tail) or tail``. This # creates any combination of optional tails starting from any head. # Based on the Python 3.8 Function Definitions grammar PARAMETER_LIST_STARARGS = MatchFirst(( SIGNATURE_ARGS + Optional(Suppress(",") + SIGNATURE_KEYWORDS) + Optional(Suppress(",") + SIGNATURE_KWARGS), SIGNATURE_KWARGS, )) PARAMETER_LIST_NO_POSONLY = MatchFirst(( SIGNATURE_MIXED + Optional(Suppress(",") + PARAMETER_LIST_STARARGS), PARAMETER_LIST_STARARGS, )) PARAMETER_LIST = MatchFirst((
trueOrFalse = trueToken | falseToken facetOrderBy = hitsToken | valueToken facetSpec = Group(columnName + ":" + "(" + trueOrFalse + "," + intNum + "," + intNum + "," + facetOrderBy + ")") browseByClause = (browseByToken + "(" + delimitedList(facetSpec).setResultsName("facet_specs") + ")") groupByClause = (groupByToken + columnName.setResultsName("groupby") + Optional(topToken + intNum.setResultsName("max_per_group"))) selectStmt << (selectToken + ('*' | columnNameList).setResultsName("columns") + fromToken + ident.setResultsName("index") + Optional((whereToken + whereExpression.setResultsName("where"))) + ZeroOrMore(orderByClause | limitClause | browseByClause | groupByClause ) + Optional(";") ) simpleSQL = selectStmt # Define comment format, and ignore them sqlComment = "--" + restOfLine simpleSQL.ignore(sqlComment) logger = logging.getLogger("sensei_client")
Optional(arith_sign) + Word(nums) + Optional(E + Optional('+') + Word(nums))) column_val = real_num | int_num | quotedString | column_idr select_stmt = Forward() where_expr = Forward() where_cond = Group( (column_idr.setResultsName('left_operand') + binary_op.setResultsName('operator') + column_val.setResultsName('right_operand')) | (column_idr.setResultsName('left_operand') + in_ + Suppress("(") + delimitedList(column_val).setResultsName('right_operand') + Suppress(")")).setResultsName('in_list_condition') | (column_idr.setResultsName('left_operand') + in_ + Suppress("(") + select_stmt.setResultsName('right_operand') + Suppress(")")).setResultsName('in_query_condition') | (Suppress("(") + where_expr + Suppress(")"))) group_by_expr = Group(column_idr + ZeroOrMore("," + column_idr)) where_expr << where_cond + ZeroOrMore((and_ | or_) + where_expr) on_ = Keyword('on', caseless=True) join = ((oneOf('left right') + 'join') | (Optional('inner') + 'join')).setResultsName('join_type') from_clause = table_idr.setResultsName('relation') + ZeroOrMore( Group(join + table_idr.setResultsName('relation') + on_ + where_cond.setResultsName('join_conditions'))).setResultsName( 'joins', listAllMatches=True)
def parser(text): var_any = Literal("_") p = Regex("[\w:]+").setResultsName("text") var_any = Regex("_") #handled by p anyway attribute = Literal("@").suppress() eq = Literal("=").suppress() closure = (Literal("?") | Literal("*") | Literal("+")).setResultsName("closure") test = Literal("^").setResultsName("modifier") + p | p + Literal("$").setResultsName("modifier") | p #| var_any axis = (Literal("\\\\*") | \ Literal("\\\\") | \ Literal("\\") | \ Literal(".") | \ Literal("//*") | \ Literal("//") | \ Literal("/") | \ Literal("-->") | \ Literal("<--") | \ Literal("->") | \ Literal("<-") | \ Literal("==>") | \ Literal("<==") | \ Literal("=>") | \ Literal("<=")).setResultsName("connector") g_left_brack = Literal("[").suppress() g_right_brack = Literal("]").suppress() # working """ abspath = Forward() locstep = Forward() node = test.setResultsName("node") attr_test = Group(attribute.suppress() + node.setResultsName("attr") + eq.suppress() + node.setResultsName("attr_val")).setResultsName("attr_test") predicate = (Group(Literal("[").suppress() + attr_test + Literal("]").suppress()).setResultsName("predicate") |\ Group(Literal("[").suppress() + abspath + Literal("]").suppress()).setResultsName("predicate")) locstep << Group(axis.setResultsName("axis") + node + \ Optional(predicate + Optional(closure).setResultsName("closure"))).setResultsName("locstep") abs2 = abspath abspath << ( Group(locstep.setResultsName("left_step") + abs2).setResultsName("abspath") | \ locstep.setResultsName("right_step") ) # TODO locpath = abspath fexpr = locpath.setResultsName("exp") """ # clean locpath = Forward() steps = Forward() fexpr = locpath.setResultsName("exp") attr_test = Group(attribute + p.setResultsName("attr") + eq + p.setResultsName("attr_val")) pred_opt = (fexpr.setResultsName("predicate") | attr_test.setResultsName("attr_test")) # connector order handling is the same as EmuQL, but the root lacks a left, as it refers to context node nodetest = Group(test + Optional(g_left_brack + pred_opt + g_right_brack + Optional(closure))) steps << ( Group(nodetest("left") + axis + steps("right")) | \ Group(test + Optional(g_left_brack + pred_opt + g_right_brack + Optional(closure)))) locpath << Group(axis + steps.setResultsName("right")) return fexpr.parseString(text)
) where_clause = CKeyword('WHERE') + W + expression group_by_clause = CKeyword('GROUP BY') + W + comma_list(expression) + \ Optional(W + CKeyword('HAVING') + W + expression) order_by_clause = CKeyword('ORDER BY') + W + comma_list(ordering_term) limit_clause = CKeyword('LIMIT') + W + expression + \ Optional(( (W + CKeyword('OFFSET') + W) | (OW + ',' + OW)) + expression) # N.B. this doesn't account for compound operators (union, intersect...) select << (\ CKeyword('SELECT') + W + Optional((CKeyword('DISTINCT') | CKeyword('ALL')) + W) + \ result_column_list.setResultsName("result_columns") + \ Optional(W + CKeyword('FROM') + W + join_source.setResultsName("join_source")) + \ Optional(W + where_clause).setResultsName("where") + \ Optional(W + group_by_clause).setResultsName("group_by") + \ Optional(W + order_by_clause).setResultsName("order_by") + \ Optional(W + limit_clause).setResultsName("limit") ) SQL_select = pyparsing.StringStart() + OW + select + Optional(';') + pyparsing.StringEnd() if __name__ == '__main__': ''' def dbgStart(s, loc, grammar): print 'Starting', s def dbgSuccess(s, start, end, grammar, match): # print 'Success', s
orderByExpression = Group( delimitedList(columnDef + Optional(CaselessLiteral("DESC") | CaselessLiteral("ASC")))) # LIMIT limitExpression = intNum # OFFSET offsetExpression = intNum # define the grammar selectColumnList = Group(delimitedList(Group(columnDef + aliasDef))) selectStmt << ( selectToken + ('*' | selectColumnList).setResultsName("columns") + fromToken + tableNameList.setResultsName("tables") + Optional(whereToken + whereExpression.setResultsName("where"), "") + Optional(groupByToken + groupByExpression.setResultsName("groupby"), "") + Optional(orderByToken + orderByExpression.setResultsName("orderby"), "") + Optional(limitToken + limitExpression.setResultsName("limit"), "") + Optional(offsetToken + offsetExpression.setResultsName("offset"), "")) sql_parser = selectStmt # + stringEnd sqlComment = "--" + restOfLine # ignore comments sql_parser.ignore(sqlComment) ########NEW FILE######## __FILENAME__ = version VERSION = "0.3"
def parse(input_string): def flatten_binary_operators(position, source, flattened_tokens): while len(flattened_tokens) >= 3: lhs, type_call, rhs = flattened_tokens[:3] flattened_tokens = [type_call(position, source, lhs, rhs)] + flattened_tokens[3:] return flattened_tokens[0] def flatten_unary_operators(position, source, flattened_tokens): type_call = flattened_tokens[0] return type_call(position, source, flattened_tokens[1]) # Packrat ParserElement.enablePackrat() lit_form = Suppress("form") lit_if = Suppress("if") lit_else = Suppress("else") lit_l_curly = Suppress("{") lit_r_curly = Suppress("}") lit_l_paren = Suppress("(") lit_r_paren = Suppress(")") lit_colon = Suppress(":") lit_assign_op = Suppress("=") lit_op_multiplication = Literal("*").setParseAction(lambda _: ast.Multiplication) lit_op_division = Literal("/").setParseAction(lambda _: ast.Division) lit_op_subtract = Literal("-").setParseAction(lambda _: ast.Subtraction) lit_op_addition = Literal("+").setParseAction(lambda _: ast.Addition) lit_op_positive = Literal("+").setParseAction(lambda _: ast.Positive) lit_op_negative = Literal("-").setParseAction(lambda _: ast.Negative) lit_op_not = Literal("!").setParseAction(lambda _: ast.Negation) lit_op_lower_exclusive = Literal("<").setParseAction(lambda _: ast.LowerExclusive) lit_op_lower_inclusive = Literal("<=").setParseAction(lambda _: ast.LowerInclusive) lit_op_greater_inclusive = Literal(">=").setParseAction(lambda _: ast.GreaterInclusive) lit_op_greater_exclusive = Literal(">").setParseAction(lambda _: ast.GreaterExclusive) lit_op_equality = Literal("==").setParseAction(lambda _: ast.Equality) lit_op_inequality = Literal("!=").setParseAction(lambda _: ast.Inequality) lit_op_and = Literal("&&").setParseAction(lambda _: ast.And) lit_op_or = Literal("||").setParseAction(lambda _: ast.Or) type_money = Literal("money").setParseAction( lambda source, position, _: ast.Money(position, source)) type_integer = Literal("integer").setParseAction( lambda source, position, _: ast.Integer(position, source)) type_boolean = Literal("boolean").setParseAction( lambda source, position, _: ast.Boolean(position, source)) type_string = Literal("string").setParseAction( lambda source, position, _: ast.String(position, source)) data_types = (type_money | type_integer | type_boolean | type_string) true = Literal("true").setParseAction( lambda source, position, _: ast.Boolean(position, source, True)) false = Literal("false").setParseAction( lambda source, position, _: ast.Boolean(position, source, False)) boolean = (true | false) integer = Word(nums).setParseAction( lambda source, position, parsed_tokens: ast.Integer(position, source, int(parsed_tokens[0]))) money = Combine(Word(nums) + Literal(".") + Word(nums)).setParseAction( lambda source, position, parsed_tokens: ast.Money(position, source, float(parsed_tokens[0]))) number = (money | integer) string = QuotedString("'", unquoteResults=True)\ .setParseAction( lambda source, position, parsed_tokens: ast.String(position, source, str(parsed_tokens[0]))) reserved_words = (lit_form | lit_if | lit_else | boolean | number | data_types) name = ~reserved_words + Word(alphas, alphanums + '_').setResultsName( 'identifier').setParseAction( lambda source, position, parsed_tokens: ast.Identifier(position, source, parsed_tokens[0])) operand_arith = (number | boolean | name | string) operand_list_arith = [ (lit_op_positive | lit_op_negative | lit_op_not, 1, opAssoc.RIGHT, lambda source, position, flattened_tokens: flatten_unary_operators(position, source, *flattened_tokens)), (lit_op_multiplication | lit_op_division, 2, opAssoc.LEFT, lambda source, position, flattened_tokens: flatten_binary_operators(position, source, *flattened_tokens)), (lit_op_addition | lit_op_subtract, 2, opAssoc.LEFT, lambda source, position, flattened_tokens: flatten_binary_operators(position, source, *flattened_tokens)), ] operand_list_bool = [ (lit_op_lower_inclusive | lit_op_greater_inclusive | lit_op_greater_exclusive | lit_op_lower_exclusive, 2, opAssoc.LEFT, lambda source, position, flattened_tokens: flatten_binary_operators(position, source, *flattened_tokens)), (lit_op_equality | lit_op_inequality, 2, opAssoc.LEFT, lambda source, position, flattened_tokens: flatten_binary_operators(position, source, *flattened_tokens)), (lit_op_and, 2, opAssoc.LEFT, lambda source, position, flattened_tokens: flatten_binary_operators(position, source, *flattened_tokens)), (lit_op_or, 2, opAssoc.LEFT, lambda source, position, flattened_tokens: flatten_binary_operators(position, source, *flattened_tokens)), ] literal_precedence = infixNotation( operand_arith, (operand_list_arith + operand_list_bool) ) expression = \ OneOrMore( literal_precedence | (lit_l_paren + literal_precedence + lit_r_paren) ) field = Forward() field_assignment = Forward() field_statement = ( QuotedString('"', unquoteResults=True).setResultsName("title") + name.setResultsName("identifier") + lit_colon + data_types.setResultsName("data_type") ) field <<= field_statement field.setParseAction(lambda source, position, parsed_tokens: ast.Field(position, source, *parsed_tokens)) field_assignment <<= field_statement + lit_assign_op + expression field_assignment.setParseAction( lambda source, position, parsed_tokens: ast.Assignment(position, source, *parsed_tokens)) field_order = field_assignment | field conditional_if = Forward() conditional_if_else = Forward() statement = Forward() body = Forward() if_statement = lit_if + lit_l_paren + expression + lit_r_paren + body conditional_if <<= if_statement conditional_if.setParseAction(ast.If) conditional_if_else <<= ( if_statement + Optional(lit_else + body).setResultsName('else_statement') ) conditional_if_else.setParseAction(ast.IfElse) conditional = conditional_if_else | conditional_if statement <<= (field_order | conditional) body <<= lit_l_curly + OneOrMore(statement) + lit_r_curly body.addParseAction(lambda parsed_tokens: [parsed_tokens.asList()]) body.setResultsName('statement_list') form = (lit_form + name + body)\ .addParseAction(lambda parsed_tokens: ast.Form(*parsed_tokens))\ .setResultsName('form')\ .parseWithTabs() return form.parseString(input_string).form
def parse(self, argument): """Procedure to parse constructor information. Variables: argument: Data to be parsed. """ # pyparsing syntax parser definition classQualifier = Forward() classQualifierRegex = Regex(r'[a-zA-Z_0-9]+::') classQualifier << ZeroOrMore(' ') + classQualifierRegex + \ ZeroOrMore(classQualifier) className = Regex(r'[a-zA-Z_0-9]+') classAll = (ZeroOrMore(classQualifier) + className) vectorWord = Forward() vectorWord << ((ZeroOrMore(' ') + 'std::vector<' + ZeroOrMore(' ') + \ vectorWord + ZeroOrMore(' ') + '>') | classAll ) anyString = ( Regex(r'(.*)') ) .\ setResultsName('parameters_text') function = vectorWord.setResultsName('return_type') + \ ZeroOrMore(' ') + Combine(('operator()' | classAll)).\ setResultsName('function_name') + anyString #parse argument parse = None try: parse = function.parseString(argument, True) except ParseException as err: Logger().debug(err.line) Logger().debug(str(err)) Logger().error('memberfunction parsing error "%s"' % argument) sys.exit(5) try: Logger().debug('entering conversion ...') print(parse) #set return_type and function_name self.return_type = '' for item in parse: if item != parse['function_name']: self.return_type = self.return_type + item else: break Logger().debug('memberfunction return_type %s' % self.return_type) text = self.return_type + ' ReturnType' self.return_type_parameter = Parameter(text) self.function_name = parse['function_name'] Logger().debug('memberfunction function_name %s' % self.function_name) Logger().debug('memberfunction parameter_list:') parameters_text = parse['parameters_text'][1:-1] #analyse parameter list - first step: include object parameter first_parameter = 'std::string ObjectId ' if parameters_text: parameters_text = first_parameter + ', ' + parameters_text else: parameters_text = first_parameter # parse argument list if parameters_text: liste = parameters_text.split(',') Logger().debug(liste) pos = 0 while pos < len(liste): text = liste[pos].strip() count = self.get_brackets(text) while count != 0 and pos < len(liste): pos += 1 if pos < len(liste): text = text + ',' + liste[pos] count = self.get_brackets(text) Logger().debug('processing ' + text + ' ' + str(count)) if text and count == 0: parameter = Parameter(text) self.parameter_list.append(parameter) else: Logger().error( 'memberfunction error parameter "%s" in \ "%s" at position %d.' % (text, liste, pos)) sys.exit(5) pos += 1 Logger().debug('leaving conversion ...') except: Logger().error('memberfunction conversion error "%s"' % argument) sys.exit(5)