def __init__(self): # create parsing grammer sQStringLiteral = pyparsing.QuotedString("'") sQStringLiteral.setParseAction( lambda s, loc, toks: StringLiteral(s, loc, toks, False)) dQStringLiteral = pyparsing.QuotedString('"', '\\') dQStringLiteral.setParseAction( lambda s, loc, toks: StringLiteral(s, loc, toks, True)) stringLiteral = sQStringLiteral | dQStringLiteral functionCall = pyparsing.Forward() functionArg = stringLiteral | functionCall functionCall << pyparsing.Word(pyparsing.alphas, pyparsing.alphanums+'-') + \ pyparsing.Suppress('(') + \ pyparsing.Optional(functionArg + pyparsing.ZeroOrMore(pyparsing.Suppress(',') + functionArg)) + \ pyparsing.Suppress(')') functionCall.setParseAction( lambda s, loc, toks: FunctionCall(s, loc, toks)) predExpr = pyparsing.infixNotation(stringLiteral ^ functionCall, [ ('!', 1, pyparsing.opAssoc.RIGHT, lambda s, loc, toks: NotOperator(s, loc, toks)), ('<', 2, pyparsing.opAssoc.LEFT, infixBinaryOp(BinaryStrOperator)), ('<=', 2, pyparsing.opAssoc.LEFT, infixBinaryOp(BinaryStrOperator)), ('>', 2, pyparsing.opAssoc.LEFT, infixBinaryOp(BinaryStrOperator)), ('>=', 2, pyparsing.opAssoc.LEFT, infixBinaryOp(BinaryStrOperator)), ('==', 2, pyparsing.opAssoc.LEFT, infixBinaryOp(BinaryStrOperator)), ('!=', 2, pyparsing.opAssoc.LEFT, infixBinaryOp(BinaryStrOperator)), ('&&', 2, pyparsing.opAssoc.LEFT, infixBinaryOp(BinaryBoolOperator)), ('||', 2, pyparsing.opAssoc.LEFT, infixBinaryOp(BinaryBoolOperator)) ]) self.__ifgrammer = predExpr
def compute(self): def getname(obj, name): _val = None if hasattr(obj, name): _val = getattr(obj, name, None) if _val is None: return _val try: if _val.isdynamic: #TODO make this work for non-attributes, non-dynamics (use .issingleton? - what about a concat mode?) raise ValueError('Combine plugin cannot process %s because it contains a dynamic class' % name) except AttributeError: raise TypeError('Expected an attribute but got a %s' % type(_val)) if _val.issingleton(): _ret = '%s' % _val[0].raw() else: _ret = ', '.join(['%s' % v.raw() for v in _val]) return _ret attrmarker = (p.Literal('@') | p.Literal('!')) attrmatch = attrmarker.suppress() + p.Word(p.alphanums) for i in attrmatch.scanString(self.config): x = i[0][0] self.__attribs__[x] = getname(self.targetobject, x) if all(v is not None for v in self.__attribs__.values()): self.computable = True if self.computable: attrmatch = p.Literal('@').suppress() + p.Word(p.alphanums) attrmatch.setParseAction(self.substitute) attrlist = p.ZeroOrMore(p.Optional(p.White()) + attrmatch + p.Optional(p.White())) self.__result__ = attrlist.transformString(self.config)
def grammar(): """Define the query grammar. Some query examples: * Simple selection: ``host1.domain`` * ClusterShell syntax for hosts expansion: ``host10[10-42].domain,host2010.other-domain`` * ClusterShell syntax for hosts globbing: ``host10[10-42]*`` * A complex selection: ``host100[1-5]* or (host10[30-40].domain and (host10[10-42].domain and not host33.domain))`` Backus-Naur form (BNF) of the grammar:: <grammar> ::= <item> | <item> <boolean> <grammar> <item> ::= <hosts> | "(" <grammar> ")" <boolean> ::= "and not" | "and" | "xor" | "or" Given that the pyparsing library defines the grammar in a BNF-like style, for the details of the tokens not specified above check directly the source code. Returns: pyparsing.ParserElement: the grammar parser. """ # Boolean operators boolean = (pp.CaselessKeyword('and not').leaveWhitespace() | pp.CaselessKeyword('and') | pp.CaselessKeyword('xor') | pp.CaselessKeyword('or'))('bool') # Parentheses lpar = pp.Literal('(')('open_subgroup') rpar = pp.Literal(')')('close_subgroup') # Hosts selection: clustershell (,!&^[]) syntax is allowed: host10[10-42].domain hosts = (~(boolean) + pp.Word(pp.alphanums + '-_.,!&^[]*?'))('hosts') # Final grammar, see the docstring for its BNF based on the tokens defined above # Groups are used to split the parsed results for an easy access full_grammar = pp.Forward() item = hosts | lpar + full_grammar + rpar full_grammar << pp.Group(item) + pp.ZeroOrMore(pp.Group(boolean + item)) # pylint: disable=expression-not-assigned return full_grammar
def main(args): sexp = pp.nestedExpr(opener='(', closer=')') sexp.ignore(';' + pp.restOfLine) parser = pp.ZeroOrMore(sexp) ast = parser.parseFile(args.input_file, parseAll=True).asList() for statement in ast: if statement[0] == 'set-logic': assert (statement[1].startswith('CHC_')) statement[1] = 'HORN' elif statement[0] == 'constraint': statement[0] = 'assert' elif statement[0] == 'check-synth': statement[0] = 'check-sat' elif statement[0] == 'synth-fun': statement[0] = 'declare-fun' statement[2] = [var_decl[1] for var_decl in statement[2]] sys.stdout.writelines(serialize(statement) + '\n' for statement in ast)
def _parse_filter(): op = pyparsing.oneOf('! & |') lpar = pyparsing.Literal('(').suppress() rpar = pyparsing.Literal(')').suppress() k = pyparsing.Word(pyparsing.alphanums) # NOTE: We may need to expand on this list, but as this is not a real # LDAP server we should be OK. # Value to contain: # numbers, upper/lower case letters, astrisk, at symbol, minus, full # stop, backslash or a space v = pyparsing.Word(pyparsing.alphanums + "-*@.\\ ") rel = pyparsing.oneOf("= ~= >= <=") expr = pyparsing.Forward() atom = pyparsing.Group(lpar + op + expr + rpar) \ | pyparsing.Combine(lpar + k + rel + v + rpar) expr << atom + pyparsing.ZeroOrMore(expr) return expr
def expr(cls): parts = [i.expr() for i in cls.comps] atom = pp.MatchFirst(parts) resp = pp.And( [ pp.MatchFirst( [ WS.expr() + pp.Optional( base.Sep + Method.expr() ), Method.expr(), ] ), base.Sep, Path.expr(), pp.ZeroOrMore(base.Sep + atom) ] ) resp = resp.setParseAction(cls) return resp
def __init__(self, parse_result): self.type_name = parse_result['type_name'] self.type_len = parse_result['type_len'] self.is_array = parse_result['is_array'][0] # create parser if self.type_name == 'STRING': # string type self.parser = quoted_string elif self.type_name == 'FLOAT': # float type self.parser = number else: raise ValueError('Unsupported primitive type %s' % self.type_name) if self.is_array: # wrap parser in array # NOTE: we group array so they don't get merged with others. self.parser = (pp.Literal('(').suppress() + pp.Group(pp.ZeroOrMore(self.parser)) + pp.Literal(')').suppress())
def _make_parser(): word = pp.CharsNotIn(''.join(whitespace)) word.skipWhitespace = True value = pp.MatchFirst([ pp.dblQuotedString.copy().setParseAction(pp.removeQuotes), pp.sglQuotedString.copy().setParseAction(pp.removeQuotes), pp.Empty() + pp.CharsNotIn(''.join(whitespace)), ]) expressions = [] for field in named_fields: exp = pp.Suppress(pp.CaselessLiteral(field) + ':') + \ value.copy().setParseAction(_decorate_match(field)) expressions.append(exp) any_ = value.copy().setParseAction(_decorate_match('any')) expressions.append(any_) return pp.ZeroOrMore(pp.MatchFirst(expressions))
def do(self, theEnv, theString, *args, **kargs): """ handler of the function @see: http://www.comp.rgu.ac.uk/staff/smc/teaching/clips/vol1/vol1-12.2.html#Heading222 """ theString = self.resolve( theEnv, self.semplify(theEnv, theString, types.String, ("1", "string"))) if theString.strip() == "": return [] # return an empty list # \" -> " theString.replace("\\\"", "\"") import pyparsing as pp constantParser = theEnv.network.getParser().getSParser( "ConstantParser") variableParser = ((pp.Literal("$?") + theEnv.network.getParser().getSParser("VariableSymbolParser"))\ .setParseAction(lambda s,l,t: types.String("".join([str(x) for x in t.asList()])) ) | pp.Literal("$?")\ .setParseAction(lambda s,l,t: types.String("$?") ) | theEnv.network.getParser().getSParser("GlobalVariableParser").copy()\ .setParseAction(lambda s,l,t: types.String("".join([str(x) for x in t.asList()])) ) | (pp.Literal("?") + theEnv.network.getParser().getSParser("VariableSymbolParser"))\ .setParseAction(lambda s,l,t: types.String("".join([str(x) for x in t.asList()])) ) | pp.Literal("?")\ .setParseAction(lambda s,l,t: types.String("?") ) ).setParseAction(lambda s,l,t: t.asList()) trapParser = pp.SkipTo(constantParser | variableParser).setParseAction( lambda s, l, t: types.String(t[0].strip())) wrapperParser = pp.ZeroOrMore(variableParser | constantParser | trapParser).setParseAction( lambda s, l, t: t.asList()) return wrapperParser.parseString(theString, True).asList()
def _make_parser(): word = pp.CharsNotIn("".join(whitespace)) word.skipWhitespace = True value = pp.MatchFirst([ pp.dbl_quoted_string.copy().set_parse_action(pp.remove_quotes), pp.sgl_quoted_string.copy().set_parse_action(pp.remove_quotes), pp.Empty() + pp.CharsNotIn("".join(whitespace)), ]) expressions = [] for field in named_fields: exp = pp.Suppress(pp.CaselessLiteral(field) + ":") + value.copy().set_parse_action( _decorate_match(field)) expressions.append(exp) any_ = value.copy().set_parse_action(_decorate_match("any")) expressions.append(any_) return pp.ZeroOrMore(pp.MatchFirst(expressions))
def XXXX_cast_expression(self): """A function returning a parser for parsing cast expressions. Args: expression: a pyparsing parser for parsing an expression to be cast. Returns: A (pyparsing) parser for parsing cast expressions. """ word = pyparsing.Word(pyparsing.alphanums + '_*[]') nested = pyparsing.Forward().setName("nested") nested << pyparsing.Combine( pyparsing.Literal('(').suppress() + pyparsing.Combine( pyparsing.ZeroOrMore(self._integer() | word | nested)) + pyparsing.Literal(')').suppress()) typeof_expression = (_OPEN_PARENTHESIS + pyparsing.Keyword('typeof') + nested("typeof_arg") + _CLOSE_PARENTHESIS) type_expression = (typeof_expression | nested("simple_type")) return (type_expression + ~(_PLUS | _MINUS) + self.expression("expression")).setParseAction( self._create_cast_expression)
def main(args): i_expr = pp.QuotedString(quoteChar='"') | pp.QuotedString( quoteChar='|', unquoteResults=False) s_expr = pp.nestedExpr(opener='(', closer=')', ignoreExpr=i_expr) s_expr.ignore(';' + pp.restOfLine) parser = pp.ZeroOrMore(s_expr) ast = parser.parseFile(args.input_file, parseAll=True).asList() for statement in ast: if statement[0] == 'set-logic': assert (statement[1].startswith('CHC_')) statement[1] = 'HORN' elif statement[0] == 'constraint': statement[0] = 'assert' elif statement[0] == 'check-synth': statement[0] = 'check-sat' elif statement[0] == 'synth-fun': statement[0] = 'declare-fun' statement[2] = [var_decl[1] for var_decl in statement[2]] sys.stdout.writelines(serialize(statement) + '\n' for statement in ast)
def gto_basis_parser(): """ Gaussian-type orbital basis parser with pyparsing Basis structure in CRYSTAL is as follows: NUM NSHELLS <ECP_PART> <SHELL_PART> <PRIMITIVE_PART> :return: basis parser """ header = 2 * pc.integer ecp_part = pp.Word(pp.alphas) + pp.Optional( pp.Group(pc.real + 6 * pc.integer) + pp.Group(pp.OneOrMore(pp.Group(2 * pc.real + pc.signed_integer)))) bs_head = pp.Group(3 * pc.integer + 2 * pc.number) bs_part = pp.OneOrMore( pp.Group(bs_head + pp.ZeroOrMore( pp.Group((3 * pc.number + pp.Suppress(pp.LineEnd())) ^ (2 * pc.number + pp.Suppress(pp.LineEnd())))))) return pp.SkipTo(header) + header('header') + pp.Optional( ecp_part('ecp')) + bs_part('bs')
def parse(s): code = pp.Forward() opcode = pp.Or([ pp.Literal('+'), pp.Literal('-'), pp.Literal('*'), pp.Literal('/'), pp.Literal('_'), pp.Literal('='), pp.Literal('>'), pp.Literal('&'), pp.Literal('|'), pp.Literal('~'), pp.Literal('$'), pp.Literal('%'), pp.Literal('\\'), pp.Literal('@'), pp.Literal('ø'), pp.Literal('p'), pp.Literal(':'), pp.Literal(';'), pp.Literal('!'), pp.Literal('?'), pp.Literal('#'), ]).setParseAction(lambda toks: ast.Opcode(toks[0])) number = (pp.Word('1234567890').setParseAction( lambda toks: ast.Number(int(toks[0])))) str_def = ((pp.Literal('"') + pp.SkipTo(pp.Literal('"'), include=True) ).setParseAction(lambda toks: ast.String(toks[1]))) varname = (pp.Word( 'qwertyuiopasdfghjklzxcvbnm', exact=1).setParseAction(lambda toks: ast.Varname(toks[0]))) fn_def = pp.Suppress(pp.Literal('[')) + code + pp.Suppress(pp.Literal(']')) expr = pp.Or([opcode, number, varname, str_def, fn_def]) atom = pp.Or([expr]) code << pp.ZeroOrMore(atom) code.setParseAction(lambda toks: ast.Function(toks)) return code.parseString(s)[0]
def parser_factory(styler): """Builds the S-expression parser.""" def cond_optional(expr): return pp.Optional(expr) if styler else expr LPAR, RPAR, SQUO, DQUO = map(pp.Suppress, '()\'"') form_first = pp.Forward() form = pp.Forward() nil = pp.CaselessKeyword('nil').addParseAction(pp.replaceWith([])) t = pp.CaselessKeyword('t').addParseAction(pp.replaceWith(True)) constant = styler('class:constant', nil | t) number = styler('class:number', ppc.number).setName('number') control_chars = ''.join(map(chr, range(0, 32))) + '\x7f' symbol = pp.CharsNotIn(control_chars + '\'"`;,()[]{} ') symbol = styler('class:symbol', symbol).setName('symbol') symbol.addParseAction(lambda t: Symbol(t[0])) call = styler('class:call', symbol) string = DQUO + pp.Combine(pp.Optional( pp.CharsNotIn('"'))) + cond_optional(DQUO) string = styler('class:string', string).setName('string') forms = (form_first + pp.ZeroOrMore(form)).setName('one or more forms') sexp = (LPAR + pp.Optional(forms) + cond_optional(RPAR)).setName('s-expression') sexp.addParseAction(lambda t: [list(t)]) quote = (styler('class:quote', SQUO) + form).setName('quoted form') quote.addParseAction(lambda t: Quote(t[0])) form_first <<= constant | number ^ call | string | sexp | quote form <<= constant | number ^ symbol | string | sexp | quote return form
def binop_level(prev, assoc, name, op_list): def dobinop(line, lhs, op, rhs): return callop(op, line, lhs, rhs) def associate(s, l, t): t = list(t) line = pp.lineno(l, s) while len(t) > 1: if assoc == 'none': if len(t) != 3: raise pp.ParseException(s, l, name + ' is not associative') t[0:3] = [dobinop(line, *t[0:3])] elif assoc == 'left': t[0:3] = [dobinop(line, *t[0:3])] elif assoc == 'right': t[-4:-1] = [dobinop(line, *t[-4:-1])] else: assert not "unhandled associativity" return t[0] return (prev + pp.ZeroOrMore(op_list + prev) ).setParseAction(associate).setName(name)
def main(args): i_expr = pp.QuotedString(quoteChar='"') | pp.QuotedString( quoteChar='|', unquoteResults=False) s_expr = pp.nestedExpr(opener='(', closer=')', ignoreExpr=i_expr) s_expr.ignore(';' + pp.restOfLine) parser = pp.ZeroOrMore(pp.Suppress('(exit)') | s_expr) ast = parser.parseFile(args.input_file, parseAll=True).asList() for statement in ast: if statement[0] == 'set-logic': assert (statement[1] == 'HORN') statement[1] = 'CHC_LIA' elif statement[0] == 'assert': statement[0] = 'constraint' elif statement[0] == 'check-sat': statement[0] = 'check-synth' elif statement[0] == 'declare-fun': statement[0] = 'synth-fun' statement[2] = [[f'x_{i}', t] for i, t in enumerate(statement[2])] sys.stdout.writelines( sanitize_and_serialize(args, statement) + '\n' for statement in ast)
def _read_x_protocol(text): """ Parse XProtocol (a.k.a. EVP: EValuation Protocol) Args: text: Returns: """ x_prot = {} # text = text[len(PROT['x_prot_id']):] # text = ' '.join(text.split()) lbra = pp.Literal('{').suppress() rbra = pp.Literal('}').suppress() lang = pp.Literal('<').suppress() rang = pp.Literal('>').suppress() dot = pp.Literal('.') cstr = pp.quotedString.addParseAction(pp.removeQuotes) number = pp.Regex(r'[+-]?\d+(\.\d*)?').setName('number') tag = pp.Combine(lang + pp.Word(pp.alphanums) + pp.Optional(dot + cstr) + rang).setName('tag') exp = pp.Forward() key_value = pp.Group(tag + exp) exp <<= (key_value | number | cstr | pp.Group(lbra + pp.ZeroOrMore(exp) + rbra)) # print(x_prot) # x_prot = exp.parseString(text) # with open('/media/Data/tmp/parsed.json', 'w') as f: # json.dump( # (x_prot.asDict(), x_prot.asList()), f, sort_keys=True, indent=4) # # quit() return x_prot
def formatList(string: Optional[str], replaceSemicolons=True, replaceAnds=True) -> List[str]: """Parses a list. Garantees that each element of the list is non-null and non-empty. Gracefully supports quoting: does not split items that are quoted (single or double quotes). Args: - string (Optional[str]): String to convert into a list, using colons as separators - replaceSemicolons (bool, optional): Also use semicolons as separators. Defaults to True. - replaceAnds (bool, optional): Also uses "and" as separators. Defaults to True. Returns: - List[str]: List of strings """ if string is None: return [] value = string.strip() if replaceSemicolons: value = value.replace(";", ", ") if replaceAnds: value = value.replace(" et ", ", ").replace(" and ", ", ") quotedstring = pyparsing.quotedString.copy() quotedstring.addParseAction(pyparsing.removeQuotes) element = pyparsing.originalTextFor( pyparsing.ZeroOrMore( pyparsing.Word(pyparsing.printables + pyparsing.alphas8bit, excludeChars="(),") | pyparsing.nestedExpr())) expr = pyparsing.delimitedList(quotedstring | element) parsed = expr.parseString(value, parseAll=True) return [x for x in parsed.asList() if x]
class ExposeDockerfileCommand(EnvRefCommand): class ExposePort(Stanza): def __init__(self, tokens): self.port = tokens['port'] def __str__(self): return 'EXPOSE {0}'.format(''.join(str(v) for v in self.port)) def evaluate(self, context): environ = context.context.environ port = ''.join(v.expand(environ) for v in self.port) if '/' in port: port, proto = port.split('/', 1) port = int(port) else: proto = 'tcp' port = int(port) # noinspection PyProtectedMember context = context._replace(expose=context.expose | {(port, proto)}) return context single_parser = EnvRefCommand.env_word_value('port').setParseAction( ExposePort) parser = single_parser + p.ZeroOrMore(sp + single_parser)
def __init__(self): minus = pp.Literal('-') lbracket = pp.Literal('[') rbracket = pp.Literal(']') colon = pp.Literal(':') name = pp.Word(pp.alphanums + '$', pp.alphanums + '_$') index = pp.Optional(minus) + pp.Word(pp.nums) subscript = ( index ^ (pp.Optional(index)('start') + colon.suppress() + pp.Optional(index)('stop') + pp.Optional(colon.suppress() + pp.Optional(index) ('step')))('slice')).setParseAction(subscript_action) name_specifier = (name + pp.Optional(lbracket.suppress() + subscript + rbracket.suppress())('subscript') ).setParseAction(name_specifier_action) attribute_specifier = pp.Literal('.').suppress() + name_specifier self.parser = (pp.Group(name_specifier) + pp.Group(pp.ZeroOrMore(attribute_specifier)))
def anything_beetween(opener_and_closer): """Builds a (pyparsing) parser for the content inside delimiters. Args: opener_and_closer: a string containing two elements: opener and closer Returns: A (pyparsing) parser for the content inside delimiters. """ opener = pyparsing.Literal(opener_and_closer[0]) closer = pyparsing.Literal(opener_and_closer[1]) char_removal_mapping = dict.fromkeys(map(ord, opener_and_closer)) other_chars = string.printable.translate(char_removal_mapping) word_without_delimiters = pyparsing.Word(other_chars).setName( "other_chars") anything = pyparsing.Forward() delimited_block = opener + anything + closer # pylint: disable=expression-not-assigned anything << pyparsing.ZeroOrMore( word_without_delimiters.setName("word_without_delimiters") | delimited_block.setName("delimited_block")) # Combine all the parts into a single string. return pyparsing.Combine(anything)
def __init__(self, config=Config): self.config = config self.grammar = pp.Forward() self.pyexpr_entry = pp.Regex(config.pyexpr_entry).suppress() self.pyexpr_exit = pp.Regex(config.pyexpr_exit).suppress() self.pyexpr = self.pyexpr_entry + pp.SkipTo(self.pyexpr_exit) + self.pyexpr_exit self.pyexpr.addParseAction(PyExprHandler) self.opt_key = pp.Word(pp.alphas) self.opt_value = self.pyexpr | pp.Word(pp.alphas) self.opt = self.opt_key + pp.Suppress('=') + self.opt_value self.opt.addParseAction(OptHandler) self.opts_list = pp.delimitedList(self.opt, delim=',') self.opts_entry = pp.Regex(config.opts_entry).suppress() self.opts_exit = pp.Regex(config.opts_exit).suppress() self.opts = pp.Optional(self.opts_entry + self.opts_list + self.opts_exit) self.opts.addParseAction(OptsHandler) self.str_pyexpr_entry = pp.Regex(config.str_pyexpr_entry).suppress() self.str_pyexpr_exit = pp.Regex(config.str_pyexpr_exit).suppress() if config.str_pyexpr_exit else pp.Empty() self.str_pyexpr = self.str_pyexpr_entry + self.pyexpr + self.str_pyexpr_exit self.str_pyexpr.addParseAction(StrPyExprHandler) self.opt_space = pp.Optional(pp.Regex(r'\s')).suppress() self.env_entry = pp.Regex(config.env_entry).suppress() self.env_exit = self.opt_space + pp.Regex(config.env_exit).suppress() self.env = self.env_entry + self.pyexpr + self.opts + self.opt_space + self.grammar + self.env_exit self.env.addParseAction(EnvHandler) self.keyword = self.env_entry | self.env_exit self.struct = self.str_pyexpr | self.env self.char = ~self.keyword + ~self.struct + pp.Regex(r'[\s\S]') self.chars = pp.OneOrMore(self.char) self.txt = pp.Combine(self.chars) self.txt.addParseAction(TxtHandler) self.struct.leaveWhitespace() self.txt.leaveWhitespace() self.element = self.struct | self.txt self.grammar << pp.ZeroOrMore(self.element) self.grammar.addParseAction(GrammarHandler)
def parse(schema): result = {} # constants LPAR, RPAR, LBRACK, RBRACK, LBRACE, RBRACE, LABRACK, RABRACK, COLON, SEMI, COMMA, EQ = map(pa.Suppress, "()[]{}<>:;,=") # keywords _typedef, _const, _enum, _struct, _exception, _service = map(pa.Keyword, ("typedef", "const", "enum", "struct", "exception", "service")) # comment match single_line_comment = (pa.Suppress("//") | pa.Suppress("#")) + pa.restOfLine # general tokens identifier = pa.Word(pa.alphanums + '_') # general value value = pa.Forward() nums_ = pa.Word(pa.nums) integer_ = nums_.setParseAction(lambda s, l, t: [int(t[0])]) double_ = pa.Combine(nums_ + '.' + nums_).setParseAction(lambda s, l, t: [float(t[0])]) string_ = pa.quotedString.setParseAction(pa.removeQuotes) list_ = pa.Group(LBRACK + pa.delimitedList(value) + RBRACK).setParseAction(lambda s, l, t: t.asList()) value << _or(double_, integer_, string_, list_) # scan for possible user defined types _typedef_prefix = _typedef + identifier + pa.Optional(pa.nestedExpr(opener='<', closer='>')) scan_utypes = _or(_typedef_prefix, _enum, _struct, _exception) + identifier utypes = map(pa.Keyword, (t[-1] for t, _, _ in scan_utypes.scanString(schema))) # ttypes ttype = pa.Forward() t_list = pa.Group(pa.Keyword("list")("ttype") + LABRACK + ttype('v') + RABRACK) t_map = pa.Group(pa.Keyword("map")("ttype") + LABRACK + ttype('k') + COMMA + ttype('v') + RABRACK) orig_types = _or(t_list, t_map, *map(pa.Keyword, ("bool", "byte", "i16", "i32", "i64", "double", "string"))) ttype << _or(orig_types, *utypes) # typedef parser typedef = _typedef + orig_types("ttype") + identifier("name") result["typedefs"] = {t.name: t.ttype for t, _, _ in typedef.scanString(schema)} # const parser const = _const + ttype("ttype") + identifier("name") + EQ + value("value") result["consts"] = {c.name: c.value for c, _, _ in const.scanString(schema)} # enum parser enum_value = pa.Group(identifier('name') + pa.Optional(EQ + integer_('value')) + pa.Optional(COMMA)) enum_list = pa.Group(pa.OneOrMore(enum_value))("members") enum = _enum + identifier("name") + LBRACE + enum_list + RBRACE enum.ignore(single_line_comment) result["enums"] = {e.name: e for e, _, _ in enum.scanString(schema)} # struct parser category = _or(*map(pa.Literal, ("required", "optional"))) struct_field = pa.Group(integer_("id") + COLON + pa.Optional(category) + ttype("ttype") + identifier("name") + pa.Optional(EQ + value("value")) + pa.Optional(COMMA)) struct_members = pa.Group(pa.OneOrMore(struct_field))("members") struct = _struct + identifier("name") + LBRACE + struct_members + RBRACE struct.ignore(single_line_comment) # struct defines is ordered result["structs"] = [s for s, _, _ in struct.scanString(schema)] # exception parser exception = _exception + identifier("name") + LBRACE + struct_members + RBRACE exception.ignore(single_line_comment) result["exceptions"] = [s for s, _, _ in exception.scanString(schema)] # service parser ftype = _or(ttype, pa.Keyword("void")) api_param = pa.Group(integer_("id") + COLON + ttype("ttype") + identifier("name") + pa.Optional(COMMA)) api_params = pa.Group(pa.ZeroOrMore(api_param)) service_api = pa.Group(ftype("ttype") + identifier("name") + LPAR + api_params("params") + RPAR + pa.Optional(pa.Keyword("throws") + LPAR + api_params("throws") + RPAR) + pa.Optional(SEMI | COMMA)) service_apis = pa.Group(pa.OneOrMore(service_api))("apis") service = _service + identifier("name") + LBRACE + service_apis + RBRACE service.ignore(single_line_comment) service.ignore(pa.cStyleComment) result["services"] = [s for s, _, _ in service.scanString(schema)] return result
def expr(cls): parts = [i.expr() for i in cls.components] atom = pp.MatchFirst(parts) resp = pp.And([WF.expr(), base.Sep, pp.ZeroOrMore(base.Sep + atom)]) resp = resp.setParseAction(cls) return resp
ctx = {"text": select_text} start, stop = pp.StringStart(), pp.StringEnd() sep = pp.Literal("/").suppress() osep = pp.Optional(sep) descendants = pp.Literal("**") children = pp.Literal("*") element = pp.Word(pp.alphanums + "-_") func = pp.Word(pp.alphas, pp.alphanums + "-_") + "()" condition = pp.Forward() # condition and path are mutually recursive segment = (descendants | children | func | element) + condition path = osep + segment + pp.ZeroOrMore(sep + segment) + osep condition << pp.Optional( pp.Literal("[").suppress() + path + pp.Literal("]").suppress()) parser = (start + path + stop) @condition.setParseAction def condition_action(txt, loc, toks): return make_filter(first(toks)) @descendants.setParseAction def descendants_action(txt, loc, toks): return [select_all_descendants]
def getSequenceArray(self, inputString): testPattern = "{0 +0 1-32}*4 {0 +5 1-32}*2 {0}*2 {0 +7 1-32} {0 +5 1-32} {0 +0 1-32} {0 +0 1-16} {0 +7 17-32}" if inputString == "": inputString = testPattern print "INPUT STRING IS " + inputString inputString = inputString.replace("\n", "") inputString = inputString.replace("\r", "") sections = inputString.split('[') sections = filter(None, sections) for i in range(len(sections)): # if len(sections[i])==0: continue partplustimes = sections[i].split(']*') if len(partplustimes) > 1: sections[i] = partplustimes[0] * int(partplustimes[1]) inputString = str() inputString = inputString.join(sections) number = pp.Word(pp.nums, max=2) plusOrMinus = pp.Word("+-/", max=1) transposition = pp.Optional(pp.Combine(plusOrMinus + number)) lpar = pp.Literal('{').suppress() rpar = pp.Literal('}').suppress() startend = pp.Optional(pp.Combine(number + "-" + number)) whitespace = pp.ZeroOrMore(" ") space = pp.Optional(pp.OneOrMore(" ")) pattern = pp.Combine(lpar + number + space + transposition + space + startend + rpar) repeatCount = pp.Combine("*" + number) patterns = pp.OneOrMore(pattern | repeatCount) print "~~~~~~" + inputString #there is s problem here I dont know what it is #if inputstring is pasted into the textbox it works #but if its done directly from parsing the square bracketed text #it fails try: shorthand = patterns.parseString(inputString) except pp.ParseException as pe: print("Exception Here") print(pe) print("column: {}".format(pe.col)) return longhand = [] for i in range(len(shorthand)): s = shorthand[i] print "S is :", s if s[0] == '*': repeat = int(s[1:]) - 1 for j in range(repeat): longhand.append(shorthand[i - 1]) else: longhand.append(shorthand[i]) listOfBreaks = [] for i in range(len(longhand)): b = Break() b.setBreak(longhand[i]) listOfBreaks.append(b) print listOfBreaks return listOfBreaks
def call_pa(r): return nodes.Call(args=r.asList()[0]) call.setParseAction(call_pa) var = name("var") def var_pa(r): return nodes.Var(name=r.asList()[0]) var.setParseAction(var_pa) expr << ((constant | var) + pp.ZeroOrMore(get_attr | get_item | call)) def expr_pa(r): obj = None r = r.asList() for part in r: if obj is not None: part.obj = obj obj = part return obj expr.setParseAction(expr_pa) filter_expr = name("name") + pp.Optional(
def parse_file(file_name): number = pp.Word(pp.nums) identifier = pp.Word(pp.alphas + "_", pp.alphanums + "_") lbrace = pp.Literal('{').suppress() rbrace = pp.Literal('}').suppress() cls = pp.Keyword('class') colon = pp.Literal(":") semi = pp.Literal(";").suppress() langle = pp.Literal("<") rangle = pp.Literal(">") equals = pp.Literal("=") comma = pp.Literal(",") lparen = pp.Literal("(") rparen = pp.Literal(")") lbrack = pp.Literal("[") rbrack = pp.Literal("]") mins = pp.Literal("-") struct = pp.Keyword('struct') template = pp.Keyword('template') final = pp.Keyword('final')("final") stub = pp.Keyword('stub')("stub") with_colon = pp.Word(pp.alphanums + "_" + ":") btype = with_colon type = pp.Forward() nestedParens = pp.nestedExpr('<', '>') tmpl = pp.Group(btype("template_name") + langle.suppress() + pp.Group(pp.delimitedList(type)) + rangle.suppress()) type << (tmpl | btype) enum_lit = pp.Keyword('enum') enum_class = pp.Group(enum_lit + cls) ns = pp.Keyword("namespace") enum_init = equals.suppress() + pp.Optional(mins) + number enum_value = pp.Group(identifier + pp.Optional(enum_init)) enum_values = pp.Group(lbrace + pp.delimitedList(enum_value) + pp.Optional(comma) + rbrace) content = pp.Forward() member_name = pp.Combine(pp.Group(identifier + pp.Optional(lparen + rparen))) attrib = pp.Group(lbrack.suppress() + lbrack.suppress() + pp.SkipTo(']') + rbrack.suppress() + rbrack.suppress()) opt_attribute = pp.Optional(attrib)("attribute") namespace = pp.Group(ns("type") + identifier("name") + lbrace + pp.Group(pp.OneOrMore(content))("content") + rbrace) enum = pp.Group(enum_class("type") + identifier("name") + colon.suppress() + identifier("underline_type") + enum_values("enum_values") + pp.Optional(semi).suppress()) default_value = equals.suppress() + pp.SkipTo(';') class_member = pp.Group(type("type") + member_name("name") + opt_attribute + pp.Optional(default_value)("default") + semi.suppress())("member") template_param = pp.Group(identifier("type") + identifier("name")) template_def = pp.Group(template + langle + pp.Group(pp.delimitedList(template_param))("params") + rangle) class_content = pp.Forward() class_def = pp.Group(pp.Optional(template_def)("template") + (cls | struct)("type") + with_colon("name") + pp.Optional(final) + pp.Optional(stub) + opt_attribute + lbrace + pp.Group(pp.ZeroOrMore(class_content))("members") + rbrace + pp.Optional(semi)) content << (enum | class_def | namespace) class_content << (enum | class_def | class_member) for varname in "enum class_def class_member content namespace template_def".split(): locals()[varname].setName(varname) rt = pp.OneOrMore(content) singleLineComment = "//" + pp.restOfLine rt.ignore(singleLineComment) rt.ignore(pp.cStyleComment) return rt.parseFile(file_name, parseAll=True)
CONSTANT = BOOLEAN | SYMBOL | STRING | FLOAT | INTEGER # Initializes the calling of a function. FUNCTION_CALL = pp.Forward() # Defines the name of a single variable. SINGLEFIELD_VARIABLE = pp.Combine(pp.Literal('?') + VARIABLE_SYMBOL) # Defines the name of a variable. VARIABLE = SINGLEFIELD_VARIABLE | GLOBAL_VARIABLE # Defines an expression. EXPRESSION = CONSTANT | VARIABLE | FUNCTION_CALL # Defines the calling of a function. FUNCTION_CALL << OB + FUNCTION_NAME + pp.ZeroOrMore(EXPRESSION) + CB # Defines a field of an ordered pattern. FACT_FIELD = GLOBAL_VARIABLE | CONSTANT | FUNCTION_CALL # Defines an ordered pattern. ORDERED_FACT_PATTERN = OB + pp.Group(SYMBOL + pp.Group(pp.ZeroOrMore(FACT_FIELD))) + CB # Defines a pattern. FACT_PATTERN = ORDERED_FACT_PATTERN # Defines a list of patterns. FACT_PATTERNS = pp.ZeroOrMore(FACT_PATTERN) # Defines the construct for the declaration of a list of facts. DEFFACTS_CONSTRUCT = OB + pp.Keyword('deffacts').suppress() + DEFFACTS_NAME + pp.Optional(COMMENT) + FACT_PATTERNS + CB