eiJNdZddlmZddlmZmZddlmZmZm Z m Z m Z m Z m Z mZmZmZmZmZddlmZddlmZGdd eZGd d eZGd d eZdZGddeZGddeZGddeZeeZeeZdS)zA convenience which constructs expression trees from an easy-to-read syntax Use this unless you have a compelling reason not to; it performs some optimizations that would be tedious to do when constructing an expression tree by hand. ) OrderedDict) BadGrammarUndefinedLabel) LiteralRegexSequenceOneOf LookaheadOptional ZeroOrMore OneOrMoreNot TokenMatcher expression is_callable) NodeVisitor)evaluate_stringc\eZdZdZd fd ZdZfdZdZddZdd Z d Z d Z d Z xZ S)GrammaraEA collection of rules that describe a language You can start parsing from the default rule by calling ``parse()`` directly on the ``Grammar`` object:: g = Grammar(''' polite_greeting = greeting ", my good " title greeting = "Hi" / "Hello" title = "madam" / "sir" ''') g.parse('Hello, my good sir') Or start parsing from any of the other rules; you can pull them out of the grammar as if it were a dictionary:: g['title'].parse('sir') You could also just construct a bunch of ``Expression`` objects yourself and stitch them together into a language, but using a ``Grammar`` has some important advantages: * Languages are much easier to define in the nice syntax it provides. * Circular references aren't a pain. * It does all kinds of whizzy space- and time-saving optimizations, like factoring up repeated subexpressions into a single object, which should increase cache hit ratio. [Is this implemented yet?] c fd|D}||\}}tt||_dS)ayConstruct a grammar. :arg rules: A string of production rules, one per line. :arg default_rule: The name of the rule invoked when you call :meth:`parse()` or :meth:`match()` on the grammar. Defaults to the first rule. Falls back to None if there are no string-based rules in this grammar. :arg more_rules: Additional kwargs whose names are rule names and values are Expressions or custom-coded callables which accomplish things the built-in rule syntax cannot. These take precedence over ``rules`` in case of naming conflicts. c\i|](\}}|t|rt||n|)S)rr).0kvselfs k/var/www/html/volatility/venv/lib/python3.11/site-packages/ccxt/static_dependencies/parsimonious/grammar.py z$Grammar.__init__..=sK",",",1 +a..? 1a&&&a",",",N)items_expressions_from_rulessuperr__init__ default_rule)rrules more_rulesdecorated_custom_rulesexprsfirst __class__s` rr%zGrammar.__init__.s",",",","((**",",",33E;QRR u gt%%ekkmm444!r!cH|}|||_|S)zAReturn a new Grammar whose :term:`default rule` is ``rule_name``.)_copyr&)r rule_namenews rdefaultzGrammar.defaultEs jjlly> r!ctt}tt|||j|_|S)zReturn a shallow copy of myself. Deep is unnecessary, since Expression trees are immutable. Subgrammars recreate all the Expressions from scratch, and AbstractGrammars have no Expressions. )r__new__r$r%r"r&)rr0r,s rr.z Grammar._copyKsLoog&& gs$$TZZ\\222, r!czt|}t||S)aReturn a 2-tuple: a dict of rule names pointing to their expressions, and then the first rule. It's a web of expressions, all referencing each other. Typically, there's a single root to the web of references, and that root is the starting symbol for parsing, but there's nothing saying you can't have multiple roots. :arg custom_rules: A map of rule names to custom-coded rules: Expressions ) rule_grammarparse RuleVisitorvisitrr' custom_rulestrees rr#zGrammar._expressions_from_rulesXs3!!%((<((..t444r!rcb||j||S)zoParse some text with the :term:`default rule`. :arg pos: The index at which to start parsing pos)_check_default_ruler&r6rtextr>s rr6z Grammar.parsehs2   """ &&t&555r!cb||j||S)zParse some text with the :term:`default rule` but not necessarily all the way to the end. :arg pos: The index at which to start parsing r=)r?r&matchr@s rrCz Grammar.matchqs2   """ &&t&555r!c2|jstddS)z7Raise RuntimeError if there is no default rule defined.zCan't call parse() on a Grammar that has no default rule. Choose a specific rule instead, like some_grammar['some_rule'].parse(...).N)r& RuntimeErrorrs rr?zGrammar._check_default_rule{s5  M LMM M M Mr!cjrjgng}|fdDdd|DS)zbReturn a rule string that, when passed to the constructor, would reconstitute the grammar.c3.K|]}|ju |VdSN)r&)rexprrs r z"Grammar.__str__..s<44d!222222244r! c3>K|]}|VdSrI)as_rulerrJs rrKz"Grammar.__str__..s*::D::::::r!)r&extendvaluesjoin)rr*s` r__str__zGrammar.__str__s(,'8@"##b 4444dkkmm444 4 4 4yy::E::::::r!cFdt|S)z8Return an expression that will reconstitute the grammar.z Grammar({!r}))formatstrrFs r__repr__zGrammar.__repr__s%%c$ii000r!)r)r)__name__ __module__ __qualname____doc__r%r1r.r#r6rCr?rSrW __classcell__)r,s@rrrs8"""""".     555 66666666MMM;;;1111111r!rceZdZdZdZdS) TokenGrammarzA Grammar which takes a list of pre-lexed tokens instead of text This is useful if you want to do the lexing yourself, as a separate pass: for example, to implement indentation-based languages. czt|}t||SrI)r5r6TokenRuleVisitorr8r9s rr#z$TokenGrammar._expressions_from_ruless1!!%(( --33D999r!NrXrYrZr[r#rr!rr^r^s- :::::r!r^ceZdZdZdZdS)BootstrappingGrammaraThe grammar used to recognize the textual rules that describe other grammars This grammar gets its start from some hard-coded Expressions and claws its way from there to an expression tree that describes how to parse the grammar description syntax. ctdd}ttd|d}t|d}tt d|d}ttd |d }t|t |d }ttd |d } tdddd} t| |d} tt d| tdd|d} t|| | d} t| | d}t|| d}tt d||d}|f|jz|_t|t|d}tt d||d}t|t|d}t|||d }t|||d!}t|t|d"}||}t |S)#zReturn the rules for parsing the grammar definition syntax. Return a 2-tuple: a dict of rule names pointing to their expressions, and then the top-level expression for the first rule. z #[^\r\n]*commentnamez\s+meaninglessness_=equalsz[a-zA-Z_][a-zA-Z_0-9]*label referencez[*+?] quantifierzu?r?"[^"\\]*(?:\\.[^"\\]*)*"Tspaceless_literal) ignore_casedot_allrgliteral~z [ilmsuxa]*)rpregexatom quantifiedterm!not_termsequence/or_termoredrruler') rr r r rrmembersrr6r7r8)r rule_syntaxr:rerhrirkrlrmrnrorrrtrurvrwryrzr|r}rr~r' rule_trees rr#z,BootstrappingGrammar._expressions_from_rulessL 9555f w=NOOO S 1 1 1'#,,99989917KKKUCKKkBBB eHooq|DDD !"A.2*.':<<<,ai@@@ |>>>% ''' YV<<<dJ\BBB ZF333GCLL$ CCC {T\1 D)D// CCC73<<DyAAAi00v>>>44lCCC vz???IdOO':::KK ,, }}""9---r!Nrarr!rrcrcs-1.1.1.1.1.r!rca # Ignored things (represented by _) are typically hung off the end of the # leafmost kinds of nodes. Literals like "/" count as leaves. rules = _ rule* rule = label equals expression equals = "=" _ literal = spaceless_literal _ # So you can't spell a regex like `~"..." ilm`: spaceless_literal = ~"u?r?\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\""is / ~"u?r?'[^'\\\\]*(?:\\\\.[^'\\\\]*)*'"is expression = ored / sequence / term or_term = "/" _ term ored = term or_term+ sequence = term term+ not_term = "!" term _ lookahead_term = "&" term _ term = not_term / lookahead_term / quantified / atom quantified = atom quantifier atom = reference / literal / regex / parenthesized regex = "~" spaceless_literal ~"[ilmsuxa]*"i _ parenthesized = "(" _ expression ")" _ quantifier = ~"[*+?]" _ reference = label !equals # A subsequent equal sign is the only thing that distinguishes a label # (which begins a new rule) from a reference (which is just a pointer to a # rule defined somewhere else): label = ~"[a-zA-Z_][a-zA-Z_0-9]*" _ # _ = ~r"\s*(?:#[^\r\n]*)?\s*" _ = meaninglessness* meaninglessness = ~r"\s+" / comment comment = ~r"#[^\r\n]*" ceZdZdZdZdZdS) LazyReferencezMA lazy reference to a rule, which we resolve after grokking all the rulesrc d|zS)NzrrFs r_as_rhszLazyReference._as_rhs s '$..r!N)rXrYrZr[rgrrr!rrrs4   D/////r!rceZdZdZeeedZej xZ xZ Z ddZ dZdZdZdZd Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZdS)r7zTurns a parse tree of a grammar definition into a map of ``Expression`` objects This is the magic piece that breathes life into a parsed bunch of parse rules, allowing them to go forth and parse other things. )?*+Nc|pi|_dS)zConstruct. :arg custom_rules: A dict of {rule name: expression} holding custom rules which will take precedence over the others N)r:)rr:s rr%zRuleVisitor.__init__s).Br!c|\}}}}}|S)zTreat a parenthesized subexpression as just its contents. Its position in the tree suffices to maintain its grouping semantics. r)rnode parenthesized left_parenrir right_parens rvisit_parenthesizedzRuleVisitor.visit_parenthesized"s 5B1 Az;r!c|\}}|S)z5Turn a quantifier into just its symbol-matching node.r)rrrnsymbolris rvisit_quantifierzRuleVisitor.visit_quantifier+s  r!cB|\}}|j|j|SrI)quantifier_classesrA)rrrvrurns rvisit_quantifiedzRuleVisitor.visit_quantified0s&%j7t&z7===r!c,|\}}}t|SrI)r )rrlookahead_term ampersandrwris rvisit_lookahead_termz RuleVisitor.visit_lookahead_term4s+ 4r!c,|\}}}t|SrI)r)rrry exclamationrwris rvisit_not_termzRuleVisitor.visit_not_term8s' T14yyr!c |\}}}||_|S)z.Assign a name to the Expression and return it.rf)rrr~rlrkrs r visit_rulezRuleVisitor.visit_rule<s$(!vz r!c&|\}}t|g|RS)zfA parsed Sequence looks like [term node, OneOrMore node of ``another_term``s]. Flatten it out.)r )rrrzrw other_termss rvisit_sequencezRuleVisitor.visit_sequenceBs$%k+{++++r!c&|\}}t|g|RSrI)r )rrr} first_termrs r visit_oredzRuleVisitor.visit_oredHs""& KZ.+....r!c|\}}}|S)zReturn just the term from an ``or_term``. We already know it's going to be ored, from the containing ``ored``. r)rrr|slashrirws r visit_or_termzRuleVisitor.visit_or_termLs !q$ r!c|\}}|jS)z#Turn a label into a unicode string.)rA)rrrlrgris r visit_labelzRuleVisitor.visit_labelUsayr!c*|\}}t|S)zjStick a :class:`LazyReference` in the tree as a placeholder. We resolve them all later. )r)rrrmrl not_equalss rvisit_referencezRuleVisitor.visit_referenceZs &zU###r!c |\}}}}|j}|j}t|d|vd|vd|vd|vd|vd|vd|vS) zReturn a ``Regex`` expression.ILMSUXA)rplocale multilinerqunicodeverboseascii)rAupperrrr)rrrttilderrflagsripatterns r visit_regexzRuleVisitor.visit_regexcss#( wq   ""/W#,%(E\(+u &)Ul&)Ul&)Ul$'5L 222 2r!cDtt|jS)z>???r!c|\}}|S)z6Pick just the literal out of a literal-and-junk combo.r)rrrrroris r visit_literalzRuleVisitor.visit_literalus&1  r!c |p|S)a Replace childbearing nodes with a list of their children; keep others untouched. For our case, if a node has children, only the children are important. Otherwise, keep the node around for (for example) the flags of the regex rule. Most of these kept-around nodes are subsequently thrown away by the other visitor methods. We can't simply hang the visited children off the original node; that would be disastrous if the node occurred in more than one place in the tree. r)rrrs r generic_visitzRuleVisitor.generic_visitzs '4'r!crt|trMt|} |}n#t$rt |wxYw|St |ddr@|vr<|tfd|j D|_ |S)aReturn an expression with all its lazy references recursively resolved. Resolve any lazy references in the expression ``expr``, recursing into all subexpressions. :arg done: The set of Expressions that have already been or are currently being resolved, to ward off redundant work and prevent infinite recursion for circular refs rrc3FK|]}|VdSrI) _resolve_refs)rmemberdonerule_maprs rrKz,RuleVisitor._resolve_refs..sQ%A%A)/&*%7%7&$%O%O%A%A%A%A%A%Ar!) isinstancerrVKeyErrorrrgetattraddtupler)rrrJrrl reffed_exprs`` ` rrzRuleVisitor._resolve_refss dM * * IIE +&uo  + + +$T*** +%%h TBB BtY++ AD0@0@$%A%A%A%A%A%A37<%A%A%A A A Ks 2A cN|\}}td|DjttfdDt |t r|r|djndfS)aCollate all the rules into a map. Return (map, default rule). The default rule is the first one. Or, if you have more than one rule of that name, it's the last-occurring rule of that name. (This lets you override the default rule when you extend a grammar.) If there are no string-based rules, the default rule is None, because the custom rules, due to being kwarg-based, are unordered. c3(K|] }|j|fVdSrIrfrOs rrKz*RuleVisitor.visit_rules..s)CCT 40CCCCCCr!c3TK|]"}|j|fV#dSrI)rgr)rrJrrrs rrKz*RuleVisitor.visit_rules..sP>>#'!% 4+=+=hd+S+ST>>>>>>r!rN)rupdater:setrQrlistrg)rr rules_listrir'rrs` @@r visit_ruleszRuleVisitor.visit_ruless5 CCUCCCCC )***uu>>>>>>+3??+<+<>>>>> 't44I9>I(58=11DHJ Jr!rI)rXrYrZr[r r rrr lift_childvisit_expression visit_term visit_atomr%rrrrrrrrrrrrrrrrrrr!rr7r7 s^ (jyII1<1GGGzJ//// >>> ,,, /// $$$ 2 2 2@@@!!! ((( : J J J J Jr!r7ceZdZdZdZdZdS)r`znA visitor which builds expression trees meant to work on sequences of pre-lexed tokens rather than stringscDtt|jS)zrTurn a string literal into a ``TokenMatcher`` that matches ``Token`` objects by their ``type`` attributes.)rrrArs rrz(TokenRuleVisitor.visit_spaceless_literalsO,=,BCCDDDr!c.|\}}}}td)NzsRegexes do not make sense in TokenGrammars, since TokenGrammars operate on pre-lexed tokens rather than characters.)r)rrrtrrrrris rrzTokenRuleVisitor.visit_regexs'#( wq,-- -r!N)rXrYrZr[rrrr!rr`r`s?,,EEE -----r!r`N) r[ collectionsr exceptionsrr expressionsrrr r r r r rrrrrnodesrutilsrrr^rcrrVrr7r`r5rr!rrs3$#####22222222""""""{1{1{1{1{1k{1{1{1| : : : : :7 : : ::.:.:.:.:.7:.:.:.@$ N/////C///zJzJzJzJzJ+zJzJzJz - - - - -{ - - -"$#K00 w{## r!