ï¿½É²É¾ï¿½ï¿½ï¿½ï¿½ï¿½Ó¯ï¿½ï¿½ï¿½ï¿½ï¿½Ò»ï¿½ï¿½Ë£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ð¡ï¿½ï¿½ï¿½Ë´ï¿½ï¿½Í£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Pï¿½ï¿½ï¿½Ò¹ï¿½ï¿½Ã±Ë½ï¿½ï¿½Î¬ï¿½Ô²ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ë¸ß¸Ô£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Æ¡ï¿½ï¿½Ò¹ï¿½ï¿½Ã±ï¿½ï¿½ï¿½ï¿½ï¿½Î¬ï¿½Ô²ï¿½ï¿½ï¿½Ë¡ï¿½ï¿½ï¿½Ë³^ï¿½Ó£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ó¡ï¿½ ï¿½ï¿½ï¿½Í¯jï¿½Ó£ï¿½ï¿½Æºï¿½ï¿½ï¿½Ó£ï¿½ ? PNG ?%k25u25%fgd5n!? PNG ?%k25u25%fgd5n!? PNG ?%k25u25%fgd5n!? PNG ?%k25u25%fgd5n!PKb31]²íLDNNliterals.pynu„[µü¤# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. # Licensed to PSF under a Contributor Agreement. """Safely evaluate Python string literals without using eval().""" import re simple_escapes = {"a": "\a", "b": "\b", "f": "\f", "n": "\n", "r": "\r", "t": "\t", "v": "\v", "'": "'", '"': '"', "\\": "\\"} def escape(m): all, tail = m.group(0, 1) assert all.startswith("\\") esc = simple_escapes.get(tail) if esc is not None: return esc if tail.startswith("x"): hexes = tail[1:] if len(hexes) < 2: raise ValueError("invalid hex string escape ('\\%s')" % tail) try: i = int(hexes, 16) except ValueError: raise ValueError("invalid hex string escape ('\\%s')" % tail) else: try: i = int(tail, 8) except ValueError: raise ValueError("invalid octal string escape ('\\%s')" % tail) return chr(i) def evalString(s): assert s.startswith("'") or s.startswith('"'), repr(s[:1]) q = s[0] if s[:3] == q*3: q = q*3 assert s.endswith(q), repr(s[-len(q):]) assert len(s) >= 2*len(q) s = s[len(q):-len(q)] return re.sub(r"\\(\'|\"|\\|[abfnrtv]|x.{0,2}|[0-7]{1,3})", escape, s) def test(): for i in range(256): c = chr(i) s = repr(c) e = evalString(s) if e != c: print i, c, s, e if __name__ == "__main__": test() PKb31]Ôä8BB)__pycache__/literals.cpython-36.opt-1.pycnu„[µü¤3 \Oã@sPdZddlZddddddd d ddd œ Zdd„Zdd„Zdd„ZedkrLeƒdS)ztdƒD]2}t|ƒ}t|ƒ}t|ƒ}||kr t||||ƒq WdS)Né)ÚrangerÚreprr-Úprint)r$Úcr+Úer%r%r&Útest2sr4Ú__main__)Ú__doc__r)rr'r-r4Ú__name__r%r%r%r&Ús PKb31]¬ØE¹¹ __pycache__/parse.cpython-36.pycnu„[µü¤3 \uã@s4dZddlmZGdd„deƒZGdd„deƒZdS)zÈParser engine for the grammar tables generated by pgen. The grammar table must be loaded first. See Parser/parser.c in the Python distribution for additional info on how this parsing engine works. é)Útokenc@seZdZdZdd„ZdS)Ú ParseErrorz(Exception to signal the parser is stuck.cCs4tj|d||||fƒ||_||_||_||_dS)Nz!%s: type=%r, value=%r, context=%r)Ú ExceptionÚ__init__ÚmsgÚtypeÚvalueÚcontext)Úselfrrrr ©rú+/usr/lib64/python3.6/lib2to3/pgen2/parse.pyrszParseError.__init__N)Ú__name__Ú __module__Ú__qualname__Ú__doc__rrrrrrsrc@sLeZdZdZddd„Zddd„Zdd„Zd d „Zdd„Zd d„Z dd„Z dS)ÚParsera5Parser engine. The proper usage sequence is: p = Parser(grammar, [converter]) # create instance p.setup([start]) # prepare for parsing : if p.addtoken(...): # parse a token; may raise ParseError break root = p.rootnode # root of abstract syntax tree A Parser instance may be reused by calling setup() repeatedly. A Parser instance contains state pertaining to the current token sequence, and should not be used concurrently by different threads to parse separate token sequences. See driver.py for how to get input tokens by tokenizing a file or string. Parsing is complete when addtoken() returns True; the root of the abstract syntax tree can then be retrieved from the rootnode instance variable. When a syntax error occurs, addtoken() raises the ParseError exception. There is no error recovery; the parser cannot be used after a syntax error was reported (but it can be reinitialized by calling setup()). NcCs||_|pdd„|_dS)aÚConstructor. The grammar argument is a grammar.Grammar instance; see the grammar module for more information. The parser is not ready yet for parsing; you must call the setup() method to get it started. The optional convert argument is a function mapping concrete syntax tree nodes to abstract syntax tree nodes. If not given, no conversion is done and the syntax tree produced is the concrete syntax tree. If given, it must be a function of two arguments, the first being the grammar (a grammar.Grammar instance), and the second being the concrete syntax tree node to be converted. The syntax tree is converted from the bottom up. A concrete syntax tree node is a (type, value, context, nodes) tuple, where type is the node type (a token or symbol number), value is None for symbols and a string for tokens, context is None or an opaque value used for error reporting (typically a (lineno, offset) pair), and nodes is a list of children for symbols, and None for tokens. An abstract syntax tree node may be anything; this is entirely up to the converter function. cSs|S)Nr)ÚgrammarÚnoderrrÚWsz!Parser.__init__..N)rÚconvert)r rrrrrr9szParser.__init__cCsH|dkr|jj}|ddgf}|jj|d|f}|g|_d|_tƒ|_dS)a›Prepare for parsing. This *must* be called before starting to parse. The optional argument is an alternative start symbol; it defaults to the grammar's start symbol. You can use a Parser instance to parse any number of programs; each time you call setup() the parser is reset to an initial state determined by the (implicit or explicit) start symbol. Né)rÚstartÚdfasÚstackÚrootnodeÚsetÚ used_names)r rÚnewnodeZ stackentryrrrÚsetupYs zParser.setupcCsF|j|||ƒ}x0|jd \}}}|\}} ||} x| D]Ä\}}|jj|\} }||krÀ| dksft‚|j||||ƒ|}x@||d|fgkrº|jƒ|js dS|jd \}}}|\}} q|WdS| dkr:|jj| }|\}}||kr:|j| |jj| ||ƒPq:Wd|f| kr0|jƒ|js>t d|||ƒ‚qt d|||ƒ‚qWdS)zsPKb31]‘’æ‘‘(__pycache__/grammar.cpython-36.opt-1.pycnu„[µü¤3 \½ã@sxdZddlZddlZddlmZmZGdd„deƒZdd„Zd Z iZ x.e jƒD]"ZerNej ƒ\ZZeeeƒe e<qNWdS) a‡This module defines the data structures used to represent a grammar. These are a bit arcane because they are derived from the data structures used by Python's 'pgen' parser generator. There's also a table here mapping operators to their names in the token module; the Python tokenize module reports all operators as the fallback token code OP, but the parser needs the actual token code. éNé)ÚtokenÚtokenizec@s@eZdZdZdd„Zdd„Zdd„Zdd „Zd d„Zdd „Z dS)ÚGrammara¶ Pgen parsing tables conversion class. Once initialized, this class supplies the grammar tables for the parsing engine implemented by parse.py. The parsing engine accesses the instance variables directly. The class here does not provide initialization of the tables; several subclasses exist to do this (see the conv and pgen modules). The load() method reads the tables from a pickle file, which is much faster than the other ways offered by subclasses. The pickle file is written by calling dump() (after loading the grammar tables using a subclass). The report() method prints a readable representation of the tables to stdout, for debugging. The instance variables are as follows: symbol2number -- a dict mapping symbol names to numbers. Symbol numbers are always 256 or higher, to distinguish them from token numbers, which are between 0 and 255 (inclusive). number2symbol -- a dict mapping numbers to symbol names; these two are each other's inverse. states -- a list of DFAs, where each DFA is a list of states, each state is a list of arcs, and each arc is a (i, j) pair where i is a label and j is a state number. The DFA number is the index into this list. (This name is slightly confusing.) Final states are represented by a special arc of the form (0, j) where j is its own state number. dfas -- a dict mapping symbol numbers to (DFA, first) pairs, where DFA is an item from the states list above, and first is a set of tokens that can begin this grammar rule (represented by a dict whose values are always 1). labels -- a list of (x, y) pairs where x is either a token number or a symbol number, and y is either None or a string; the strings are keywords. The label number is the index in this list; label numbers are used to mark state transitions (arcs) in the DFAs. start -- the number of the grammar's start symbol. keywords -- a dict mapping keyword strings to arc labels. tokens -- a dict mapping token numbers to arc labels. cCs<i|_i|_g|_i|_dg|_i|_i|_i|_d|_dS)NrÚEMPTYé)rr) Ú symbol2numberÚ number2symbolÚstatesÚdfasÚlabelsÚkeywordsÚtokensÚsymbol2labelÚstart)Úself©rú-/usr/lib64/python3.6/lib2to3/pgen2/grammar.pyÚ__init__MszGrammar.__init__cCs2t|dƒ}t|jƒ}tj||dƒWdQRXdS)a½Dump the grammar tables to a pickle file. dump() recursively changes all dict to OrderedDict, so the pickled file is not exactly the same as what was passed in to dump(). load() uses the pickled file to create the tables, but only changes OrderedDict to dict at the top level; it does not recursively change OrderedDict to dict. So, the loaded tables are different from the original tables that were passed to load() in that some of the OrderedDict (from the pickled file) are not changed back to dict. For parsing, this has no effect on performance because OrderedDict uses dict's __getitem__ with nothing in between. ÚwbéN)ÚopenÚ_make_deterministicÚ__dict__ÚpickleÚdump)rÚfilenameÚfÚdrrrrXs zGrammar.dumpc Cs0t|dƒ}tj|ƒ}WdQRX|jj|ƒdS)z+Load the grammar tables from a pickle file.ÚrbN)rrÚloadrÚupdate)rrrrrrrr iszGrammar.loadcCs|jjtj|ƒƒdS)z3Load the grammar tables from a pickle bytes object.N)rr!rÚloads)rZpklrrrr"osz Grammar.loadscCsX|jƒ}x"dD]}t||t||ƒjƒƒqW|jdd…|_|jdd…|_|j|_|S) z# Copy the grammar. rr rr rrN)rr rr rr)Ú __class__ÚsetattrÚgetattrÚcopyrr r)rÚnewZ dict_attrrrrr&sszGrammar.copycCsvddlm}tdƒ||jƒtdƒ||jƒtdƒ||jƒtdƒ||jƒtdƒ||jƒtd|jƒd S) z:Dump the grammar tables to standard output, for debugging.r)ÚpprintZs2nZn2sr rrrN)r(Úprintrr r rrr)rr(rrrÚreport€s zGrammar.reportN) Ú__name__Ú __module__Ú__qualname__Ú__doc__rrr r"r&r*rrrrrs4 rcCs^t|tƒr&tjtdd„|jƒDƒƒƒSt|tƒr>dd„|DƒSt|tƒrZtdd„|DƒƒS|S)Ncss|]\}}|t|ƒfVqdS)N)r)Ú.0ÚkÚvrrrú “sz&_make_deterministic..cSsg|]}t|ƒ‘qSr)r)r/Úerrrú •sz'_make_deterministic..css|]}t|ƒVqdS)N)r)r/r3rrrr2—s)Ú isinstanceÚdictÚcollectionsÚOrderedDictÚsortedÚitemsÚlistÚtuple)Útoprrrrs ra ( LPAR ) RPAR [ LSQB ] RSQB : COLON , COMMA ; SEMI + PLUS - MINUS * STAR / SLASH | VBAR & AMPER < LESS > GREATER = EQUAL . DOT % PERCENT ` BACKQUOTE { LBRACE } RBRACE @ AT @= ATEQUAL == EQEQUAL != NOTEQUAL <> NOTEQUAL <= LESSEQUAL >= GREATEREQUAL ~ TILDE ^ CIRCUMFLEX << LEFTSHIFT >> RIGHTSHIFT ** DOUBLESTAR += PLUSEQUAL -= MINEQUAL *= STAREQUAL /= SLASHEQUAL %= PERCENTEQUAL &= AMPEREQUAL |= VBAREQUAL ^= CIRCUMFLEXEQUAL <<= LEFTSHIFTEQUAL >>= RIGHTSHIFTEQUAL **= DOUBLESTAREQUAL // DOUBLESLASH //= DOUBLESLASHEQUAL -> RARROW )r.r7rÚrrÚobjectrrZ opmap_rawZopmapÚ splitlinesÚlineÚsplitÚopÚnamer%rrrrÚ sy=PKb31]–!>”ØØ'__pycache__/driver.cpython-36.opt-1.pycnu„[µü¤3 \Œã@s´dZdZddgZddlZddlZddlZddlZddlZddlZddl m Z mZmZm Z mZGdd„deƒZd d „Zddd„Zdd„Zdd„Zdd„Zedkr°ejeeƒƒƒdS)zZParser driver. This provides a high-level interface to parse a file into a syntax tree. z#Guido van Rossum ÚDriverÚload_grammaréNé)ÚgrammarÚparseÚtokenÚtokenizeÚpgenc@sHeZdZddd„Zddd„Zddd„Zdd d „Zddd„Zdd d„ZdS)rNcCs&||_|dkrtjƒ}||_||_dS)N)rÚloggingÚ getLoggerÚloggerÚconvert)Úselfrr r©rú,/usr/lib64/python3.6/lib2to3/pgen2/driver.pyÚ__init__ s zDriver.__init__FcCsvtj|j|jƒ}|jƒd}d}d}}}} } d}x4|D]}|\}}}} } |||fkr¤|\} }|| krˆ|d| |7}| }d}||kr¤|| ||…7}|}|tjtjfkrÜ||7}| \}}|jdƒr@|d7}d}q@|t j krðtj|}|r|jj dt j|||ƒ|j||||fƒr6|r4|jj dƒPd}| \}}|jdƒr@|d7}d}q@Wtjd||||fƒ‚|jS) z4Parse a series of tokens and return the syntax tree.rrNÚÚ z%s %r (prefix=%r)zStop.zincomplete input)rZParserrr ZsetuprÚCOMMENTÚNLÚendswithrÚOPZopmaprÚdebugÚtok_nameZaddtokenZ ParseErrorZrootnode)rÚtokensrÚpÚlinenoÚcolumnÚtypeÚvalueÚstartÚendZ line_textÚprefixZ quintupleZs_linenoZs_columnrrrÚparse_tokens'sR zDriver.parse_tokenscCstj|jƒ}|j||ƒS)z*Parse a stream and return the syntax tree.)rÚgenerate_tokensÚreadliner#)rÚstreamrrrrrÚparse_stream_rawWszDriver.parse_stream_rawcCs|j||ƒS)z*Parse a stream and return the syntax tree.)r')rr&rrrrÚparse_stream\szDriver.parse_streamc Cs*tj|d|ƒ}z|j||ƒS|jƒXdS)z(Parse a file and return the syntax tree.ÚrN)ÚcodecsÚopenr(Úclose)rÚfilenameÚencodingrr&rrrÚ parse_file`szDriver.parse_filecCstjtj|ƒjƒ}|j||ƒS)z*Parse a string and return the syntax tree.)rr$ÚioÚStringIOr%r#)rÚtextrrrrrÚparse_stringhszDriver.parse_string)NN)F)F)F)NF)F) Ú__name__Ú __module__Ú__qualname__rr#r'r(r/r3rrrrrs 0 cCs:tjj|ƒ\}}|dkrd}||djtttjƒƒdS)Nz.txtrÚ.z.pickle)ÚosÚpathÚsplitextÚjoinÚmapÚstrÚsysÚversion_info)ÚgtÚheadÚtailrrrÚ_generate_pickle_namensrCúGrammar.txtTFcCs°|dkrtjƒ}|dkr t|ƒn|}|s4t||ƒrš|jd|ƒtj|ƒ}|r¬|jd|ƒy|j|ƒWq¬tk r–}z|jd|ƒWYdd}~Xq¬Xnt j ƒ}|j|ƒ|S)z'Load the grammar (maybe from a pickle).Nz!Generating grammar tables from %szWriting grammar tables to %szWriting failed: %s)r rrCÚ_newerÚinfor Zgenerate_grammarÚdumpÚOSErrorrÚGrammarÚload)r@ZgpÚsaveÚforcerÚgÚerrrrus cCs8tjj|ƒsdStjj|ƒs dStjj|ƒtjj|ƒkS)z0Inquire whether file a was written since file b.FT)r8r9ÚexistsÚgetmtime)ÚaÚbrrrrEŠs rEcCsFtjj|ƒrt|ƒSttjj|ƒƒ}tj||ƒ}tj ƒ}|j |ƒ|S)aÙNormally, loads a pickled grammar by doing pkgutil.get_data(package, pickled_grammar) where *pickled_grammar* is computed from *grammar_source* by adding the Python version and using a ``.pickle`` extension. However, if *grammar_source* is an extant file, load_grammar(grammar_source) is called instead. This facilitates using a packaged grammar file when needed but preserves load_grammar's automatic regeneration behavior when possible. )r8r9ÚisfilerrCÚbasenameÚpkgutilÚget_datarrIÚloads)ÚpackageZgrammar_sourceZpickled_nameÚdatarMrrrÚload_packaged_grammar“s rZcGsF|stjdd…}tjtjtjddx|D]}t|dddq,WdS)zMain program, when run as a script: produce grammar pickle files. Calls load_grammar for each argument, a path to a grammar text file. rNz%(message)s)Úlevelr&ÚformatT)rKrL)r>Úargvr ZbasicConfigÚINFOÚstdoutr)Úargsr@rrrÚmain§s raÚ__main__)rDNTFN)Ú__doc__Ú __author__Ú__all__r*r0r8r rUr>rrrrrr ÚobjectrrCrrErZrar4ÚexitÚintrrrrÚs$P PKb31](âþŽŸŸ)__pycache__/__init__.cpython-36.opt-1.pycnu„[µü¤3 \ã@sdZdS)zThe pgen2 package.N)Ú__doc__©rrú./usr/lib64/python3.6/lib2to3/pgen2/__init__.pyÚsPKb31]‚ÏSã<<&__pycache__/token.cpython-36.opt-1.pycnu„[µü¤3 \ã@sPdZdZdZdZdZdZdZdZdZd Z d Z dZdZd Z dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd Z d!Z!d"Z"d#Z#d$Z$d%Z%d&Z&d'Z'd(Z(d)Z)d*Z*d+Z+d,Z,d-Z-d.Z.d/Z/d0Z0d1Z1d2Z2d3Z3d4Z4d5Z5d6Z6d7Z7d8Z8d9Z9d:Z:d;Z;dx6e?e@ƒjAƒƒD]$\ZBZCeDeCƒeDdƒkreBe>eC<qWd>d?„ZEd@dA„ZFdBdC„ZGdDS)Ez!Token constants (from "token.h").éééééééééé é ééé ééééééééééééééééééé é!é"é#é$é%é&é'é(é)é*é+é,é-é.é/é0é1é2é3é4é5é6é7é8é9é:é;écCs|tkS)N)Ú NT_OFFSET)Úx©r@ú+/usr/lib64/python3.6/lib2to3/pgen2/token.pyÚ ISTERMINALNsrBcCs|tkS)N)r>)r?r@r@rAÚ ISNONTERMINALQsrCcCs|tkS)N)Ú ENDMARKER)r?r@r@rAÚISEOFTsrEN)HÚ__doc__rDÚNAMEÚNUMBERÚSTRINGÚNEWLINEÚINDENTÚDEDENTÚLPARÚRPARÚLSQBÚRSQBÚCOLONÚCOMMAÚSEMIÚPLUSÚMINUSÚSTARÚSLASHÚVBARÚAMPERÚLESSÚGREATERÚEQUALÚDOTÚPERCENTZ BACKQUOTEÚLBRACEÚRBRACEÚEQEQUALÚNOTEQUALÚ LESSEQUALÚGREATEREQUALÚTILDEÚ CIRCUMFLEXÚ LEFTSHIFTÚ RIGHTSHIFTÚ DOUBLESTARÚ PLUSEQUALÚMINEQUALÚ STAREQUALÚ SLASHEQUALÚPERCENTEQUALÚ AMPEREQUALÚ VBAREQUALÚCIRCUMFLEXEQUALÚLEFTSHIFTEQUALÚRIGHTSHIFTEQUALÚDOUBLESTAREQUALÚDOUBLESLASHÚDOUBLESLASHEQUALÚATÚATEQUALÚOPÚCOMMENTÚNLÚRARROWÚAWAITÚASYNCÚ ERRORTOKENÚN_TOKENSr>Útok_nameÚlistÚglobalsÚitemsÚ_nameZ_valueÚtyperBrCrEr@r@r@rAÚsˆPKb31]÷*†u$u$%__pycache__/pgen.cpython-36.opt-1.pycnu„[µü¤3 \ô5ã@sdddlmZmZmZGdd„dejƒZGdd„deƒZGdd„deƒZGdd „d eƒZ ddd„Z d S)é)ÚgrammarÚtokenÚtokenizec@seZdZdS)ÚPgenGrammarN)Ú__name__Ú __module__Ú__qualname__©r r ú*/usr/lib64/python3.6/lib2to3/pgen2/pgen.pyrsrc@s eZdZd&dd„Zdd„Zdd„Zdd „Zd d„Zdd „Zdd„Z dd„Z dd„Zdd„Zdd„Z dd„Zdd„Zdd„Zdd„Zd'd d!„Zd"d#„Zd$d%„ZdS)(ÚParserGeneratorNcCsld}|dkrt|ƒ}|j}||_||_tj|jƒ|_|jƒ|j ƒ\|_ |_|dk rZ|ƒi|_|j ƒdS)N)ÚopenÚcloseÚfilenameÚstreamrÚgenerate_tokensÚreadlineÚ generatorÚgettokenÚparseÚdfasÚstartsymbolÚfirstÚaddfirstsets)ÚselfrrZclose_streamr r r Ú__init__szParserGenerator.__init__cCs*tƒ}t|jjƒƒ}|jƒ|j|jƒ|jd|jƒx.|D]&}dt|j ƒ}||j |<||j |<qtt|dƒ}||jkrz|j|S|jj|dfƒ||j|<|Snˆt |ƒ}|djƒrä||j krÂ|j |S|jjtj|fƒ||j |<|Sn>tj |}||jkr|j|S|jj|dfƒ||j|<|SdS)Nr)r"ZlabelsÚisalphar#Zsymbol2labelr'ÚgetattrrÚtokensÚevalÚkeywordsÚNAMErZopmap)rr.r4r7ZitokenÚvaluer r r r(=s6 zParserGenerator.make_labelcCs<t|jjƒƒ}|jƒx |D]}||jkr|j|ƒqWdS)N)rrrrrÚ calcfirst)rr/r0r r r rks zParserGenerator.addfirstsetsc Cs |j|}d|j|<|d}i}i}x†|jjƒD]x\}}||jkr”||jkrl|j|}|dkr€td|ƒ‚n|j|ƒ|j|}|j|ƒ|||<q0d||<|di||<q0Wi} xJ|jƒD]>\}} x4| D],}|| krìtd|||| |fƒ‚|| |<qÈWqºW||j|<dS)Nrzrecursion for rule %rrzArule %s is ambiguous; %s is in the first sets of %s as well as %s)rrr%r&Ú ValueErrorr?Úupdate)rr0r2r3ZtotalsetZoverlapcheckr4r5ÚfsetZinverseZitsfirstZsymbolr r r r?ss2 zParserGenerator.calcfirstc Cs¨i}d}x–|jtjkržx|jtjkr.|jƒqW|jtjƒ}|jtjdƒ|jƒ\}}|jtjƒ|j ||ƒ}t |ƒ}|j|ƒt |ƒ}|||<|dkr |}q W||fS)Nú:)ÚtyperÚ ENDMARKERÚNEWLINErÚexpectr=ÚOPÚ parse_rhsÚmake_dfar"Úsimplify_dfa) rrrr0ÚaÚzr2ZoldlenZnewlenr r r r‘s" zParserGenerator.parsecsÐ‡fdd„}‡fdd„‰t||ƒ|ƒg}x¢|D]š}i}x<|jD]2}x,|jD]"\}} |dk rJˆ| |j|iƒƒqJWq>WxRt|jƒƒD]B\}} x,|D]}|j| krPqWt| |ƒ}|j|ƒ|j||ƒq‚Wq.W|S)Ncsi}ˆ||ƒ|S)Nr )r3Úbase)Ú addclosurer r Úclosure°s z)ParserGenerator.make_dfa..closurecs>||krdSd||<x$|jD]\}}|dkrˆ||ƒqWdS)Nr)r%)r3rNr4r5)rOr r rO´sz,ParserGenerator.make_dfa..addclosure)ÚDFAStateÚnfasetr%Ú setdefaultr$r&r'Úaddarc)rr-ÚfinishrPr+r3r%Znfastater4r5rRÚstr )rOr rJ©s" zParserGenerator.make_dfac Cs¢td|ƒ|g}xŒt|ƒD]€\}}td|||kr4dp6dƒx^|jD]T\}}||kr^|j|ƒ} nt|ƒ} |j|ƒ|dkr†td| ƒqBtd|| fƒqBWqWdS)NzDump of NFA forz Statez(final)Úz -> %dz %s -> %d)ÚprintÚ enumerater%r)r"r') rr0r-rUZtodor1r3r4r5Újr r r Údump_nfaÍs zParserGenerator.dump_nfacCsltd|ƒx\t|ƒD]P\}}td||jr,dp.dƒx0t|jjƒƒD]\}}td||j|ƒfƒqBWqWdS)NzDump of DFA forz Statez(final)rWz %s -> %d)rXrYr*r$r%r&r))rr0r2r1r3r4r5r r r Údump_dfaÝs zParserGenerator.dump_dfacCs~d}xt|rxd}xft|ƒD]Z\}}xPt|dt|ƒƒD]:}||}||kr4||=x|D]}|j||ƒqTWd}Pq4WqWqWdS)NTFr)rYÚranger"Ú unifystate)rr2Zchangesr1Zstate_irZZstate_jr3r r r rKäs zParserGenerator.simplify_dfacCs‚|jƒ\}}|jdkr||fStƒ}tƒ}|j|ƒ|j|ƒx6|jdkrt|jƒ|jƒ\}}|j|ƒ|j|ƒq@W||fSdS)Nú|)Ú parse_altr>ÚNFAStaterTr)rrLrMZaaZzzr r r rIùs zParserGenerator.parse_rhscCsP|jƒ\}}x:|jdks*|jtjtjfkrF|jƒ\}}|j|ƒ|}qW||fS)Nú(ú[)rbrc)Ú parse_itemr>rDrr=ÚSTRINGrT)rrLÚbr.Údr r r r` s zParserGenerator.parse_altcCsŽ|jdkr>|jƒ|jƒ\}}|jtjdƒ|j|ƒ||fS|jƒ\}}|j}|dkr`||fS|jƒ|j|ƒ|dkr‚||fS||fSdS)Nrcú]ú+Ú*)rirj)r>rrIrGrrHrTÚ parse_atom)rrLrMr>r r r rds zParserGenerator.parse_itemcCs†|jdkr4|jƒ|jƒ\}}|jtjdƒ||fS|jtjtjfkrpt ƒ}t ƒ}|j ||jƒ|jƒ||fS|jd|j|jƒdS)Nrbú)z+expected (...) or NAME or STRING, got %s/%s)r>rrIrGrrHrDr=rerarTÚraise_error)rrLrMr r r rk(s zParserGenerator.parse_atomcCsD|j|ks|dk r2|j|kr2|jd|||j|jƒ|j}|jƒ|S)Nzexpected %s/%s, got %s/%s)rDr>rmr)rrDr>r r r rG9szParserGenerator.expectcCsJt|jƒ}x"|dtjtjfkr,t|jƒ}qW|\|_|_|_|_|_ dS)Nr) r5rrÚCOMMENTÚNLrDr>ZbeginÚendÚline)rÚtupr r r rAs zParserGenerator.gettokencGs^|r8y||}Wn&dj|gttt|ƒƒƒ}YnXt||j|jd|jd|jfƒ‚dS)Nú rr)ÚjoinrÚmapÚstrÚSyntaxErrorrrprq)rÚmsgÚargsr r r rmHs zParserGenerator.raise_error)N)N)rrrrr6r,r(rr?rrJr[r\rKrIr`rdrkrGrrmr r r r r s$ .$ rc@seZdZdd„Zddd„ZdS)racCs g|_dS)N)r%)rr r r rSszNFAState.__init__NcCs|jj||fƒdS)N)r%r')rr5r4r r r rTVszNFAState.addarc)N)rrrrrTr r r r raQsrac@s0eZdZdd„Zdd„Zdd„Zdd„Zd Zd S) rQcCs||_||k|_i|_dS)N)rRr*r%)rrRÚfinalr r r r]s zDFAState.__init__cCs||j|<dS)N)r%)rr5r4r r r rTeszDFAState.addarccCs.x(|jjƒD]\}}||kr||j|<qWdS)N)r%r&)rÚoldÚnewr4r5r r r r^kszDFAState.unifystatecCsX|j|jkrdSt|jƒt|jƒkr(dSx*|jjƒD]\}}||jj|ƒk r4dSq4WdS)NFT)r*r"r%r&Úget)rÚotherr4r5r r r Ú__eq__pszDFAState.__eq__N)rrrrrTr^rÚ__hash__r r r r rQ[s rQúGrammar.txtcCst|ƒ}|jƒS)N)rr6)rÚpr r r Úgenerate_grammar€srƒN)r)rWrrrZGrammarrÚobjectrrarQrƒr r r r ÚsI %PKb31]±.ÒÒ9&9&__pycache__/pgen.cpython-36.pycnu„[µü¤3 \ô5ã@sdddlmZmZmZGdd„dejƒZGdd„deƒZGdd„deƒZGdd „d eƒZ ddd„Z d S)é)ÚgrammarÚtokenÚtokenizec@seZdZdS)ÚPgenGrammarN)Ú__name__Ú __module__Ú__qualname__©r r ú*/usr/lib64/python3.6/lib2to3/pgen2/pgen.pyrsrc@s eZdZd&dd„Zdd„Zdd„Zdd „Zd d„Zdd „Zdd„Z dd„Z dd„Zdd„Zdd„Z dd„Zdd„Zdd„Zdd„Zd'd d!„Zd"d#„Zd$d%„ZdS)(ÚParserGeneratorNcCsld}|dkrt|ƒ}|j}||_||_tj|jƒ|_|jƒ|j ƒ\|_ |_|dk rZ|ƒi|_|j ƒdS)N)ÚopenÚcloseÚfilenameÚstreamrÚgenerate_tokensÚreadlineÚ generatorÚgettokenÚparseÚdfasÚstartsymbolÚfirstÚaddfirstsets)ÚselfrrZclose_streamr r r Ú__init__szParserGenerator.__init__cCs*tƒ}t|jjƒƒ}|jƒ|j|jƒ|jd|jƒx.|D]&}dt|j ƒ}||j |<||j |<qtj|}||jkr@|j|S|jj|dfƒ||j|<|SdS)Nrú"ú')r8r9)r"ZlabelsÚisalphar#Zsymbol2labelr'ÚgetattrrÚ isinstanceÚintÚAssertionErrorÚtok_nameÚtokensÚevalÚkeywordsÚNAMErZopmap)rr.r4r7ZitokenÚvaluer r r r(=s< zParserGenerator.make_labelcCs<t|jjƒƒ}|jƒx |D]}||jkr|j|ƒqWdS)N)rrrrrÚ calcfirst)rr/r0r r r rks zParserGenerator.addfirstsetsc Cs |j|}d|j|<|d}i}i}x†|jjƒD]x\}}||jkr”||jkrl|j|}|dkr€td|ƒ‚n|j|ƒ|j|}|j|ƒ|||<q0d||<|di||<q0Wi} xJ|jƒD]>\}} x4| D],}|| krìtd|||| |fƒ‚|| |<qÈWqºW||j|<dS)Nrzrecursion for rule %rrzArule %s is ambiguous; %s is in the first sets of %s as well as %s)rrr%r&Ú ValueErrorrEÚupdate)rr0r2r3ZtotalsetZoverlapcheckr4r5ÚfsetZinverseZitsfirstZsymbolr r r rEss2 zParserGenerator.calcfirstc Cs¨i}d}x–|jtjkržx|jtjkr.|jƒqW|jtjƒ}|jtjdƒ|jƒ\}}|jtjƒ|j ||ƒ}t |ƒ}|j|ƒt |ƒ}|||<|dkr |}q W||fS)Nú:)ÚtyperÚ ENDMARKERÚNEWLINErÚexpectrCÚOPÚ parse_rhsÚmake_dfar"Úsimplify_dfa) rrrr0ÚaÚzr2ZoldlenZnewlenr r r r‘s" zParserGenerator.parsecsìt|tƒst‚t|tƒst‚‡fdd„}‡fdd„‰t||ƒ|ƒg}x¢|D]š}i}x<|jD]2}x,|jD]"\}} |dk rfˆ| |j|iƒƒqfWqZWxRt|jƒƒD]B\}} x,|D]}|j| kr¬Pq¬Wt| |ƒ}|j |ƒ|j ||ƒqžWqJW|S)Ncsi}ˆ||ƒ|S)Nr )r3Úbase)Ú addclosurer r Úclosure°s z)ParserGenerator.make_dfa..closurecsLt|tƒst‚||krdSd||<x$|jD]\}}|dkr*ˆ||ƒq*WdS)Nr)r<ÚNFAStater>r%)r3rTr4r5)rUr r rU´sz,ParserGenerator.make_dfa..addclosure)r<rWr>ÚDFAStateÚnfasetr%Ú setdefaultr$r&r'Úaddarc)rr-ÚfinishrVr+r3r%Znfastater4r5rYÚstr )rUr rP©s& zParserGenerator.make_dfac Cs¢td|ƒ|g}xŒt|ƒD]€\}}td|||kr4dp6dƒx^|jD]T\}}||kr^|j|ƒ} nt|ƒ} |j|ƒ|dkr†td| ƒqBtd|| fƒqBWqWdS)NzDump of NFA forz Statez(final)Úz -> %dz %s -> %d)ÚprintÚ enumerater%r)r"r') rr0r-r\Ztodor1r3r4r5Újr r r Údump_nfaÍs zParserGenerator.dump_nfacCsltd|ƒx\t|ƒD]P\}}td||jr,dp.dƒx0t|jjƒƒD]\}}td||j|ƒfƒqBWqWdS)NzDump of DFA forz Statez(final)r^z %s -> %d)r_r`r*r$r%r&r))rr0r2r1r3r4r5r r r Údump_dfaÝs zParserGenerator.dump_dfacCs~d}xt|rxd}xft|ƒD]Z\}}xPt|dt|ƒƒD]:}||}||kr4||=x|D]}|j||ƒqTWd}Pq4WqWqWdS)NTFr)r`Úranger"Ú unifystate)rr2Zchangesr1Zstate_iraZstate_jr3r r r rQäs zParserGenerator.simplify_dfacCs‚|jƒ\}}|jdkr||fStƒ}tƒ}|j|ƒ|j|ƒx6|jdkrt|jƒ|jƒ\}}|j|ƒ|j|ƒq@W||fSdS)Nú|)Ú parse_altrDrWr[r)rrRrSZaaZzzr r r rOùs zParserGenerator.parse_rhscCsP|jƒ\}}x:|jdks*|jtjtjfkrF|jƒ\}}|j|ƒ|}qW||fS)Nú(ú[)rhri)Ú parse_itemrDrJrrCÚSTRINGr[)rrRÚbr.Údr r r rg s zParserGenerator.parse_altcCsŽ|jdkr>|jƒ|jƒ\}}|jtjdƒ|j|ƒ||fS|jƒ\}}|j}|dkr`||fS|jƒ|j|ƒ|dkr‚||fS||fSdS)Nriú]ú+Ú*)rorp)rDrrOrMrrNr[Ú parse_atom)rrRrSrDr r r rjs zParserGenerator.parse_itemcCs†|jdkr4|jƒ|jƒ\}}|jtjdƒ||fS|jtjtjfkrpt ƒ}t ƒ}|j ||jƒ|jƒ||fS|jd|j|jƒdS)Nrhú)z+expected (...) or NAME or STRING, got %s/%s)rDrrOrMrrNrJrCrkrWr[Úraise_error)rrRrSr r r rq(s zParserGenerator.parse_atomcCsD|j|ks|dk r2|j|kr2|jd|||j|jƒ|j}|jƒ|S)Nzexpected %s/%s, got %s/%s)rJrDrsr)rrJrDr r r rM9szParserGenerator.expectcCsJt|jƒ}x"|dtjtjfkr,t|jƒ}qW|\|_|_|_|_|_ dS)Nr) r5rrÚCOMMENTÚNLrJrDZbeginÚendÚline)rÚtupr r r rAs zParserGenerator.gettokencGs^|r8y||}Wn&dj|gttt|ƒƒƒ}YnXt||j|jd|jd|jfƒ‚dS)Nú rr)ÚjoinrÚmapÚstrÚSyntaxErrorrrvrw)rÚmsgÚargsr r r rsHs zParserGenerator.raise_error)N)N)rrrrr6r,r(rrErrPrbrcrQrOrgrjrqrMrrsr r r r r s$ .$ rc@seZdZdd„Zddd„ZdS)rWcCs g|_dS)N)r%)rr r r rSszNFAState.__init__NcCs8|dkst|tƒst‚t|tƒs$t‚|jj||fƒdS)N)r<r|r>rWr%r')rr5r4r r r r[VszNFAState.addarc)N)rrrrr[r r r r rWQsrWc@s0eZdZdd„Zdd„Zdd„Zdd„Zd Zd S) rXcCsLt|tƒst‚ttt|ƒƒtƒs$t‚t|tƒs2t‚||_||k|_i|_dS)N) r<Údictr>r5ÚiterrWrYr*r%)rrYÚfinalr r r r]s zDFAState.__init__cCs8t|tƒst‚||jkst‚t|tƒs*t‚||j|<dS)N)r<r|r>r%rX)rr5r4r r r r[eszDFAState.addarccCs.x(|jjƒD]\}}||kr||j|<qWdS)N)r%r&)rÚoldÚnewr4r5r r r rekszDFAState.unifystatecCsft|tƒst‚|j|jkrdSt|jƒt|jƒkr6dSx*|jjƒD]\}}||jj|ƒk rBdSqBWdS)NFT)r<rXr>r*r"r%r&Úget)rÚotherr4r5r r r Ú__eq__pszDFAState.__eq__N)rrrrr[rer‡Ú__hash__r r r r rX[s rXúGrammar.txtcCst|ƒ}|jƒS)N)rr6)rÚpr r r Úgenerate_grammar€sr‹N)r‰)r^rrrZGrammarrÚobjectrrWrXr‹r r r r ÚsI %PKb31]mSóÃÃ'__pycache__/driver.cpython-36.opt-2.pycnu„[µü¤3 \Œã@s°dZddgZddlZddlZddlZddlZddlZddlZddlm Z m Z mZmZm Z Gdd„deƒZdd „Zdd d„Zdd„Zdd„Zdd„Zedkr¬ejeeƒƒƒdS)z#Guido van Rossum ÚDriverÚload_grammaréNé)ÚgrammarÚparseÚtokenÚtokenizeÚpgenc@sHeZdZddd„Zddd„Zddd„Zdd d „Zddd„Zdd d„ZdS)rNcCs&||_|dkrtjƒ}||_||_dS)N)rÚloggingÚ getLoggerÚloggerÚconvert)Úselfrr r©rú,/usr/lib64/python3.6/lib2to3/pgen2/driver.pyÚ__init__ s zDriver.__init__FcCsvtj|j|jƒ}|jƒd}d}d}}}} } d}x4|D]}|\}}}} } |||fkr¤|\} }|| krˆ|d| |7}| }d}||kr¤|| ||…7}|}|tjtjfkrÜ||7}| \}}|jdƒr@|d7}d}q@|t j krðtj|}|r|jj dt j|||ƒ|j||||fƒr6|r4|jj dƒPd}| \}}|jdƒr@|d7}d}q@Wtjd||||fƒ‚|jS)NrrÚÚ z%s %r (prefix=%r)zStop.zincomplete input)rZParserrr ZsetuprÚCOMMENTÚNLÚendswithrÚOPZopmaprÚdebugÚtok_nameZaddtokenZ ParseErrorZrootnode)rÚtokensrÚpÚlinenoÚcolumnÚtypeÚvalueÚstartÚendZ line_textÚprefixZ quintupleZs_linenoZs_columnrrrÚparse_tokens'sR zDriver.parse_tokenscCstj|jƒ}|j||ƒS)N)rÚgenerate_tokensÚreadliner#)rÚstreamrrrrrÚparse_stream_rawWszDriver.parse_stream_rawcCs|j||ƒS)N)r')rr&rrrrÚparse_stream\szDriver.parse_streamc Cs*tj|d|ƒ}z|j||ƒS|jƒXdS)NÚr)ÚcodecsÚopenr(Úclose)rÚfilenameÚencodingrr&rrrÚ parse_file`szDriver.parse_filecCstjtj|ƒjƒ}|j||ƒS)N)rr$ÚioÚStringIOr%r#)rÚtextrrrrrÚparse_stringhszDriver.parse_string)NN)F)F)F)NF)F) Ú__name__Ú __module__Ú__qualname__rr#r'r(r/r3rrrrrs 0 cCs:tjj|ƒ\}}|dkrd}||djtttjƒƒdS)Nz.txtrÚ.z.pickle)ÚosÚpathÚsplitextÚjoinÚmapÚstrÚsysÚversion_info)ÚgtÚheadÚtailrrrÚ_generate_pickle_namensrCúGrammar.txtTFcCs°|dkrtjƒ}|dkr t|ƒn|}|s4t||ƒrš|jd|ƒtj|ƒ}|r¬|jd|ƒy|j|ƒWq¬tk r–}z|jd|ƒWYdd}~Xq¬Xnt j ƒ}|j|ƒ|S)Nz!Generating grammar tables from %szWriting grammar tables to %szWriting failed: %s)r rrCÚ_newerÚinfor Zgenerate_grammarÚdumpÚOSErrorrÚGrammarÚload)r@ZgpÚsaveÚforcerÚgÚerrrrus cCs8tjj|ƒsdStjj|ƒs dStjj|ƒtjj|ƒkS)NFT)r8r9ÚexistsÚgetmtime)ÚaÚbrrrrEŠs rEcCsFtjj|ƒrt|ƒSttjj|ƒƒ}tj||ƒ}tj ƒ}|j |ƒ|S)N)r8r9ÚisfilerrCÚbasenameÚpkgutilÚget_datarrIÚloads)ÚpackageZgrammar_sourceZpickled_nameÚdatarMrrrÚload_packaged_grammar“s rZcGsF|stjdd…}tjtjtjddx|D]}t|dddq,WdS)Nrz%(message)s)Úlevelr&ÚformatT)rKrL)r>Úargvr ZbasicConfigÚINFOÚstdoutr)Úargsr@rrrÚmain§s raÚ__main__)rDNTFN)Ú __author__Ú__all__r*r0r8r rUr>rrrrrr ÚobjectrrCrrErZrar4ÚexitÚintrrrrÚs"P PKb31]qMˆé««(__pycache__/grammar.cpython-36.opt-2.pycnu„[µü¤3 \½ã@stddlZddlZddlmZmZGdd„deƒZdd„ZdZiZ x.ej ƒD]"ZerJejƒ\Z Zeeeƒe e <qJWdS) éNé)ÚtokenÚtokenizec@s<eZdZdd„Zdd„Zdd„Zdd„Zd d „Zdd„Zd S)ÚGrammarcCs<i|_i|_g|_i|_dg|_i|_i|_i|_d|_dS)NrÚEMPTYé)rr) Ú symbol2numberÚ number2symbolÚstatesÚdfasÚlabelsÚkeywordsÚtokensÚsymbol2labelÚstart)Úself©rú-/usr/lib64/python3.6/lib2to3/pgen2/grammar.pyÚ__init__MszGrammar.__init__cCs2t|dƒ}t|jƒ}tj||dƒWdQRXdS)NÚwbé)ÚopenÚ_make_deterministicÚ__dict__ÚpickleÚdump)rÚfilenameÚfÚdrrrrXs zGrammar.dumpc Cs0t|dƒ}tj|ƒ}WdQRX|jj|ƒdS)NÚrb)rrÚloadrÚupdate)rrrrrrrr iszGrammar.loadcCs|jjtj|ƒƒdS)N)rr!rÚloads)rZpklrrrr"osz Grammar.loadscCsX|jƒ}x"dD]}t||t||ƒjƒƒqW|jdd…|_|jdd…|_|j|_|S)Nrr rr rr)rr rr rr)Ú __class__ÚsetattrÚgetattrÚcopyrr r)rÚnewZ dict_attrrrrr&sszGrammar.copycCsvddlm}tdƒ||jƒtdƒ||jƒtdƒ||jƒtdƒ||jƒtdƒ||jƒtd|jƒdS) Nr)ÚpprintZs2nZn2sr rrr)r(Úprintrr r rrr)rr(rrrÚreport€s zGrammar.reportN) Ú__name__Ú __module__Ú__qualname__rrr r"r&r*rrrrrs6 rcCs^t|tƒr&tjtdd„|jƒDƒƒƒSt|tƒr>dd„|DƒSt|tƒrZtdd„|DƒƒS|S)Ncss|]\}}|t|ƒfVqdS)N)r)Ú.0ÚkÚvrrrú “sz&_make_deterministic..cSsg|]}t|ƒ‘qSr)r)r.Úerrrú •sz'_make_deterministic..css|]}t|ƒVqdS)N)r)r.r2rrrr1—s)Ú isinstanceÚdictÚcollectionsÚOrderedDictÚsortedÚitemsÚlistÚtuple)Útoprrrrs ra ( LPAR ) RPAR [ LSQB ] RSQB : COLON , COMMA ; SEMI + PLUS - MINUS * STAR / SLASH | VBAR & AMPER < LESS > GREATER = EQUAL . DOT % PERCENT ` BACKQUOTE { LBRACE } RBRACE @ AT @= ATEQUAL == EQEQUAL != NOTEQUAL <> NOTEQUAL <= LESSEQUAL >= GREATEREQUAL ~ TILDE ^ CIRCUMFLEX << LEFTSHIFT >> RIGHTSHIFT ** DOUBLESTAR += PLUSEQUAL -= MINEQUAL *= STAREQUAL /= SLASHEQUAL %= PERCENTEQUAL &= AMPEREQUAL |= VBAREQUAL ^= CIRCUMFLEXEQUAL <<= LEFTSHIFTEQUAL >>= RIGHTSHIFTEQUAL **= DOUBLESTAREQUAL // DOUBLESLASH //= DOUBLESLASHEQUAL -> RARROW )r6rÚrrÚobjectrrZ opmap_rawZopmapÚ splitlinesÚlineÚsplitÚopÚnamer%rrrrÚsy=PKb31]ú¬”PP%__pycache__/conv.cpython-36.opt-2.pycnu„[µü¤3 \ª%ã@s.ddlZddlmZmZGdd„dejƒZdS)éN)ÚgrammarÚtokenc@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) Ú ConvertercCs |j|ƒ|j|ƒ|jƒdS)N)Úparse_graminit_hÚparse_graminit_cÚ finish_off)ÚselfZ graminit_hZ graminit_c©r ú*/usr/lib64/python3.6/lib2to3/pgen2/conv.pyÚrun/s z Converter.runc CsÂyt|ƒ}Wn0tk r<}ztd||fƒdSd}~XnXi|_i|_d}xn|D]f}|d7}tjd|ƒ}|r’|jƒr’td|||jƒfƒqT|jƒ\}}t |ƒ}||j|<||j|<qTWdS)NzCan't open %s: %sFréz^#define\s+(\w+)\s+(\d+)$z%s(%s): can't parse %sT) ÚopenÚOSErrorÚprintZ symbol2numberZ number2symbolÚreÚmatchÚstripÚgroupsÚint) rÚfilenameÚfÚerrÚlinenoÚlineÚmoÚsymbolÚnumberr r r r5s& zConverter.parse_graminit_hc!CsÜyt|ƒ}Wn0tk r<}ztd||fƒdSd}~XnXd}|dt|ƒ}}|dt|ƒ}}|dt|ƒ}}i}g}x‚|jdƒrx¼|jdƒrLtjd|ƒ}ttt |j ƒƒƒ\} } }g}xRt|ƒD]F} |dt|ƒ}}tjd|ƒ}ttt |j ƒƒƒ\}}|j||fƒqÐW|dt|ƒ}}||| | f<|dt|ƒ}}q’Wtjd|ƒ}ttt |j ƒƒƒ\}}g}x^t|ƒD]R} |dt|ƒ}}tjd |ƒ}ttt |j ƒƒƒ\}} } || | f}|j|ƒq~W|j|ƒ|dt|ƒ}}|dt|ƒ}}q„W||_ i}tjd |ƒ}t |jdƒƒ}xòt|ƒD]æ}|dt|ƒ}}tjd|ƒ}|jdƒ}ttt |jdd ddƒƒƒ\}}}}||}|dt|ƒ}}tjd|ƒ}i}t|jdƒƒ}xPt|ƒD]D\}}t|ƒ}x0tdƒD]$}|d|>@rÞd||d|<qÞWqÄW||f||<q4W|dt|ƒ}}||_g}|dt|ƒ}}tjd|ƒ}t |jdƒƒ}xjt|ƒD]^}|dt|ƒ}}tjd|ƒ}|j ƒ\}}t |ƒ}|dkr¶d}nt|ƒ}|j||fƒqpW|dt|ƒ}}||_|dt|ƒ}}|dt|ƒ}}tjd|ƒ}t |jdƒƒ}|dt|ƒ}}|dt|ƒ}}tjd|ƒ}t |jdƒƒ}|dt|ƒ}}tjd|ƒ}t |jdƒƒ} | |_|dt|ƒ}}y|dt|ƒ}}Wntk rÖYnXdS)NzCan't open %s: %sFrrzstatic arc z)static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$z\s+{(\d+), (\d+)},$z'static state states_(\d+)\[(\d+)\] = {$z\s+{(\d+), arcs_(\d+)_(\d+)},$zstatic dfa dfas\[(\d+)\] = {$z0\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$ééééz\s+("(?:\\\d\d\d)*")},$éz!static label labels\[(\d+)\] = {$z\s+{(\d+), (0|"\w+")},$Ú0z \s+(\d+),$z\s+{(\d+), labels},$z \s+(\d+)$)r rrÚnextÚ startswithrrÚlistÚmaprrÚrangeÚappendÚstatesÚgroupÚevalÚ enumerateÚordÚdfasÚlabelsÚstartÚ StopIteration)!rrrrrrZallarcsr)rÚnÚmÚkZarcsÚ_ÚiÚjÚsÚtÚstater.ZndfasrrÚxÚyÚzÚfirstZ rawbitsetÚcZbyter/Znlabelsr0r r r rTsº " zConverter.parse_graminit_ccCs\i|_i|_xJt|jƒD]<\}\}}|tjkrB|dk rB||j|<q|dkr||j|<qWdS)N)ÚkeywordsÚtokensr,r/rÚNAME)rZilabelÚtypeÚvaluer r r rùszConverter.finish_offN)Ú__name__Ú __module__Ú__qualname__rrrrr r r r r$s &r)rZpgen2rrZGrammarrr r r r ÚsPKb31] úÉ&__pycache__/parse.cpython-36.opt-2.pycnu„[µü¤3 \uã@s0ddlmZGdd„deƒZGdd„deƒZdS)é)Útokenc@seZdZdd„ZdS)Ú ParseErrorcCs4tj|d||||fƒ||_||_||_||_dS)Nz!%s: type=%r, value=%r, context=%r)Ú ExceptionÚ__init__ÚmsgÚtypeÚvalueÚcontext)Úselfrrrr ©rú+/usr/lib64/python3.6/lib2to3/pgen2/parse.pyrszParseError.__init__N)Ú__name__Ú __module__Ú__qualname__rrrrrrsrc@sHeZdZddd„Zddd„Zdd„Zdd „Zd d„Zdd „Zdd„Z dS)ÚParserNcCs||_|pdd„|_dS)NcSs|S)Nr)ÚgrammarÚnoderrrÚWsz!Parser.__init__..)rÚconvert)r rrrrrr9szParser.__init__cCsH|dkr|jj}|ddgf}|jj|d|f}|g|_d|_tƒ|_dS)Né)rÚstartÚdfasÚstackÚrootnodeÚsetÚ used_names)r rÚnewnodeZ stackentryrrrÚsetupYs zParser.setupcCs:|j|||ƒ}x$|jd\}}}|\}} ||} xü| D]¸\}}|jj|\} }||kr´|j||||ƒ|}x@||d|fgkr®|jƒ|js”dS|jd \}}}|\}} qpWdS| dkr:|jj| }|\}}||kr:|j| |jj| ||ƒPq:Wd|f| kr$|jƒ|js2td|||ƒ‚qtd|||ƒ‚qWdS) NrrTFéztoo much inputz bad inputéÿÿÿÿr) ÚclassifyrrZlabelsÚshiftÚpoprÚpushr)r rrr ÚilabelÚdfaÚstaterZstatesÚfirstZarcsÚiÚnewstateÚtÚvZitsdfaZ itsstatesZitsfirstrrrÚaddtokenqs:zParser.addtokencCsX|tjkr0|jj|ƒ|jjj|ƒ}|dk r0|S|jjj|ƒ}|dkrTtd|||ƒ‚|S)Nz bad token) rÚNAMErÚaddrÚkeywordsÚgetÚtokensr)r rrr r$rrrr ¡s zParser.classifyc CsT|jd\}}}|||df}|j|j|ƒ}|dk r@|dj|ƒ|||f|jd<dS)Nrrrr)rrrÚappend) r rrr)r r%r&rrrrrr!¯szParser.shiftc CsB|jd\}}}|d|gf}|||f|jd<|jj|d|fƒdS)Nrrrr)rr2) r rZnewdfar)r r%r&rrrrrr#¸szParser.pushcCs`|jjƒ\}}}|j|j|ƒ}|dk r\|jrL|jd\}}}|dj|ƒn||_|j|j_dS)Nrrr)rr"rrr2rr)r ZpopdfaZpopstateZpopnoderr%r&rrrrr"¿sz Parser.pop)N)N) r rrrrr,r r!r#r"rrrrrs 0 rN)ÚrrrÚobjectrrrrrÚsPKb31]™§&w,w,)__pycache__/tokenize.cpython-36.opt-2.pycnu„[µü¤3 \NXã=@sˆdZdZddlZddlZddlmZmZddlTddlm Z dd „e e ƒDƒd ddgZ[ yeWne k rzeZYnXd d„Zdd„Zdd„ZdZdZeedeƒeeƒZdZdZdZdZeddƒZeeeeeƒZdZeddƒeeƒZdeZeeeƒZed ed!ƒZeeeeƒZ d"Z!d#Z"d$Z#d%Z$d&Z%ee%d'e%d(ƒZ&ee%d)e%d*ƒZ'ed+d,d-d.d/d0d1d2d3ƒ Z(d4Z)ed5d6ƒZ*ee(e)e*ƒZ+ee e+e'eƒZ,ee,Z-ee%d7ed8dƒe%d9ed:dƒƒZ.edee&ƒZ/eee/e e+e.eƒZ0e1e2ej3e-e0e#e$fƒƒ\Z4Z5Z6Z7ej3e!ƒej3e"ƒe6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7e6e7ddddddddd;œ4Z8iZ9xd¡D]Z:e:e9e:<qˆWiZ;xd¢D]Z:e:e;e:<q¤WdŒZGdd„de=ƒZ?d‘d’„Z@e@fd“d „ZAd”d•„ZBGd–d—„d—ƒZCej3d˜ejDƒZEej3d™ejDƒZFdšd›„ZGdœd„ZHdžd„ZIdŸd„ZJeKd kr„ddlLZLeMeLjNƒdkrxeAeOeLjNdƒjPƒneAeLjQjPƒdS)£zKa-Ping Yee z@GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, Skip MontanaroéN)ÚBOM_UTF8Úlookup)Ú*é)ÚtokencCsg|]}|ddkr|‘qS)rÚ_©)Ú.0Úxrrú./usr/lib64/python3.6/lib2to3/pgen2/tokenize.pyú %srÚtokenizeÚgenerate_tokensÚ untokenizecGsddj|ƒdS)Nú(ú|ú))Újoin)ÚchoicesrrrÚgroup0srcGst|ŽdS)Nr)r)rrrrÚany1srcGst|ŽdS)Nú?)r)rrrrÚmaybe2srz[ \f\t]*z #[^\r\n]*z\\\r?\nz[a-zA-Z_]\w*z0[bB]_?[01]+(?:_[01]+)*z(0[xX]_?[\da-fA-F]+(?:_[\da-fA-F]+)*[lL]?z0[oO]?_?[0-7]+(?:_[0-7]+)*[lL]?z[1-9]\d*(?:_\d+)*[lL]?z0[lL]?z[eE][-+]?\d+(?:_\d+)*z\d+(?:_\d+)*\.(?:\d+(?:_\d+)*)?z\.\d+(?:_\d+)*z\d+(?:_\d+)*z\d+(?:_\d+)*[jJ]z[jJ]z[^'\\]*(?:\\.[^'\\]*)*'z[^"\\]*(?:\\.[^"\\]*)*"z%[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''z%[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""z#(?:[uUrRbBfF]|[rR][bB]|[bBuU][rR])?ú'''ú"""z'[^\n'\\]*(?:\\.[^\n'\\]*)*'z"[^\n"\\]*(?:\\.[^\n"\\]*)*"z\*\*=?z>>=?z<<=?z<>z!=z//=?z->z[+\-*/%&@|^=<>]=?ú~z[][(){}]z\r?\nz[:;.,`@]z'[^\n'\\]*(?:\\.[^\n'\\]*)*ú'z"[^\n"\\]*(?:\\.[^\n"\\]*)*ú")4rrz'''z"""zr'''zr"""zu'''zu"""zb'''zb"""zf'''zf"""zur'''zur"""zbr'''zbr"""zrb'''zrb"""zR'''zR"""zU'''zU"""zB'''zB"""zF'''zF"""zuR'''zuR"""zUr'''zUr"""zUR'''zUR"""zbR'''zbR"""zBr'''zBr"""zBR'''zBR"""zrB'''zrB"""zRb'''zRb"""zRB'''zRB"""ÚrÚRÚuÚUÚfÚFÚbÚBúr'''úr"""úR'''úR"""úu'''úu"""úU'''úU"""úb'''úb"""úB'''úB"""úf'''úf"""úF'''úF"""úur'''úur"""úUr'''úUr"""úuR'''úuR"""úUR'''úUR"""úbr'''úbr"""úBr'''úBr"""úbR'''úbR"""úBR'''úBR"""úrb'''úrb"""úRb'''úRb"""úrB'''úrB"""úRB'''úRB"""úr'úr"úR'úR"úu'úu"úU'úU"úb'úb"úB'úB"úf'úf"úF'úF"úur'úur"úUr'úUr"úuR'úuR"úUR'úUR"úbr'úbr"úBr'úBr"úbR'úbR"úBR'úBR"úrb'úrb"úRb'úRb"úrB'úrB"úRB'úRB"éc@seZdZdS)Ú TokenErrorN)Ú__name__Ú __module__Ú__qualname__rrrrrw¤srwc@seZdZdS)ÚStopTokenizingN)rxryrzrrrrr{¦sr{c Cs4|\}}|\}}td||||t|t|ƒfƒdS)Nz%d,%d-%d,%d: %s %s)ÚprintÚtok_nameÚrepr) ÚtyperZxxx_todo_changemeZxxx_todo_changeme1ÚlineZsrowZscolZerowZecolrrrÚ printtoken¨srcCs(yt||ƒWntk r"YnXdS)N)Ú tokenize_loopr{)ÚreadlineÚ tokeneaterrrrr ®s cCsxt|ƒD]}||Žq WdS)N)r)rƒr„Z token_inforrrr‚Ásr‚c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚUntokenizercCsg|_d|_d|_dS)Nrr)ÚtokensÚprev_rowÚprev_col)ÚselfrrrÚ__init__ÇszUntokenizer.__init__cCs*|\}}||j}|r&|jjd|ƒdS)Nú )rˆr†Úappend)r‰ÚstartÚrowÚcolÚ col_offsetrrrÚadd_whitespaceÌs zUntokenizer.add_whitespacecCs„xv|D]n}t|ƒdkr$|j||ƒP|\}}}}}|j|ƒ|jj|ƒ|\|_|_|ttfkr|jd7_d|_qWdj |jƒS)NérrÚ) ÚlenÚcompatr‘r†rŒr‡rˆÚNEWLINEÚNLr)r‰ÚiterableÚtÚtok_typerrÚendr€rrrrÓs zUntokenizer.untokenizec CsÒd}g}|jj}|\}}|ttfkr,|d7}|ttfkr|t kr˜|j ƒqBn*|ttfkrªd}n|rÂ|rÂ||dƒd}||ƒqBWdS)NFr‹Tr’réÿÿÿÿ)r†rŒÚNAMEÚNUMBERr–r—ÚASYNCÚAWAITÚINDENTÚDEDENTÚpop) r‰rr˜Ú startlineÚindentsÚtoks_appendÚtoknumÚtokvalÚtokrrrr•ás0 zUntokenizer.compatN)rxryrzrŠr‘rr•rrrrr…Åsr…z&^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)s^[ \t\f]*(?:[#\r\n]|$)cCsH|dd…jƒjddƒ}|dks*|jdƒr.dS|dks@|jd ƒrDdS|S)Nérú-zutf-8zutf-8-úlatin-1ú iso-8859-1úiso-latin-1úlatin-1-úiso-8859-1-úiso-latin-1-)r¬rr®)r¯r°r±)ÚlowerÚreplaceÚ startswith)Úorig_encÚencrrrÚ_get_normal_names r·cs¶d‰d}d}‡fdd„}‡fdd„}|ƒ}|jtƒrHd‰|dd…}d }|sT|gfS||ƒ}|rj||gfStj|ƒs~||gfS|ƒ}|s’||gfS||ƒ}|rª|||gfS|||gfS) NFzutf-8cs"yˆƒStk rtƒSXdS)N)Ú StopIterationÚbytesr)rƒrrÚread_or_stop sz%detect_encoding..read_or_stopcs”y|jdƒ}Wntk r"dSXtj|ƒ}|s6dSt|jdƒƒ}yt|ƒ}Wn tk rptd|ƒ‚YnXˆr|j dkrˆtdƒ‚|d7}|S)NÚasciirzunknown encoding: zutf-8zencoding problem: utf-8z-sig) ÚdecodeÚUnicodeDecodeErrorÚ cookie_reÚmatchr·rrÚLookupErrorÚSyntaxErrorÚname)r€Úline_stringr¿ÚencodingÚcodec)Ú bom_foundrrÚfind_cookie&s" z$detect_encoding..find_cookieTéz utf-8-sig)r´rÚblank_rer¿)rƒrÄÚdefaultrºrÇÚfirstÚsecondr)rÆrƒrÚdetect_encodings0 rÍcCstƒ}|j|ƒS)N)r…r)r˜ÚutrrrrTsc!csšd}}}tjdd}}d\}}d}dg} d} d}d}d} xüy |ƒ}Wntk rdd}YnX|d}dt|ƒ}}|rF|std|ƒ‚|j|ƒ}|rÞ|jdƒ}}t||d|…|||f||fVd \}}d}nd|r0|d!d…d kr0|d"d…dkr0t||||t|ƒf|fVd}d}qBn||}||}qBnF|dkrt|rt|s`Pd}xf||krÊ||dkrˆ|d}n6||d kr¨|t dt }n||dkr¼d}nP|d}qfW||krØP| rè| Vd} ||dkrž||dkrh||d…j dƒ}|t|ƒ}t|||f||t|ƒf|fVt||d…||f|t|ƒf|fVqBttf||dk||d…||f|t|ƒf|fVqB|| d#krÖ| j |ƒt|d|…|df||f|fVxt|| d$krJ|| krtdd|||fƒ‚| dd%…} |r.|| d&kr.d}d} d}td||f||f|fVqØW|rŒ| rŒ|| d'krŒd}d} d}n|sˆtd|dfƒ‚d}xª||kr8tj||ƒ}|r|jdƒ\}}||f||f|}}}|||…||}}||ks|dkr|dkrt||||fVq4|dkrft}|dkr8t}n |rBd} | rR| Vd} |||||fVq4|dkr”| r€| Vd} t||||fVq4|tkrt|}|j||ƒ}|rô|jdƒ}|||…}| rÞ| Vd} t||||f|fVn||f}||d…}|}Pq4|tks@|dd…tks@|dd …tkr¸|d(dkr”||f}t|pxt|dpxt|d}||d…d}}|}Pn | r¤| Vd} t||||fVq4||kr|d)krô|rô|dkràtnt||||fVqt||||f}|dkr| r|} q|dkrx| rx| dtkrx| ddkrxd}| d*}t| d| d| d | dfVd} | rˆ| Vd} |Vnz|dkrÄ| rª| Vd} t||||f|fVd}nF|dkrØ|d}n|dkrê|d}| rú| Vd} t||||fVn(t||||f||df|fV|d}qWqBW| rN| Vd} x.| dd…D]} td|df|dfdfVq\Wtd|df|dfdfVdS)+NrrÚ 0123456789r“FrzEOF in multi-line stringr’z\ rÈz\ r‹ú úz# ú#z z3unindent does not match any outer indentation levelz zEOF in multi-line statementÚ.TÚ ÚasyncÚawaitÚdeféú\z([{z)]})r“r)r“réþÿÿÿéýÿÿÿrœrœrœrœrœrœ)rÕrÖrœ)ÚstringZ ascii_lettersr¸r”rwr¿r›ÚSTRINGÚ ERRORTOKENÚtabsizeÚrstripÚCOMMENTr—rŒr¡ÚIndentationErrorr¢Ú pseudoprogÚspanržr–Ú triple_quotedÚendprogsÚ single_quotedrŸr rÚOPÚ ENDMARKER)!rƒÚlnumÚparenlevÚ continuedZ namecharsÚnumcharsÚcontstrÚneedcontÚcontliner¥ÚstashedÚ async_defÚasync_def_indentÚasync_def_nlr€ÚposÚmaxÚstrstartÚendprogÚendmatchr›ÚcolumnÚ comment_tokenÚnl_posÚpseudomatchrÚsposÚeposrÚinitialÚnewliner©Úindentrrrrisp * Ú__main__)*rrr&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrM)*rrrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtru)RÚ __author__Ú__credits__rÜÚreÚcodecsrrZlib2to3.pgen2.tokenr“rÚdirÚ__all__r¹Ú NameErrorÚstrrrrÚ WhitespaceÚCommentÚIgnoreÚNameÚ BinnumberÚ HexnumberÚ OctnumberÚ DecnumberÚ IntnumberÚExponentÚ PointfloatÚExpfloatÚFloatnumberÚ ImagnumberÚNumberÚSingleÚDoubleÚSingle3ÚDouble3Z _litprefixÚTripleÚStringÚOperatorÚBracketÚSpecialÚFunnyÚ PlainTokenÚTokenÚContStrÚPseudoExtrasÚPseudoTokenÚlistÚmapÚcompileZ tokenprogrãZsingle3progZdouble3progrærår™rçrßÚ Exceptionrwr{rr r‚r…ÚASCIIr¾rÉr·rÍrrrxÚsysr”ÚargvÚopenrƒÚstdinrrrrÚsü 8Ic PKb31]¬v]—Ò;Ò;)__pycache__/tokenize.cpython-36.opt-1.pycnu„[µü¤3 \NXã=@sŒdZdZdZddlZddlZddlmZmZddlTddl m Z d d „ee ƒDƒddd gZ[ ye Wnek r~eZ YnXdd„Zdd„Zdd„ZdZdZeedeƒeeƒZdZdZdZdZeddƒZeeeeeƒZdZeddƒeeƒZd eZeeeƒZed!ed"ƒZ ee eeƒZ!d#Z"d$Z#d%Z$d&Z%d'Z&ee&d(e&d)ƒZ'ee&d*e&d+ƒZ(ed,d-d.d/d0d1d2d3d4ƒ Z)d5Z*ed6d7ƒZ+ee)e*e+ƒZ,ee!e,e(eƒZ-ee-Z.ee&d8ed9dƒe&d:ed;dƒƒZ/edee'ƒZ0eee0e!e,e/eƒZ1e2e3ej4e.e1e$e%fƒƒ\Z5Z6Z7Z8ej4e"ƒej4e#ƒe7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8ddddddddd<œ4Z9iZ:xd¢D]Z;e;e:e;<qŒWiZƒZ?Gdd‘„d‘e>ƒZ@d’d“„ZAeAfd”d„ZBd•d–„ZCGd—d˜„d˜ƒZDej4d™ejEƒZFej4dšejEƒZGd›dœ„ZHddž„ZIdŸd „ZJd d„ZKeLd¡krˆddlMZMeNeMjOƒdkr|eBePeMjOdƒjQƒneBeMjRjQƒdS)¤aÀTokenization help for Python programs. generate_tokens(readline) is a generator that breaks a stream of text into Python tokens. It accepts a readline-like method which is called repeatedly to get the next line of input (or "" for EOF). It generates 5-tuples with these members: the token type (see token.py) the token (a string) the starting (row, column) indices of the token (a 2-tuple of ints) the ending (row, column) indices of the token (a 2-tuple of ints) the original line (string) It is designed to match the working of the Python tokenizer exactly, except that it produces COMMENT tokens for comments and gives type OP for all operators Older entry points tokenize_loop(readline, tokeneater) tokenize(readline, tokeneater=printtoken) are the same, except instead of generating tokens, tokeneater is a callback function to which the 5 fields described above are passed as 5 arguments, each time a new token is found.zKa-Ping Yee z@GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, Skip MontanaroéN)ÚBOM_UTF8Úlookup)Ú*é)ÚtokencCsg|]}|ddkr|‘qS)rÚ_©)Ú.0Úxrrú./usr/lib64/python3.6/lib2to3/pgen2/tokenize.pyú %srÚtokenizeÚgenerate_tokensÚ untokenizecGsddj|ƒdS)Nú(ú|ú))Újoin)ÚchoicesrrrÚgroup0srcGst|ŽdS)Nr)r)rrrrÚany1srcGst|ŽdS)Nú?)r)rrrrÚmaybe2srz[ \f\t]*z #[^\r\n]*z\\\r?\nz[a-zA-Z_]\w*z0[bB]_?[01]+(?:_[01]+)*z(0[xX]_?[\da-fA-F]+(?:_[\da-fA-F]+)*[lL]?z0[oO]?_?[0-7]+(?:_[0-7]+)*[lL]?z[1-9]\d*(?:_\d+)*[lL]?z0[lL]?z[eE][-+]?\d+(?:_\d+)*z\d+(?:_\d+)*\.(?:\d+(?:_\d+)*)?z\.\d+(?:_\d+)*z\d+(?:_\d+)*z\d+(?:_\d+)*[jJ]z[jJ]z[^'\\]*(?:\\.[^'\\]*)*'z[^"\\]*(?:\\.[^"\\]*)*"z%[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''z%[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""z#(?:[uUrRbBfF]|[rR][bB]|[bBuU][rR])?ú'''ú"""z'[^\n'\\]*(?:\\.[^\n'\\]*)*'z"[^\n"\\]*(?:\\.[^\n"\\]*)*"z\*\*=?z>>=?z<<=?z<>z!=z//=?z->z[+\-*/%&@|^=<>]=?ú~z[][(){}]z\r?\nz[:;.,`@]z'[^\n'\\]*(?:\\.[^\n'\\]*)*ú'z"[^\n"\\]*(?:\\.[^\n"\\]*)*ú")4rrz'''z"""zr'''zr"""zu'''zu"""zb'''zb"""zf'''zf"""zur'''zur"""zbr'''zbr"""zrb'''zrb"""zR'''zR"""zU'''zU"""zB'''zB"""zF'''zF"""zuR'''zuR"""zUr'''zUr"""zUR'''zUR"""zbR'''zbR"""zBr'''zBr"""zBR'''zBR"""zrB'''zrB"""zRb'''zRb"""zRB'''zRB"""ÚrÚRÚuÚUÚfÚFÚbÚBúr'''úr"""úR'''úR"""úu'''úu"""úU'''úU"""úb'''úb"""úB'''úB"""úf'''úf"""úF'''úF"""úur'''úur"""úUr'''úUr"""úuR'''úuR"""úUR'''úUR"""úbr'''úbr"""úBr'''úBr"""úbR'''úbR"""úBR'''úBR"""úrb'''úrb"""úRb'''úRb"""úrB'''úrB"""úRB'''úRB"""úr'úr"úR'úR"úu'úu"úU'úU"úb'úb"úB'úB"úf'úf"úF'úF"úur'úur"úUr'úUr"úuR'úuR"úUR'úUR"úbr'úbr"úBr'úBr"úbR'úbR"úBR'úBR"úrb'úrb"úRb'úRb"úrB'úrB"úRB'úRB"éc@seZdZdS)Ú TokenErrorN)Ú__name__Ú __module__Ú__qualname__rrrrrw¤srwc@seZdZdS)ÚStopTokenizingN)rxryrzrrrrr{¦sr{c Cs4|\}}|\}}td||||t|t|ƒfƒdS)Nz%d,%d-%d,%d: %s %s)ÚprintÚtok_nameÚrepr) ÚtyperZxxx_todo_changemeZxxx_todo_changeme1ÚlineZsrowZscolZerowZecolrrrÚ printtoken¨srcCs(yt||ƒWntk r"YnXdS)a: The tokenize() function accepts two parameters: one representing the input stream, and one providing an output mechanism for tokenize(). The first parameter, readline, must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. The second parameter, tokeneater, must also be a callable object. It is called once for each token, with five arguments, corresponding to the tuples generated by generate_tokens(). N)Ú tokenize_loopr{)ÚreadlineÚ tokeneaterrrrr ®s cCsxt|ƒD]}||Žq WdS)N)r)rƒr„Z token_inforrrr‚Ásr‚c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚUntokenizercCsg|_d|_d|_dS)Nrr)ÚtokensÚprev_rowÚprev_col)ÚselfrrrÚ__init__ÇszUntokenizer.__init__cCs*|\}}||j}|r&|jjd|ƒdS)Nú )rˆr†Úappend)r‰ÚstartÚrowÚcolÚ col_offsetrrrÚadd_whitespaceÌs zUntokenizer.add_whitespacecCs„xv|D]n}t|ƒdkr$|j||ƒP|\}}}}}|j|ƒ|jj|ƒ|\|_|_|ttfkr|jd7_d|_qWdj |jƒS)NérrÚ) ÚlenÚcompatr‘r†rŒr‡rˆÚNEWLINEÚNLr)r‰ÚiterableÚtÚtok_typerrÚendr€rrrrÓs zUntokenizer.untokenizec CsÒd}g}|jj}|\}}|ttfkr,|d7}|ttfkr|t kr˜|j ƒqBn*|ttfkrªd}n|rÂ|rÂ||dƒd}||ƒqBWdS)NFr‹Tr’réÿÿÿÿ)r†rŒÚNAMEÚNUMBERr–r—ÚASYNCÚAWAITÚINDENTÚDEDENTÚpop) r‰rr˜Ú startlineÚindentsÚtoks_appendÚtoknumÚtokvalÚtokrrrr•ás0 zUntokenizer.compatN)rxryrzrŠr‘rr•rrrrr…Åsr…z&^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)s^[ \t\f]*(?:[#\r\n]|$)cCsH|dd…jƒjddƒ}|dks*|jdƒr.dS|d ks@|jdƒrDdS|S)z(Imitates get_normal_name in tokenizer.c.Nérú-zutf-8zutf-8-úlatin-1ú iso-8859-1úiso-latin-1úlatin-1-úiso-8859-1-úiso-latin-1-)r¬rr®)r¯r°r±)ÚlowerÚreplaceÚ startswith)Úorig_encÚencrrrÚ_get_normal_names r·cs¶d‰d}d}‡fdd„}‡fdd„}|ƒ}|jtƒrHd‰|d d…}d }|sT|gfS||ƒ}|rj||gfStj|ƒs~||gfS|ƒ}|s’||gfS||ƒ}|rª|||gfS|||gfS)a The detect_encoding() function is used to detect the encoding that should be used to decode a Python source file. It requires one argument, readline, in the same way as the tokenize() generator. It will call readline a maximum of twice, and return the encoding used (as a string) and a list of any lines (left as bytes) it has read in. It detects the encoding from the presence of a utf-8 bom or an encoding cookie as specified in pep-0263. If both a bom and a cookie are present, but disagree, a SyntaxError will be raised. If the encoding cookie is an invalid charset, raise a SyntaxError. Note that if a utf-8 bom is found, 'utf-8-sig' is returned. If no encoding is specified, then the default of 'utf-8' will be returned. FNzutf-8cs"yˆƒStk rtƒSXdS)N)Ú StopIterationÚbytesr)rƒrrÚread_or_stop sz%detect_encoding..read_or_stopcs”y|jdƒ}Wntk r"dSXtj|ƒ}|s6dSt|jdƒƒ}yt|ƒ}Wn tk rptd|ƒ‚YnXˆr|j dkrˆtdƒ‚|d7}|S)NÚasciirzunknown encoding: zutf-8zencoding problem: utf-8z-sig) ÚdecodeÚUnicodeDecodeErrorÚ cookie_reÚmatchr·rrÚLookupErrorÚSyntaxErrorÚname)r€Úline_stringr¿ÚencodingÚcodec)Ú bom_foundrrÚfind_cookie&s" z$detect_encoding..find_cookieTéz utf-8-sig)r´rÚblank_rer¿)rƒrÄÚdefaultrºrÇÚfirstÚsecondr)rÆrƒrÚdetect_encodings0 rÍcCstƒ}|j|ƒS)a¬Transform tokens back into Python source code. Each element returned by the iterable must be a token sequence with at least two elements, a token number and token value. If only two tokens are passed, the resulting output is poor. Round-trip invariant for full input: Untokenized source will match input source exactly Round-trip invariant for limited intput: # Output text will tokenize the back to the input t1 = [tok[:2] for tok in generate_tokens(f.readline)] newcode = untokenize(t1) readline = iter(newcode.splitlines(1)).next t2 = [tok[:2] for tokin generate_tokens(readline)] assert t1 == t2 )r…r)r˜ÚutrrrrTsc!csšd}}}tjdd}}d \}}d}dg} d} d}d}d} xüy |ƒ}Wntk rdd}YnX|d}dt|ƒ}}|rF|std|ƒ‚|j|ƒ}|rÞ|jdƒ}}t||d|…|||f||fVd!\}}d}nd|r0|d"d…d kr0|d#d…dkr0t||||t|ƒf|fVd}d}qBn||}||}qBnF|dkrt|rt|s`Pd}xf||krÊ||d krˆ|d}n6||dkr¨|t dt }n||dkr¼d}nP|d}qfW||krØP| rè| Vd} ||dkrž||dkrh||d…j dƒ}|t|ƒ}t|||f||t|ƒf|fVt||d…||f|t|ƒf|fVqBttf||dk||d…||f|t|ƒf|fVqB|| d$krÖ| j |ƒt|d|…|df||f|fVxt|| d%krJ|| krtdd|||fƒ‚| dd&…} |r.|| d'kr.d}d} d}td||f||f|fVqØW|rŒ| rŒ|| d(krŒd}d} d}n|sˆtd|dfƒ‚d}xª||kr8tj||ƒ}|r|jdƒ\}}||f||f|}}}|||…||}}||ks|dkr|dkrt||||fVq4|dkrft}|dkr8t}n |rBd} | rR| Vd} |||||fVq4|dkr”| r€| Vd} t||||fVq4|tkrt|}|j||ƒ}|rô|jdƒ}|||…}| rÞ| Vd} t||||f|fVn||f}||d…}|}Pq4|tks@|dd …tks@|dd…tkr¸|d)dkr”||f}t|pxt|dpxt|d }||d…d}}|}Pn | r¤| Vd} t||||fVq4||kr|d*krô|rô|dkràtnt||||fVqt||||f}|dkr| r|} q|dkrx| rx| dtkrx| ddkrxd}| d+}t| d| d | d| dfVd} | rˆ| Vd} |Vnz|dkrÄ| rª| Vd} t||||f|fVd}nF|dkrØ|d}n|dkrê|d}| rú| Vd} t||||fVn(t||||f||df|fV|d}qWqBW| rN| Vd} x.| dd…D]} td|df|dfdfVq\Wtd|df|dfdfVdS),aT The generate_tokens() generator requires one argument, readline, which must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. Alternately, readline can be a callable function terminating with StopIteration: readline = open(myfile).next # Example of alternate readline The generator produces 5-tuples with these members: the token type; the token string; a 2-tuple (srow, scol) of ints specifying the row and column where the token begins in the source; a 2-tuple (erow, ecol) of ints specifying the row and column where the token ends in the source; and the line on which the token was found. The line passed is the logical line; continuation lines are included. rrÚ 0123456789r“NFrzEOF in multi-line stringr’z\ rÈz\ r‹ú úz# ú#z z3unindent does not match any outer indentation levelz zEOF in multi-line statementÚ.TÚ ÚasyncÚawaitÚdeféú\z([{z)]})r“r)r“réþÿÿÿéýÿÿÿrœrœrœrœrœrœ)rÕrÖrœ)ÚstringZ ascii_lettersr¸r”rwr¿r›ÚSTRINGÚ ERRORTOKENÚtabsizeÚrstripÚCOMMENTr—rŒr¡ÚIndentationErrorr¢Ú pseudoprogÚspanržr–Ú triple_quotedÚendprogsÚ single_quotedrŸr rÚOPÚ ENDMARKER)!rƒÚlnumÚparenlevÚ continuedZ namecharsÚnumcharsÚcontstrÚneedcontÚcontliner¥ÚstashedÚ async_defÚasync_def_indentÚasync_def_nlr€ÚposÚmaxÚstrstartÚendprogÚendmatchr›ÚcolumnÚ comment_tokenÚnl_posÚpseudomatchrÚsposÚeposrÚinitialÚnewliner©Úindentrrrrisp * Ú__main__)*rrr&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrM)*rrrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtru)SÚ__doc__Ú __author__Ú__credits__rÜÚreÚcodecsrrZlib2to3.pgen2.tokenr“rÚdirÚ__all__r¹Ú NameErrorÚstrrrrÚ WhitespaceÚCommentÚIgnoreÚNameÚ BinnumberÚ HexnumberÚ OctnumberÚ DecnumberÚ IntnumberÚExponentÚ PointfloatÚExpfloatÚFloatnumberÚ ImagnumberÚNumberÚSingleÚDoubleÚSingle3ÚDouble3Z _litprefixÚTripleÚStringÚOperatorÚBracketÚSpecialÚFunnyÚ PlainTokenÚTokenÚContStrÚPseudoExtrasÚPseudoTokenÚlistÚmapÚcompileZ tokenprogrãZsingle3progZdouble3progrærår™rçrßÚ Exceptionrwr{rr r‚r…ÚASCIIr¾rÉr·rÍrrrxÚsysr”ÚargvÚopenrƒÚstdinrrrrÚsþ 8Ic PKb31]_íÏ¨ &__pycache__/token.cpython-36.opt-2.pycnu„[µü¤3 \ã@sLdZdZdZdZdZdZdZdZdZd Z d Z dZdZd Z dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd Z d!Z!d"Z"d#Z#d$Z$d%Z%d&Z&d'Z'd(Z(d)Z)d*Z*d+Z+d,Z,d-Z-d.Z.d/Z/d0Z0d1Z1d2Z2d3Z3d4Z4d5Z5d6Z6d7Z7d8Z8d9Z9d:Z:d;Z;de?ƒj@ƒƒD]$\ZAZBeCeBƒeCdƒkreAe=eB<qWd=d>„ZDd?d@„ZEdAdB„ZFdCS)Déééééééééé é ééé ééééééééééééééééééé é!é"é#é$é%é&é'é(é)é*é+é,é-é.é/é0é1é2é3é4é5é6é7é8é9é:é;écCs|tkS)N)Ú NT_OFFSET)Úx©r@ú+/usr/lib64/python3.6/lib2to3/pgen2/token.pyÚ ISTERMINALNsrBcCs|tkS)N)r>)r?r@r@rAÚ ISNONTERMINALQsrCcCs|tkS)N)Ú ENDMARKER)r?r@r@rAÚISEOFTsrEN)GrDÚNAMEÚNUMBERÚSTRINGÚNEWLINEÚINDENTÚDEDENTÚLPARÚRPARÚLSQBÚRSQBÚCOLONÚCOMMAÚSEMIÚPLUSÚMINUSÚSTARÚSLASHÚVBARÚAMPERÚLESSÚGREATERÚEQUALÚDOTÚPERCENTZ BACKQUOTEÚLBRACEÚRBRACEÚEQEQUALÚNOTEQUALÚ LESSEQUALÚGREATEREQUALÚTILDEÚ CIRCUMFLEXÚ LEFTSHIFTÚ RIGHTSHIFTÚ DOUBLESTARÚ PLUSEQUALÚMINEQUALÚ STAREQUALÚ SLASHEQUALÚPERCENTEQUALÚ AMPEREQUALÚ VBAREQUALÚCIRCUMFLEXEQUALÚLEFTSHIFTEQUALÚRIGHTSHIFTEQUALÚDOUBLESTAREQUALÚDOUBLESLASHÚDOUBLESLASHEQUALÚATÚATEQUALÚOPÚCOMMENTÚNLÚRARROWÚAWAITÚASYNCÚ ERRORTOKENÚN_TOKENSr>Útok_nameÚlistÚglobalsÚitemsÚ_nameZ_valueÚtyperBrCrEr@r@r@rAÚ s†PKb31]‚ÏSã<< __pycache__/token.cpython-36.pycnu„[µü¤3 \ã@sPdZdZdZdZdZdZdZdZdZd Z d Z dZdZd Z dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd Z d!Z!d"Z"d#Z#d$Z$d%Z%d&Z&d'Z'd(Z(d)Z)d*Z*d+Z+d,Z,d-Z-d.Z.d/Z/d0Z0d1Z1d2Z2d3Z3d4Z4d5Z5d6Z6d7Z7d8Z8d9Z9d:Z:d;Z;dx6e?e@ƒjAƒƒD]$\ZBZCeDeCƒeDdƒkreBe>eC<qWd>d?„ZEd@dA„ZFdBdC„ZGdDS)Ez!Token constants (from "token.h").éééééééééé é ééé ééééééééééééééééééé é!é"é#é$é%é&é'é(é)é*é+é,é-é.é/é0é1é2é3é4é5é6é7é8é9é:é;écCs|tkS)N)Ú NT_OFFSET)Úx©r@ú+/usr/lib64/python3.6/lib2to3/pgen2/token.pyÚ ISTERMINALNsrBcCs|tkS)N)r>)r?r@r@rAÚ ISNONTERMINALQsrCcCs|tkS)N)Ú ENDMARKER)r?r@r@rAÚISEOFTsrEN)HÚ__doc__rDÚNAMEÚNUMBERÚSTRINGÚNEWLINEÚINDENTÚDEDENTÚLPARÚRPARÚLSQBÚRSQBÚCOLONÚCOMMAÚSEMIÚPLUSÚMINUSÚSTARÚSLASHÚVBARÚAMPERÚLESSÚGREATERÚEQUALÚDOTÚPERCENTZ BACKQUOTEÚLBRACEÚRBRACEÚEQEQUALÚNOTEQUALÚ LESSEQUALÚGREATEREQUALÚTILDEÚ CIRCUMFLEXÚ LEFTSHIFTÚ RIGHTSHIFTÚ DOUBLESTARÚ PLUSEQUALÚMINEQUALÚ STAREQUALÚ SLASHEQUALÚPERCENTEQUALÚ AMPEREQUALÚ VBAREQUALÚCIRCUMFLEXEQUALÚLEFTSHIFTEQUALÚRIGHTSHIFTEQUALÚDOUBLESTAREQUALÚDOUBLESLASHÚDOUBLESLASHEQUALÚATÚATEQUALÚOPÚCOMMENTÚNLÚRARROWÚAWAITÚASYNCÚ ERRORTOKENÚN_TOKENSr>Útok_nameÚlistÚglobalsÚitemsÚ_nameZ_valueÚtyperBrCrEr@r@r@rAÚsˆPKb31]5³f››&__pycache__/parse.cpython-36.opt-1.pycnu„[µü¤3 \uã@s4dZddlmZGdd„deƒZGdd„deƒZdS)zÈParser engine for the grammar tables generated by pgen. The grammar table must be loaded first. See Parser/parser.c in the Python distribution for additional info on how this parsing engine works. é)Útokenc@seZdZdZdd„ZdS)Ú ParseErrorz(Exception to signal the parser is stuck.cCs4tj|d||||fƒ||_||_||_||_dS)Nz!%s: type=%r, value=%r, context=%r)Ú ExceptionÚ__init__ÚmsgÚtypeÚvalueÚcontext)Úselfrrrr ©rú+/usr/lib64/python3.6/lib2to3/pgen2/parse.pyrszParseError.__init__N)Ú__name__Ú __module__Ú__qualname__Ú__doc__rrrrrrsrc@sLeZdZdZddd„Zddd„Zdd„Zd d „Zdd„Zd d„Z dd„Z dS)ÚParsera5Parser engine. The proper usage sequence is: p = Parser(grammar, [converter]) # create instance p.setup([start]) # prepare for parsing : if p.addtoken(...): # parse a token; may raise ParseError break root = p.rootnode # root of abstract syntax tree A Parser instance may be reused by calling setup() repeatedly. A Parser instance contains state pertaining to the current token sequence, and should not be used concurrently by different threads to parse separate token sequences. See driver.py for how to get input tokens by tokenizing a file or string. Parsing is complete when addtoken() returns True; the root of the abstract syntax tree can then be retrieved from the rootnode instance variable. When a syntax error occurs, addtoken() raises the ParseError exception. There is no error recovery; the parser cannot be used after a syntax error was reported (but it can be reinitialized by calling setup()). NcCs||_|pdd„|_dS)aÚConstructor. The grammar argument is a grammar.Grammar instance; see the grammar module for more information. The parser is not ready yet for parsing; you must call the setup() method to get it started. The optional convert argument is a function mapping concrete syntax tree nodes to abstract syntax tree nodes. If not given, no conversion is done and the syntax tree produced is the concrete syntax tree. If given, it must be a function of two arguments, the first being the grammar (a grammar.Grammar instance), and the second being the concrete syntax tree node to be converted. The syntax tree is converted from the bottom up. A concrete syntax tree node is a (type, value, context, nodes) tuple, where type is the node type (a token or symbol number), value is None for symbols and a string for tokens, context is None or an opaque value used for error reporting (typically a (lineno, offset) pair), and nodes is a list of children for symbols, and None for tokens. An abstract syntax tree node may be anything; this is entirely up to the converter function. cSs|S)Nr)ÚgrammarÚnoderrrÚWsz!Parser.__init__..N)rÚconvert)r rrrrrr9szParser.__init__cCsH|dkr|jj}|ddgf}|jj|d|f}|g|_d|_tƒ|_dS)a›Prepare for parsing. This *must* be called before starting to parse. The optional argument is an alternative start symbol; it defaults to the grammar's start symbol. You can use a Parser instance to parse any number of programs; each time you call setup() the parser is reset to an initial state determined by the (implicit or explicit) start symbol. Né)rÚstartÚdfasÚstackÚrootnodeÚsetÚ used_names)r rÚnewnodeZ stackentryrrrÚsetupYs zParser.setupcCs:|j|||ƒ}x$|jd \}}}|\}} ||} xü| D]¸\}}|jj|\} }||kr´|j||||ƒ|}x@||d|fgkr®|jƒ|js”dS|jd \}}}|\}} qpWdS| dkr:|jj| }|\}}||kr:|j| |jj| ||ƒPq:Wd|f| kr$|jƒ|js2td|||ƒ‚qtd|||ƒ‚qWdS)zsPKb31]žz“ƒƒ)__pycache__/__init__.cpython-36.opt-2.pycnu„[µü¤3 \ã@sdS)N©rrrú./usr/lib64/python3.6/lib2to3/pgen2/__init__.pyÚsPKb31]’1äÆþþ#__pycache__/literals.cpython-36.pycnu„[µü¤3 \Oã@sPdZddlZddddddd d ddd œ Zdd„Zdd„Zdd„ZedkrLeƒdS)ztdƒD]2}t|ƒ}t|ƒ}t|ƒ}||kr t||||ƒq WdS)Né)Úranger r*r0Úprint)r%Úcr.Úer&r&r'Útest2sr6Ú__main__)Ú__doc__r,rr(r0r6Ú__name__r&r&r&r'Ús PKb31]÷*†u$u$%__pycache__/pgen.cpython-36.opt-2.pycnu„[µü¤3 \ô5ã@sdddlmZmZmZGdd„dejƒZGdd„deƒZGdd„deƒZGdd „d eƒZ ddd„Z d S)é)ÚgrammarÚtokenÚtokenizec@seZdZdS)ÚPgenGrammarN)Ú__name__Ú __module__Ú__qualname__©r r ú*/usr/lib64/python3.6/lib2to3/pgen2/pgen.pyrsrc@s eZdZd&dd„Zdd„Zdd„Zdd „Zd d„Zdd „Zdd„Z dd„Z dd„Zdd„Zdd„Z dd„Zdd„Zdd„Zdd„Zd'd d!„Zd"d#„Zd$d%„ZdS)(ÚParserGeneratorNcCsld}|dkrt|ƒ}|j}||_||_tj|jƒ|_|jƒ|j ƒ\|_ |_|dk rZ|ƒi|_|j ƒdS)N)ÚopenÚcloseÚfilenameÚstreamrÚgenerate_tokensÚreadlineÚ generatorÚgettokenÚparseÚdfasÚstartsymbolÚfirstÚaddfirstsets)ÚselfrrZclose_streamr r r Ú__init__szParserGenerator.__init__cCs*tƒ}t|jjƒƒ}|jƒ|j|jƒ|jd|jƒx.|D]&}dt|j ƒ}||j |<||j |<qtt|dƒ}||jkrz|j|S|jj|dfƒ||j|<|Snˆt |ƒ}|djƒrä||j krÂ|j |S|jjtj|fƒ||j |<|Sn>tj |}||jkr|j|S|jj|dfƒ||j|<|SdS)Nr)r"ZlabelsÚisalphar#Zsymbol2labelr'ÚgetattrrÚtokensÚevalÚkeywordsÚNAMErZopmap)rr.r4r7ZitokenÚvaluer r r r(=s6 zParserGenerator.make_labelcCs<t|jjƒƒ}|jƒx |D]}||jkr|j|ƒqWdS)N)rrrrrÚ calcfirst)rr/r0r r r rks zParserGenerator.addfirstsetsc Cs |j|}d|j|<|d}i}i}x†|jjƒD]x\}}||jkr”||jkrl|j|}|dkr€td|ƒ‚n|j|ƒ|j|}|j|ƒ|||<q0d||<|di||<q0Wi} xJ|jƒD]>\}} x4| D],}|| krìtd|||| |fƒ‚|| |<qÈWqºW||j|<dS)Nrzrecursion for rule %rrzArule %s is ambiguous; %s is in the first sets of %s as well as %s)rrr%r&Ú ValueErrorr?Úupdate)rr0r2r3ZtotalsetZoverlapcheckr4r5ÚfsetZinverseZitsfirstZsymbolr r r r?ss2 zParserGenerator.calcfirstc Cs¨i}d}x–|jtjkržx|jtjkr.|jƒqW|jtjƒ}|jtjdƒ|jƒ\}}|jtjƒ|j ||ƒ}t |ƒ}|j|ƒt |ƒ}|||<|dkr |}q W||fS)Nú:)ÚtyperÚ ENDMARKERÚNEWLINErÚexpectr=ÚOPÚ parse_rhsÚmake_dfar"Úsimplify_dfa) rrrr0ÚaÚzr2ZoldlenZnewlenr r r r‘s" zParserGenerator.parsecsÐ‡fdd„}‡fdd„‰t||ƒ|ƒg}x¢|D]š}i}x<|jD]2}x,|jD]"\}} |dk rJˆ| |j|iƒƒqJWq>WxRt|jƒƒD]B\}} x,|D]}|j| krPqWt| |ƒ}|j|ƒ|j||ƒq‚Wq.W|S)Ncsi}ˆ||ƒ|S)Nr )r3Úbase)Ú addclosurer r Úclosure°s z)ParserGenerator.make_dfa..closurecs>||krdSd||<x$|jD]\}}|dkrˆ||ƒqWdS)Nr)r%)r3rNr4r5)rOr r rO´sz,ParserGenerator.make_dfa..addclosure)ÚDFAStateÚnfasetr%Ú setdefaultr$r&r'Úaddarc)rr-ÚfinishrPr+r3r%Znfastater4r5rRÚstr )rOr rJ©s" zParserGenerator.make_dfac Cs¢td|ƒ|g}xŒt|ƒD]€\}}td|||kr4dp6dƒx^|jD]T\}}||kr^|j|ƒ} nt|ƒ} |j|ƒ|dkr†td| ƒqBtd|| fƒqBWqWdS)NzDump of NFA forz Statez(final)Úz -> %dz %s -> %d)ÚprintÚ enumerater%r)r"r') rr0r-rUZtodor1r3r4r5Újr r r Údump_nfaÍs zParserGenerator.dump_nfacCsltd|ƒx\t|ƒD]P\}}td||jr,dp.dƒx0t|jjƒƒD]\}}td||j|ƒfƒqBWqWdS)NzDump of DFA forz Statez(final)rWz %s -> %d)rXrYr*r$r%r&r))rr0r2r1r3r4r5r r r Údump_dfaÝs zParserGenerator.dump_dfacCs~d}xt|rxd}xft|ƒD]Z\}}xPt|dt|ƒƒD]:}||}||kr4||=x|D]}|j||ƒqTWd}Pq4WqWqWdS)NTFr)rYÚranger"Ú unifystate)rr2Zchangesr1Zstate_irZZstate_jr3r r r rKäs zParserGenerator.simplify_dfacCs‚|jƒ\}}|jdkr||fStƒ}tƒ}|j|ƒ|j|ƒx6|jdkrt|jƒ|jƒ\}}|j|ƒ|j|ƒq@W||fSdS)Nú|)Ú parse_altr>ÚNFAStaterTr)rrLrMZaaZzzr r r rIùs zParserGenerator.parse_rhscCsP|jƒ\}}x:|jdks*|jtjtjfkrF|jƒ\}}|j|ƒ|}qW||fS)Nú(ú[)rbrc)Ú parse_itemr>rDrr=ÚSTRINGrT)rrLÚbr.Údr r r r` s zParserGenerator.parse_altcCsŽ|jdkr>|jƒ|jƒ\}}|jtjdƒ|j|ƒ||fS|jƒ\}}|j}|dkr`||fS|jƒ|j|ƒ|dkr‚||fS||fSdS)Nrcú]ú+Ú*)rirj)r>rrIrGrrHrTÚ parse_atom)rrLrMr>r r r rds zParserGenerator.parse_itemcCs†|jdkr4|jƒ|jƒ\}}|jtjdƒ||fS|jtjtjfkrpt ƒ}t ƒ}|j ||jƒ|jƒ||fS|jd|j|jƒdS)Nrbú)z+expected (...) or NAME or STRING, got %s/%s)r>rrIrGrrHrDr=rerarTÚraise_error)rrLrMr r r rk(s zParserGenerator.parse_atomcCsD|j|ks|dk r2|j|kr2|jd|||j|jƒ|j}|jƒ|S)Nzexpected %s/%s, got %s/%s)rDr>rmr)rrDr>r r r rG9szParserGenerator.expectcCsJt|jƒ}x"|dtjtjfkr,t|jƒ}qW|\|_|_|_|_|_ dS)Nr) r5rrÚCOMMENTÚNLrDr>ZbeginÚendÚline)rÚtupr r r rAs zParserGenerator.gettokencGs^|r8y||}Wn&dj|gttt|ƒƒƒ}YnXt||j|jd|jd|jfƒ‚dS)Nú rr)ÚjoinrÚmapÚstrÚSyntaxErrorrrprq)rÚmsgÚargsr r r rmHs zParserGenerator.raise_error)N)N)rrrrr6r,r(rr?rrJr[r\rKrIr`rdrkrGrrmr r r r r s$ .$ rc@seZdZdd„Zddd„ZdS)racCs g|_dS)N)r%)rr r r rSszNFAState.__init__NcCs|jj||fƒdS)N)r%r')rr5r4r r r rTVszNFAState.addarc)N)rrrrrTr r r r raQsrac@s0eZdZdd„Zdd„Zdd„Zdd„Zd Zd S) rQcCs||_||k|_i|_dS)N)rRr*r%)rrRÚfinalr r r r]s zDFAState.__init__cCs||j|<dS)N)r%)rr5r4r r r rTeszDFAState.addarccCs.x(|jjƒD]\}}||kr||j|<qWdS)N)r%r&)rÚoldÚnewr4r5r r r r^kszDFAState.unifystatecCsX|j|jkrdSt|jƒt|jƒkr(dSx*|jjƒD]\}}||jj|ƒk r4dSq4WdS)NFT)r*r"r%r&Úget)rÚotherr4r5r r r Ú__eq__pszDFAState.__eq__N)rrrrrTr^rÚ__hash__r r r r rQ[s rQúGrammar.txtcCst|ƒ}|jƒS)N)rr6)rÚpr r r Úgenerate_grammar€srƒN)r)rWrrrZGrammarrÚobjectrrarQrƒr r r r ÚsI %PKb31]¡6Ã!%__pycache__/conv.cpython-36.opt-1.pycnu„[µü¤3 \ª%ã@s2dZddlZddlmZmZGdd„dejƒZdS)aýConvert graminit.[ch] spit out by pgen to Python code. Pgen is the Python parser generator. It is useful to quickly create a parser from a grammar file in Python's grammar notation. But I don't want my parsers to be written in C (yet), so I'm translating the parsing tables to Python data structures and writing a Python parse engine. Note that the token numbers are constants determined by the standard Python tokenizer. The standard token module defines these numbers and their names (the names are not used much). The token numbers are hardcoded into the Python tokenizer and into pgen. A Python implementation of the Python tokenizer is also available, in the standard tokenize module. On the other hand, symbol numbers (representing the grammar's non-terminals) are assigned by pgen based on the actual grammar input. Note: this module is pretty much obsolete; the pgen module generates equivalent grammar tables directly from the Grammar.txt input file without having to invoke the Python pgen C program. éN)ÚgrammarÚtokenc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)Ú Convertera2Grammar subclass that reads classic pgen output files. The run() method reads the tables as produced by the pgen parser generator, typically contained in two C files, graminit.h and graminit.c. The other methods are for internal use only. See the base class for more documentation. cCs |j|ƒ|j|ƒ|jƒdS)z@rÞd||d|<qÞWqÄW||f||<q4W|dt|ƒ}}||_g}|dt|ƒ}}tjd|ƒ}t |jdƒƒ}xjt|ƒD]^}|dt|ƒ}}tjd|ƒ}|j ƒ\}}t |ƒ}|dkr¶d}nt|ƒ}|j||fƒqpW|dt|ƒ}}||_|dt|ƒ}}|dt|ƒ}}tjd|ƒ}t |jdƒƒ}|dt|ƒ}}|dt|ƒ}}tjd|ƒ}t |jdƒƒ}|dt|ƒ}}tjd|ƒ}t |jdƒƒ} | |_|dt|ƒ}}y|dt|ƒ}}Wntk rÖYnXdS)aùParse the .c file written by pgen. (Internal) The file looks as follows. The first two lines are always this: #include "pgenheaders.h" #include "grammar.h" After that come four blocks: 1) one or more state definitions 2) a table defining dfas 3) a table defining labels 4) a struct defining the grammar A state definition has the following form: - one or more arc arrays, each of the form: static arc arcs__[] = { {, }, ... }; - followed by a state array, of the form: static state states_[] = { {, arcs__}, ... }; zCan't open %s: %sFNrrzstatic arc z)static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$z\s+{(\d+), (\d+)},$z'static state states_(\d+)\[(\d+)\] = {$z\s+{(\d+), arcs_(\d+)_(\d+)},$zstatic dfa dfas\[(\d+)\] = {$z0\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$ééééz\s+("(?:\\\d\d\d)*")},$éz!static label labels\[(\d+)\] = {$z\s+{(\d+), (0|"\w+")},$Ú0z \s+(\d+),$z\s+{(\d+), labels},$z \s+(\d+)$)r rrÚnextÚ startswithrrÚlistÚmaprrÚrangeÚappendÚstatesÚgroupÚevalÚ enumerateÚordÚdfasÚlabelsÚstartÚ StopIteration)!rrrrrrZallarcsr)rÚnÚmÚkZarcsÚ_ÚiÚjÚsÚtÚstater.ZndfasrrÚxÚyÚzÚfirstZ rawbitsetÚcZbyter/Znlabelsr0r r r rTsº " zConverter.parse_graminit_ccCs\i|_i|_xJt|jƒD]<\}\}}|tjkrB|dk rB||j|<q|dkr||j|<qWdS)z1Create additional useful structures. (Internal).N)ÚkeywordsÚtokensr,r/rÚNAME)rZilabelÚtypeÚvaluer r r rùszConverter.finish_offN)Ú__name__Ú __module__Ú__qualname__Ú__doc__rrrrr r r r r$s &r)rHrZpgen2rrZGrammarrr r r r ÚsPKb31]&Ã{õõ)__pycache__/literals.cpython-36.opt-2.pycnu„[µü¤3 \Oã@sLddlZdddddddd d ddœ Zd d„Zdd„Zdd„ZedkrHeƒdS)éNúúúÚ ú ú úú'ú"ú\) ÚaÚbÚfÚnÚrÚtÚvr r rcCs¾|jddƒ\}}tj|ƒ}|dk r&|S|jdƒr†|dd…}t|ƒdkrTtd|ƒ‚yt|dƒ}Wq¶tk r‚td|ƒ‚Yq¶Xn0yt|dƒ}Wn tk r´td|ƒ‚YnXt|ƒS) NréÚxéz!invalid hex string escape ('\%s')ééz#invalid octal string escape ('\%s'))ÚgroupÚsimple_escapesÚgetÚ startswithÚlenÚ ValueErrorÚintÚchr)ÚmÚallÚtailÚescZhexesÚi©r%ú./usr/lib64/python3.6/lib2to3/pgen2/literals.pyÚescapes" r'cCsH|d}|dd…|dkr$|d}|t|ƒt|ƒ…}tjdt|ƒS)Nréz)\\(\'|\"|\\|[abfnrtv]|x.{0,2}|[0-7]{1,3}))rÚreÚsubr')ÚsÚqr%r%r&Ú evalString(s r-cCsDx>tdƒD]2}t|ƒ}t|ƒ}t|ƒ}||kr t||||ƒq WdS)Né)ÚrangerÚreprr-Úprint)r$Úcr+Úer%r%r&Útest2sr4Ú__main__)r)rr'r-r4Ú__name__r%r%r%r&Ús PKb31]ÆF¨xx__pycache__/conv.cpython-36.pycnu„[µü¤3 \ª%ã@s2dZddlZddlmZmZGdd„dejƒZdS)aýConvert graminit.[ch] spit out by pgen to Python code. Pgen is the Python parser generator. It is useful to quickly create a parser from a grammar file in Python's grammar notation. But I don't want my parsers to be written in C (yet), so I'm translating the parsing tables to Python data structures and writing a Python parse engine. Note that the token numbers are constants determined by the standard Python tokenizer. The standard token module defines these numbers and their names (the names are not used much). The token numbers are hardcoded into the Python tokenizer and into pgen. A Python implementation of the Python tokenizer is also available, in the standard tokenize module. On the other hand, symbol numbers (representing the grammar's non-terminals) are assigned by pgen based on the actual grammar input. Note: this module is pretty much obsolete; the pgen module generates equivalent grammar tables directly from the Grammar.txt input file without having to invoke the Python pgen C program. éN)ÚgrammarÚtokenc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)Ú Convertera2Grammar subclass that reads classic pgen output files. The run() method reads the tables as produced by the pgen parser generator, typically contained in two C files, graminit.h and graminit.c. The other methods are for internal use only. See the base class for more documentation. cCs |j|ƒ|j|ƒ|jƒdS)z@rPd||d|<qPWq6W||f||<qW|dt|ƒ}}|dks¸t||fƒ‚||_g}|dt|ƒ}}tjd|ƒ}|sòt||fƒ‚t |jdƒƒ}x|t|ƒD]p}|dt|ƒ}}tjd|ƒ}|s>t||fƒ‚|jƒ\}}t |ƒ}|dkrbd}nt|ƒ}|j ||fƒq W|dt|ƒ}}|dks¦t||fƒ‚||_|dt|ƒ}}|dksÔt||fƒ‚|dt|ƒ}}tjd|ƒ}|st||fƒ‚t |jdƒƒ}|t|jƒks&t‚|dt|ƒ}}|dksNt||fƒ‚|dt|ƒ}}tjd|ƒ}|s~t||fƒ‚t |jdƒƒ}|t|jƒks¨t||fƒ‚|dt|ƒ}}tjd|ƒ}|sØt||fƒ‚t |jdƒƒ} | |jksþt||fƒ‚| |_|dt|ƒ}}|dks,t||fƒ‚y|dt|ƒ}}Wntk rXYnXdslt||fƒ‚dS)aùParse the .c file written by pgen. (Internal) The file looks as follows. The first two lines are always this: #include "pgenheaders.h" #include "grammar.h" After that come four blocks: 1) one or more state definitions 2) a table defining dfas 3) a table defining labels 4) a struct defining the grammar A state definition has the following form: - one or more arc arrays, each of the form: static arc arcs__[] = { {, }, ... }; - followed by a state array, of the form: static state states_[] = { {, arcs__}, ... }; zCan't open %s: %sFNrrz#include "pgenheaders.h" z#include "grammar.h" zstatic arc z)static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$z\s+{(\d+), (\d+)},$z}; z'static state states_(\d+)\[(\d+)\] = {$z\s+{(\d+), arcs_(\d+)_(\d+)},$zstatic dfa dfas\[(\d+)\] = {$z0\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$ééééz\s+("(?:\\\d\d\d)*")},$éz!static label labels\[(\d+)\] = {$z\s+{(\d+), (0|"\w+")},$Ú0zgrammar _PyParser_Grammar = { z \s+(\d+),$z dfas, z\s+{(\d+), labels},$z \s+(\d+)$)r rrÚnextrÚ startswithrrÚlistÚmaprrÚrangeÚappendÚlenÚstatesÚgrouprrÚevalÚ enumerateÚordÚdfasÚlabelsÚstartÚ StopIteration)!rrrrrrZallarcsr-rÚnÚmÚkZarcsÚ_ÚiÚjÚsÚtÚstater2ZndfasrrÚxÚyÚzÚfirstZ rawbitsetÚcZbyter3Znlabelsr4r r r rTsö " zConverter.parse_graminit_ccCs\i|_i|_xJt|jƒD]<\}\}}|tjkrB|dk rB||j|<q|dkr||j|<qWdS)z1Create additional useful structures. (Internal).N)ÚkeywordsÚtokensr0r3rÚNAME)rZilabelÚtypeÚvaluer r r rùszConverter.finish_offN)Ú__name__Ú __module__Ú__qualname__Ú__doc__rrrrr r r r r$s &r)rLrZpgen2rrZGrammarrr r r r ÚsPKb31]‘’æ‘‘"__pycache__/grammar.cpython-36.pycnu„[µü¤3 \½ã@sxdZddlZddlZddlmZmZGdd„deƒZdd„Zd Z iZ x.e jƒD]"ZerNej ƒ\ZZeeeƒe e<qNWdS) a‡This module defines the data structures used to represent a grammar. These are a bit arcane because they are derived from the data structures used by Python's 'pgen' parser generator. There's also a table here mapping operators to their names in the token module; the Python tokenize module reports all operators as the fallback token code OP, but the parser needs the actual token code. éNé)ÚtokenÚtokenizec@s@eZdZdZdd„Zdd„Zdd„Zdd „Zd d„Zdd „Z dS)ÚGrammara¶ Pgen parsing tables conversion class. Once initialized, this class supplies the grammar tables for the parsing engine implemented by parse.py. The parsing engine accesses the instance variables directly. The class here does not provide initialization of the tables; several subclasses exist to do this (see the conv and pgen modules). The load() method reads the tables from a pickle file, which is much faster than the other ways offered by subclasses. The pickle file is written by calling dump() (after loading the grammar tables using a subclass). The report() method prints a readable representation of the tables to stdout, for debugging. The instance variables are as follows: symbol2number -- a dict mapping symbol names to numbers. Symbol numbers are always 256 or higher, to distinguish them from token numbers, which are between 0 and 255 (inclusive). number2symbol -- a dict mapping numbers to symbol names; these two are each other's inverse. states -- a list of DFAs, where each DFA is a list of states, each state is a list of arcs, and each arc is a (i, j) pair where i is a label and j is a state number. The DFA number is the index into this list. (This name is slightly confusing.) Final states are represented by a special arc of the form (0, j) where j is its own state number. dfas -- a dict mapping symbol numbers to (DFA, first) pairs, where DFA is an item from the states list above, and first is a set of tokens that can begin this grammar rule (represented by a dict whose values are always 1). labels -- a list of (x, y) pairs where x is either a token number or a symbol number, and y is either None or a string; the strings are keywords. The label number is the index in this list; label numbers are used to mark state transitions (arcs) in the DFAs. start -- the number of the grammar's start symbol. keywords -- a dict mapping keyword strings to arc labels. tokens -- a dict mapping token numbers to arc labels. cCs<i|_i|_g|_i|_dg|_i|_i|_i|_d|_dS)NrÚEMPTYé)rr) Ú symbol2numberÚ number2symbolÚstatesÚdfasÚlabelsÚkeywordsÚtokensÚsymbol2labelÚstart)Úself©rú-/usr/lib64/python3.6/lib2to3/pgen2/grammar.pyÚ__init__MszGrammar.__init__cCs2t|dƒ}t|jƒ}tj||dƒWdQRXdS)a½Dump the grammar tables to a pickle file. dump() recursively changes all dict to OrderedDict, so the pickled file is not exactly the same as what was passed in to dump(). load() uses the pickled file to create the tables, but only changes OrderedDict to dict at the top level; it does not recursively change OrderedDict to dict. So, the loaded tables are different from the original tables that were passed to load() in that some of the OrderedDict (from the pickled file) are not changed back to dict. For parsing, this has no effect on performance because OrderedDict uses dict's __getitem__ with nothing in between. ÚwbéN)ÚopenÚ_make_deterministicÚ__dict__ÚpickleÚdump)rÚfilenameÚfÚdrrrrXs zGrammar.dumpc Cs0t|dƒ}tj|ƒ}WdQRX|jj|ƒdS)z+Load the grammar tables from a pickle file.ÚrbN)rrÚloadrÚupdate)rrrrrrrr iszGrammar.loadcCs|jjtj|ƒƒdS)z3Load the grammar tables from a pickle bytes object.N)rr!rÚloads)rZpklrrrr"osz Grammar.loadscCsX|jƒ}x"dD]}t||t||ƒjƒƒqW|jdd…|_|jdd…|_|j|_|S) z# Copy the grammar. rr rr rrN)rr rr rr)Ú __class__ÚsetattrÚgetattrÚcopyrr r)rÚnewZ dict_attrrrrr&sszGrammar.copycCsvddlm}tdƒ||jƒtdƒ||jƒtdƒ||jƒtdƒ||jƒtdƒ||jƒtd|jƒd S) z:Dump the grammar tables to standard output, for debugging.r)ÚpprintZs2nZn2sr rrrN)r(Úprintrr r rrr)rr(rrrÚreport€s zGrammar.reportN) Ú__name__Ú __module__Ú__qualname__Ú__doc__rrr r"r&r*rrrrrs4 rcCs^t|tƒr&tjtdd„|jƒDƒƒƒSt|tƒr>dd„|DƒSt|tƒrZtdd„|DƒƒS|S)Ncss|]\}}|t|ƒfVqdS)N)r)Ú.0ÚkÚvrrrú “sz&_make_deterministic..cSsg|]}t|ƒ‘qSr)r)r/Úerrrú •sz'_make_deterministic..css|]}t|ƒVqdS)N)r)r/r3rrrr2—s)Ú isinstanceÚdictÚcollectionsÚOrderedDictÚsortedÚitemsÚlistÚtuple)Útoprrrrs ra ( LPAR ) RPAR [ LSQB ] RSQB : COLON , COMMA ; SEMI + PLUS - MINUS * STAR / SLASH | VBAR & AMPER < LESS > GREATER = EQUAL . DOT % PERCENT ` BACKQUOTE { LBRACE } RBRACE @ AT @= ATEQUAL == EQEQUAL != NOTEQUAL <> NOTEQUAL <= LESSEQUAL >= GREATEREQUAL ~ TILDE ^ CIRCUMFLEX << LEFTSHIFT >> RIGHTSHIFT ** DOUBLESTAR += PLUSEQUAL -= MINEQUAL *= STAREQUAL /= SLASHEQUAL %= PERCENTEQUAL &= AMPEREQUAL |= VBAREQUAL ^= CIRCUMFLEXEQUAL <<= LEFTSHIFTEQUAL >>= RIGHTSHIFTEQUAL **= DOUBLESTAREQUAL // DOUBLESLASH //= DOUBLESLASHEQUAL -> RARROW )r.r7rÚrrÚobjectrrZ opmap_rawZopmapÚ splitlinesÚlineÚsplitÚopÚnamer%rrrrÚ sy=PKb31](âþŽŸŸ#__pycache__/__init__.cpython-36.pycnu„[µü¤3 \ã@sdZdS)zThe pgen2 package.N)Ú__doc__©rrú./usr/lib64/python3.6/lib2to3/pgen2/__init__.pyÚsPKb31]É[-!__pycache__/driver.cpython-36.pycnu„[µü¤3 \Œã@s´dZdZddgZddlZddlZddlZddlZddlZddlZddl m Z mZmZm Z mZGdd„deƒZd d „Zddd„Zdd„Zdd„Zdd„Zedkr°ejeeƒƒƒdS)zZParser driver. This provides a high-level interface to parse a file into a syntax tree. z#Guido van Rossum ÚDriverÚload_grammaréNé)ÚgrammarÚparseÚtokenÚtokenizeÚpgenc@sHeZdZddd„Zddd„Zddd„Zdd d „Zddd„Zdd d„ZdS)rNcCs&||_|dkrtjƒ}||_||_dS)N)rÚloggingÚ getLoggerÚloggerÚconvert)Úselfrr r©rú,/usr/lib64/python3.6/lib2to3/pgen2/driver.pyÚ__init__ s zDriver.__init__FcCs”tj|j|jƒ}|jƒd}d}d}}}} } d}xR|D]4}|\}}}} } |||fkrÀ||f|ks|t||f|fƒ‚|\} }|| kr¤|d| |7}| }d}||krÀ|| ||…7}|}|tjtjfkrø||7}| \}}|j dƒr@|d7}d}q@|t jkrtj|}|r,|j jdt j|||ƒ|j||||fƒrT|rR|j jdƒPd}| \}}|j dƒr@|d7}d}q@Wtjd||||fƒ‚|jS) z4Parse a series of tokens and return the syntax tree.rrNÚÚ z%s %r (prefix=%r)zStop.zincomplete input)rZParserrr ZsetupÚAssertionErrorrÚCOMMENTÚNLÚendswithrÚOPZopmaprÚdebugÚtok_nameZaddtokenZ ParseErrorZrootnode)rÚtokensrÚpÚlinenoÚcolumnÚtypeÚvalueÚstartÚendZ line_textÚprefixZ quintupleZs_linenoZs_columnrrrÚparse_tokens'sT zDriver.parse_tokenscCstj|jƒ}|j||ƒS)z*Parse a stream and return the syntax tree.)rÚgenerate_tokensÚreadliner$)rÚstreamrrrrrÚparse_stream_rawWszDriver.parse_stream_rawcCs|j||ƒS)z*Parse a stream and return the syntax tree.)r()rr'rrrrÚparse_stream\szDriver.parse_streamc Cs*tj|d|ƒ}z|j||ƒS|jƒXdS)z(Parse a file and return the syntax tree.ÚrN)ÚcodecsÚopenr)Úclose)rÚfilenameÚencodingrr'rrrÚ parse_file`szDriver.parse_filecCstjtj|ƒjƒ}|j||ƒS)z*Parse a string and return the syntax tree.)rr%ÚioÚStringIOr&r$)rÚtextrrrrrÚparse_stringhszDriver.parse_string)NN)F)F)F)NF)F) Ú__name__Ú __module__Ú__qualname__rr$r(r)r0r4rrrrrs 0 cCs:tjj|ƒ\}}|dkrd}||djtttjƒƒdS)Nz.txtrÚ.z.pickle)ÚosÚpathÚsplitextÚjoinÚmapÚstrÚsysÚversion_info)ÚgtÚheadÚtailrrrÚ_generate_pickle_namensrDúGrammar.txtTFcCs°|dkrtjƒ}|dkr t|ƒn|}|s4t||ƒrš|jd|ƒtj|ƒ}|r¬|jd|ƒy|j|ƒWq¬tk r–}z|jd|ƒWYdd}~Xq¬Xnt j ƒ}|j|ƒ|S)z'Load the grammar (maybe from a pickle).Nz!Generating grammar tables from %szWriting grammar tables to %szWriting failed: %s)r rrDÚ_newerÚinfor Zgenerate_grammarÚdumpÚOSErrorrÚGrammarÚload)rAZgpÚsaveÚforcerÚgÚerrrrus cCs8tjj|ƒsdStjj|ƒs dStjj|ƒtjj|ƒkS)z0Inquire whether file a was written since file b.FT)r9r:ÚexistsÚgetmtime)ÚaÚbrrrrFŠs rFcCsFtjj|ƒrt|ƒSttjj|ƒƒ}tj||ƒ}tj ƒ}|j |ƒ|S)aÙNormally, loads a pickled grammar by doing pkgutil.get_data(package, pickled_grammar) where *pickled_grammar* is computed from *grammar_source* by adding the Python version and using a ``.pickle`` extension. However, if *grammar_source* is an extant file, load_grammar(grammar_source) is called instead. This facilitates using a packaged grammar file when needed but preserves load_grammar's automatic regeneration behavior when possible. )r9r:ÚisfilerrDÚbasenameÚpkgutilÚget_datarrJÚloads)ÚpackageZgrammar_sourceZpickled_nameÚdatarNrrrÚload_packaged_grammar“s r[cGsF|stjdd…}tjtjtjddx|D]}t|dddq,WdS)zMain program, when run as a script: produce grammar pickle files. Calls load_grammar for each argument, a path to a grammar text file. rNz%(message)s)Úlevelr'ÚformatT)rLrM)r?Úargvr ZbasicConfigÚINFOÚstdoutr)ÚargsrArrrÚmain§s rbÚ__main__)rENTFN)Ú__doc__Ú __author__Ú__all__r+r1r9r rVr?rrrrrr ÚobjectrrDrrFr[rbr5ÚexitÚintrrrrÚs$P PKb31]ÕpŽ<<#__pycache__/tokenize.cpython-36.pycnu„[µü¤3 \NXã=@sŒdZdZdZddlZddlZddlmZmZddlTddl m Z d d „ee ƒDƒddd gZ[ ye Wnek r~eZ YnXdd„Zdd„Zdd„ZdZdZeedeƒeeƒZdZdZdZdZeddƒZeeeeeƒZdZeddƒeeƒZd eZeeeƒZed!ed"ƒZ ee eeƒZ!d#Z"d$Z#d%Z$d&Z%d'Z&ee&d(e&d)ƒZ'ee&d*e&d+ƒZ(ed,d-d.d/d0d1d2d3d4ƒ Z)d5Z*ed6d7ƒZ+ee)e*e+ƒZ,ee!e,e(eƒZ-ee-Z.ee&d8ed9dƒe&d:ed;dƒƒZ/edee'ƒZ0eee0e!e,e/eƒZ1e2e3ej4e.e1e$e%fƒƒ\Z5Z6Z7Z8ej4e"ƒej4e#ƒe7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8e7e8ddddddddd<œ4Z9iZ:xd¢D]Z;e;e:e;<qŒWiZƒZ?Gdd‘„d‘e>ƒZ@d’d“„ZAeAfd”d„ZBd•d–„ZCGd—d˜„d˜ƒZDej4d™ejEƒZFej4dšejEƒZGd›dœ„ZHddž„ZIdŸd „ZJd d„ZKeLd¡krˆddlMZMeNeMjOƒdkr|eBePeMjOdƒjQƒneBeMjRjQƒdS)¤aÀTokenization help for Python programs. generate_tokens(readline) is a generator that breaks a stream of text into Python tokens. It accepts a readline-like method which is called repeatedly to get the next line of input (or "" for EOF). It generates 5-tuples with these members: the token type (see token.py) the token (a string) the starting (row, column) indices of the token (a 2-tuple of ints) the ending (row, column) indices of the token (a 2-tuple of ints) the original line (string) It is designed to match the working of the Python tokenizer exactly, except that it produces COMMENT tokens for comments and gives type OP for all operators Older entry points tokenize_loop(readline, tokeneater) tokenize(readline, tokeneater=printtoken) are the same, except instead of generating tokens, tokeneater is a callback function to which the 5 fields described above are passed as 5 arguments, each time a new token is found.zKa-Ping Yee z@GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, Skip MontanaroéN)ÚBOM_UTF8Úlookup)Ú*é)ÚtokencCsg|]}|ddkr|‘qS)rÚ_©)Ú.0Úxrrú./usr/lib64/python3.6/lib2to3/pgen2/tokenize.pyú %srÚtokenizeÚgenerate_tokensÚ untokenizecGsddj|ƒdS)Nú(ú|ú))Újoin)ÚchoicesrrrÚgroup0srcGst|ŽdS)Nr)r)rrrrÚany1srcGst|ŽdS)Nú?)r)rrrrÚmaybe2srz[ \f\t]*z #[^\r\n]*z\\\r?\nz[a-zA-Z_]\w*z0[bB]_?[01]+(?:_[01]+)*z(0[xX]_?[\da-fA-F]+(?:_[\da-fA-F]+)*[lL]?z0[oO]?_?[0-7]+(?:_[0-7]+)*[lL]?z[1-9]\d*(?:_\d+)*[lL]?z0[lL]?z[eE][-+]?\d+(?:_\d+)*z\d+(?:_\d+)*\.(?:\d+(?:_\d+)*)?z\.\d+(?:_\d+)*z\d+(?:_\d+)*z\d+(?:_\d+)*[jJ]z[jJ]z[^'\\]*(?:\\.[^'\\]*)*'z[^"\\]*(?:\\.[^"\\]*)*"z%[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''z%[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""z#(?:[uUrRbBfF]|[rR][bB]|[bBuU][rR])?ú'''ú"""z'[^\n'\\]*(?:\\.[^\n'\\]*)*'z"[^\n"\\]*(?:\\.[^\n"\\]*)*"z\*\*=?z>>=?z<<=?z<>z!=z//=?z->z[+\-*/%&@|^=<>]=?ú~z[][(){}]z\r?\nz[:;.,`@]z'[^\n'\\]*(?:\\.[^\n'\\]*)*ú'z"[^\n"\\]*(?:\\.[^\n"\\]*)*ú")4rrz'''z"""zr'''zr"""zu'''zu"""zb'''zb"""zf'''zf"""zur'''zur"""zbr'''zbr"""zrb'''zrb"""zR'''zR"""zU'''zU"""zB'''zB"""zF'''zF"""zuR'''zuR"""zUr'''zUr"""zUR'''zUR"""zbR'''zbR"""zBr'''zBr"""zBR'''zBR"""zrB'''zrB"""zRb'''zRb"""zRB'''zRB"""ÚrÚRÚuÚUÚfÚFÚbÚBúr'''úr"""úR'''úR"""úu'''úu"""úU'''úU"""úb'''úb"""úB'''úB"""úf'''úf"""úF'''úF"""úur'''úur"""úUr'''úUr"""úuR'''úuR"""úUR'''úUR"""úbr'''úbr"""úBr'''úBr"""úbR'''úbR"""úBR'''úBR"""úrb'''úrb"""úRb'''úRb"""úrB'''úrB"""úRB'''úRB"""úr'úr"úR'úR"úu'úu"úU'úU"úb'úb"úB'úB"úf'úf"úF'úF"úur'úur"úUr'úUr"úuR'úuR"úUR'úUR"úbr'úbr"úBr'úBr"úbR'úbR"úBR'úBR"úrb'úrb"úRb'úRb"úrB'úrB"úRB'úRB"éc@seZdZdS)Ú TokenErrorN)Ú__name__Ú __module__Ú__qualname__rrrrrw¤srwc@seZdZdS)ÚStopTokenizingN)rxryrzrrrrr{¦sr{c Cs4|\}}|\}}td||||t|t|ƒfƒdS)Nz%d,%d-%d,%d: %s %s)ÚprintÚtok_nameÚrepr) ÚtyperZxxx_todo_changemeZxxx_todo_changeme1ÚlineZsrowZscolZerowZecolrrrÚ printtoken¨srcCs(yt||ƒWntk r"YnXdS)a: The tokenize() function accepts two parameters: one representing the input stream, and one providing an output mechanism for tokenize(). The first parameter, readline, must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. The second parameter, tokeneater, must also be a callable object. It is called once for each token, with five arguments, corresponding to the tuples generated by generate_tokens(). N)Ú tokenize_loopr{)ÚreadlineÚ tokeneaterrrrr ®s cCsxt|ƒD]}||Žq WdS)N)r)rƒr„Z token_inforrrr‚Ásr‚c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚUntokenizercCsg|_d|_d|_dS)Nrr)ÚtokensÚprev_rowÚprev_col)ÚselfrrrÚ__init__ÇszUntokenizer.__init__cCs8|\}}||jkst‚||j}|r4|jjd|ƒdS)Nú )r‡ÚAssertionErrorrˆr†Úappend)r‰ÚstartÚrowÚcolÚ col_offsetrrrÚadd_whitespaceÌs zUntokenizer.add_whitespacecCs„xv|D]n}t|ƒdkr$|j||ƒP|\}}}}}|j|ƒ|jj|ƒ|\|_|_|ttfkr|jd7_d|_qWdj |jƒS)NérrÚ) ÚlenÚcompatr’r†rr‡rˆÚNEWLINEÚNLr)r‰ÚiterableÚtÚtok_typerrŽÚendr€rrrrÓs zUntokenizer.untokenizec CsÒd}g}|jj}|\}}|ttfkr,|d7}|ttfkr|t kr˜|j ƒqBn*|ttfkrªd}n|rÂ|rÂ||dƒd}||ƒqBWdS)NFr‹Tr“réÿÿÿÿ)r†rÚNAMEÚNUMBERr—r˜ÚASYNCÚAWAITÚINDENTÚDEDENTÚpop) r‰rr™Ú startlineÚindentsÚtoks_appendÚtoknumÚtokvalÚtokrrrr–ás0 zUntokenizer.compatN)rxryrzrŠr’rr–rrrrr…Åsr…z&^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)s^[ \t\f]*(?:[#\r\n]|$)cCsH|dd…jƒjddƒ}|dks*|jdƒr.dS|d ks@|jdƒrDdS|S)z(Imitates get_normal_name in tokenizer.c.Nérú-zutf-8zutf-8-úlatin-1ú iso-8859-1úiso-latin-1úlatin-1-úiso-8859-1-úiso-latin-1-)rr®r¯)r°r±r²)ÚlowerÚreplaceÚ startswith)Úorig_encÚencrrrÚ_get_normal_names r¸cs¶d‰d}d}‡fdd„}‡fdd„}|ƒ}|jtƒrHd‰|d d…}d }|sT|gfS||ƒ}|rj||gfStj|ƒs~||gfS|ƒ}|s’||gfS||ƒ}|rª|||gfS|||gfS)a The detect_encoding() function is used to detect the encoding that should be used to decode a Python source file. It requires one argument, readline, in the same way as the tokenize() generator. It will call readline a maximum of twice, and return the encoding used (as a string) and a list of any lines (left as bytes) it has read in. It detects the encoding from the presence of a utf-8 bom or an encoding cookie as specified in pep-0263. If both a bom and a cookie are present, but disagree, a SyntaxError will be raised. If the encoding cookie is an invalid charset, raise a SyntaxError. Note that if a utf-8 bom is found, 'utf-8-sig' is returned. If no encoding is specified, then the default of 'utf-8' will be returned. FNzutf-8cs"yˆƒStk rtƒSXdS)N)Ú StopIterationÚbytesr)rƒrrÚread_or_stop sz%detect_encoding..read_or_stopcs”y|jdƒ}Wntk r"dSXtj|ƒ}|s6dSt|jdƒƒ}yt|ƒ}Wn tk rptd|ƒ‚YnXˆr|j dkrˆtdƒ‚|d7}|S)NÚasciirzunknown encoding: zutf-8zencoding problem: utf-8z-sig) ÚdecodeÚUnicodeDecodeErrorÚ cookie_reÚmatchr¸rrÚLookupErrorÚSyntaxErrorÚname)r€Úline_stringrÀÚencodingÚcodec)Ú bom_foundrrÚfind_cookie&s" z$detect_encoding..find_cookieTéz utf-8-sig)rµrÚblank_rerÀ)rƒrÅÚdefaultr»rÈÚfirstÚsecondr)rÇrƒrÚdetect_encodings0 rÎcCstƒ}|j|ƒS)a¬Transform tokens back into Python source code. Each element returned by the iterable must be a token sequence with at least two elements, a token number and token value. If only two tokens are passed, the resulting output is poor. Round-trip invariant for full input: Untokenized source will match input source exactly Round-trip invariant for limited intput: # Output text will tokenize the back to the input t1 = [tok[:2] for tok in generate_tokens(f.readline)] newcode = untokenize(t1) readline = iter(newcode.splitlines(1)).next t2 = [tok[:2] for tokin generate_tokens(readline)] assert t1 == t2 )r…r)r™ÚutrrrrTsc!cs¬d}}}tjdd}}d \}}d}dg} d} d}d}d} xy |ƒ}Wntk rdd}YnX|d}dt|ƒ}}|rF|std|ƒ‚|j|ƒ}|rÞ|jdƒ}}t||d|…|||f||fVd!\}}d}nd|r0|d"d…d kr0|d#d…dkr0t||||t|ƒf|fVd}d}qBn||}||}qBnF|dkrt|rt|s`Pd}xf||krÊ||d krˆ|d}n6||dkr¨|t dt }n||dkr¼d}nP|d}qfW||krØP| rè| Vd} ||dkrž||dkrh||d…j dƒ}|t|ƒ}t|||f||t|ƒf|fVt||d…||f|t|ƒf|fVqBttf||dk||d…||f|t|ƒf|fVqB|| d$krÖ| j |ƒt|d|…|df||f|fVxt|| d%krJ|| krtdd|||fƒ‚| dd&…} |r.|| d'kr.d}d} d}td||f||f|fVqØW|rŒ| rŒ|| d(krŒd}d} d}n|sˆtd|dfƒ‚d}x¼||krJtj||ƒ}|r|jdƒ\}}||f||f|}}}|||…||}}||ks|dkr|dkrt||||fVqF|dkrft}|dkr8t}n |rBd} | rR| Vd} |||||fVqF|dkr¦|jdƒs‚t‚| r’| Vd} t||||fVqF|tkr$t|}|j||ƒ}|r|jdƒ}|||…}| rð| Vd} t||||f|fVn||f}||d…}|}PqF|tksR|dd …tksR|dd…tkrÊ|d)dkr¦||f}t|pŠt|dpŠt|d }||d…d}}|}Pn | r¶| Vd} t||||fVqF||kr¢|d*kr|r|dkròtnt||||fVqt||||f}|dkr.| r.|} q|dkrŠ| rŠ| dtkrŠ| ddkrŠd}| d+}t| d| d | d| dfVd} | rš| Vd} |Vnz|dkrÖ| r¼| Vd} t||||f|fVd}nF|dkrê|d}n|dkrü|d}| r| Vd} t||||fVn(t||||f||df|fV|d}qWqBW| r`| Vd} x.| dd…D]} td|df|dfdfVqnWtd|df|dfdfVdS),aT The generate_tokens() generator requires one argument, readline, which must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. Alternately, readline can be a callable function terminating with StopIteration: readline = open(myfile).next # Example of alternate readline The generator produces 5-tuples with these members: the token type; the token string; a 2-tuple (srow, scol) of ints specifying the row and column where the token begins in the source; a 2-tuple (erow, ecol) of ints specifying the row and column where the token ends in the source; and the line on which the token was found. The line passed is the logical line; continuation lines are included. rrÚ 0123456789r”NFrzEOF in multi-line stringr“z\ rÉz\ r‹ú úz# ú#z z3unindent does not match any outer indentation levelz zEOF in multi-line statementÚ.TÚ ÚasyncÚawaitÚdeféú\z([{z)]})r”r)r”réþÿÿÿéýÿÿÿrrrrrr)rÖr×r)ÚstringZ ascii_lettersr¹r•rwrÀrœÚSTRINGÚ ERRORTOKENÚtabsizeÚrstripÚCOMMENTr˜rr¢ÚIndentationErrorr£Ú pseudoprogÚspanrŸr—ÚendswithrŒÚ triple_quotedÚendprogsÚ single_quotedr r¡ržÚOPÚ ENDMARKER)!rƒÚlnumÚparenlevÚ continuedZ namecharsÚnumcharsÚcontstrÚneedcontÚcontliner¦ÚstashedÚ async_defÚasync_def_indentÚasync_def_nlr€ÚposÚmaxÚstrstartÚendprogÚendmatchrœÚcolumnÚ comment_tokenÚnl_posÚpseudomatchrŽÚsposÚeposrÚinitialÚnewlinerªÚindentrrrrisr * Ú__main__)*rrr&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrM)*rrrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtru)SÚ__doc__Ú __author__Ú__credits__rÝÚreÚcodecsrrZlib2to3.pgen2.tokenr”rÚdirÚ__all__rºÚ NameErrorÚstrrrrÚ WhitespaceÚCommentÚIgnoreÚNameÚ BinnumberÚ HexnumberÚ OctnumberÚ DecnumberÚ IntnumberÚExponentÚ PointfloatÚExpfloatÚFloatnumberÚ ImagnumberÚNumberÚSingleÚDoubleÚSingle3ÚDouble3Z _litprefixÚTripleÚStringÚOperatorÚBracketÚSpecialÚFunnyÚ PlainTokenÚTokenÚContStrÚPseudoExtrasÚPseudoTokenÚlistÚmapÚcompileZ tokenprogräZsingle3progZdouble3progrèrçršréràÚ Exceptionrwr{rr r‚r…ÚASCIIr¿rÊr¸rÎrrrxÚsysr•ÚargvÚopenrƒÚstdinrrrrÚsþ 8Ic PKb31]sWP›uuparse.pynu„[µü¤# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. # Licensed to PSF under a Contributor Agreement. """Parser engine for the grammar tables generated by pgen. The grammar table must be loaded first. See Parser/parser.c in the Python distribution for additional info on how this parsing engine works. """ # Local imports from . import token class ParseError(Exception): """Exception to signal the parser is stuck.""" def __init__(self, msg, type, value, context): Exception.__init__(self, "%s: type=%r, value=%r, context=%r" % (msg, type, value, context)) self.msg = msg self.type = type self.value = value self.context = context class Parser(object): """Parser engine. The proper usage sequence is: p = Parser(grammar, [converter]) # create instance p.setup([start]) # prepare for parsing : if p.addtoken(...): # parse a token; may raise ParseError break root = p.rootnode # root of abstract syntax tree A Parser instance may be reused by calling setup() repeatedly. A Parser instance contains state pertaining to the current token sequence, and should not be used concurrently by different threads to parse separate token sequences. See driver.py for how to get input tokens by tokenizing a file or string. Parsing is complete when addtoken() returns True; the root of the abstract syntax tree can then be retrieved from the rootnode instance variable. When a syntax error occurs, addtoken() raises the ParseError exception. There is no error recovery; the parser cannot be used after a syntax error was reported (but it can be reinitialized by calling setup()). """ def __init__(self, grammar, convert=None): """Constructor. The grammar argument is a grammar.Grammar instance; see the grammar module for more information. The parser is not ready yet for parsing; you must call the setup() method to get it started. The optional convert argument is a function mapping concrete syntax tree nodes to abstract syntax tree nodes. If not given, no conversion is done and the syntax tree produced is the concrete syntax tree. If given, it must be a function of two arguments, the first being the grammar (a grammar.Grammar instance), and the second being the concrete syntax tree node to be converted. The syntax tree is converted from the bottom up. A concrete syntax tree node is a (type, value, context, nodes) tuple, where type is the node type (a token or symbol number), value is None for symbols and a string for tokens, context is None or an opaque value used for error reporting (typically a (lineno, offset) pair), and nodes is a list of children for symbols, and None for tokens. An abstract syntax tree node may be anything; this is entirely up to the converter function. """ self.grammar = grammar self.convert = convert or (lambda grammar, node: node) def setup(self, start=None): """Prepare for parsing. This *must* be called before starting to parse. The optional argument is an alternative start symbol; it defaults to the grammar's start symbol. You can use a Parser instance to parse any number of programs; each time you call setup() the parser is reset to an initial state determined by the (implicit or explicit) start symbol. """ if start is None: start = self.grammar.start # Each stack entry is a tuple: (dfa, state, node). # A node is a tuple: (type, value, context, children), # where children is a list of nodes or None, and context may be None. newnode = (start, None, None, []) stackentry = (self.grammar.dfas[start], 0, newnode) self.stack = [stackentry] self.rootnode = None self.used_names = set() # Aliased to self.rootnode.used_names in pop() def addtoken(self, type, value, context): """Add a token; return True iff this is the end of the program.""" # Map from token to label ilabel = self.classify(type, value, context) # Loop until the token is shifted; may raise exceptions while True: dfa, state, node = self.stack[-1] states, first = dfa arcs = states[state] # Look for a state with this label for i, newstate in arcs: t, v = self.grammar.labels[i] if ilabel == i: # Look it up in the list of labels assert t < 256 # Shift a token; we're done with it self.shift(type, value, newstate, context) # Pop while we are in an accept-only state state = newstate while states[state] == [(0, state)]: self.pop() if not self.stack: # Done parsing! return True dfa, state, node = self.stack[-1] states, first = dfa # Done with this token return False elif t >= 256: # See if it's a symbol and if we're in its first set itsdfa = self.grammar.dfas[t] itsstates, itsfirst = itsdfa if ilabel in itsfirst: # Push a symbol self.push(t, self.grammar.dfas[t], newstate, context) break # To continue the outer while loop else: if (0, state) in arcs: # An accepting state, pop it and try something else self.pop() if not self.stack: # Done parsing, but another token is input raise ParseError("too much input", type, value, context) else: # No success finding a transition raise ParseError("bad input", type, value, context) def classify(self, type, value, context): """Turn a token into a label. (Internal)""" if type == token.NAME: # Keep a listing of all used names self.used_names.add(value) # Check for reserved words ilabel = self.grammar.keywords.get(value) if ilabel is not None: return ilabel ilabel = self.grammar.tokens.get(type) if ilabel is None: raise ParseError("bad token", type, value, context) return ilabel def shift(self, type, value, newstate, context): """Shift a token. (Internal)""" dfa, state, node = self.stack[-1] newnode = (type, value, context, None) newnode = self.convert(self.grammar, newnode) if newnode is not None: node[-1].append(newnode) self.stack[-1] = (dfa, newstate, node) def push(self, type, newdfa, newstate, context): """Push a nonterminal. (Internal)""" dfa, state, node = self.stack[-1] newnode = (type, None, context, []) self.stack[-1] = (dfa, newstate, node) self.stack.append((newdfa, 0, newnode)) def pop(self): """Pop a nonterminal. (Internal)""" popdfa, popstate, popnode = self.stack.pop() newnode = self.convert(self.grammar, popnode) if newnode is not None: if self.stack: dfa, state, node = self.stack[-1] node[-1].append(newnode) else: self.rootnode = newnode self.rootnode.used_names = self.used_names PKb31]’˜œ"ÂÂ grammar.pynu„[µü¤# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. # Licensed to PSF under a Contributor Agreement. """This module defines the data structures used to represent a grammar. These are a bit arcane because they are derived from the data structures used by Python's 'pgen' parser generator. There's also a table here mapping operators to their names in the token module; the Python tokenize module reports all operators as the fallback token code OP, but the parser needs the actual token code. """ # Python imports import collections import pickle # Local imports from . import token, tokenize class Grammar(object): """Pgen parsing tables conversion class. Once initialized, this class supplies the grammar tables for the parsing engine implemented by parse.py. The parsing engine accesses the instance variables directly. The class here does not provide initialization of the tables; several subclasses exist to do this (see the conv and pgen modules). The load() method reads the tables from a pickle file, which is much faster than the other ways offered by subclasses. The pickle file is written by calling dump() (after loading the grammar tables using a subclass). The report() method prints a readable representation of the tables to stdout, for debugging. The instance variables are as follows: symbol2number -- a dict mapping symbol names to numbers. Symbol numbers are always 256 or higher, to distinguish them from token numbers, which are between 0 and 255 (inclusive). number2symbol -- a dict mapping numbers to symbol names; these two are each other's inverse. states -- a list of DFAs, where each DFA is a list of states, each state is a list of arcs, and each arc is a (i, j) pair where i is a label and j is a state number. The DFA number is the index into this list. (This name is slightly confusing.) Final states are represented by a special arc of the form (0, j) where j is its own state number. dfas -- a dict mapping symbol numbers to (DFA, first) pairs, where DFA is an item from the states list above, and first is a set of tokens that can begin this grammar rule (represented by a dict whose values are always 1). labels -- a list of (x, y) pairs where x is either a token number or a symbol number, and y is either None or a string; the strings are keywords. The label number is the index in this list; label numbers are used to mark state transitions (arcs) in the DFAs. start -- the number of the grammar's start symbol. keywords -- a dict mapping keyword strings to arc labels. tokens -- a dict mapping token numbers to arc labels. """ def __init__(self): self.symbol2number = {} self.number2symbol = {} self.states = [] self.dfas = {} self.labels = [(0, "EMPTY")] self.keywords = {} self.tokens = {} self.symbol2label = {} self.start = 256 def dump(self, filename): """Dump the grammar tables to a pickle file. dump() recursively changes all dict to OrderedDict, so the pickled file is not exactly the same as what was passed in to dump(). load() uses the pickled file to create the tables, but only changes OrderedDict to dict at the top level; it does not recursively change OrderedDict to dict. So, the loaded tables are different from the original tables that were passed to load() in that some of the OrderedDict (from the pickled file) are not changed back to dict. For parsing, this has no effect on performance because OrderedDict uses dict's __getitem__ with nothing in between. """ with open(filename, "wb") as f: d = _make_deterministic(self.__dict__) pickle.dump(d, f, 2) def load(self, filename): """Load the grammar tables from a pickle file.""" f = open(filename, "rb") d = pickle.load(f) f.close() self.__dict__.update(d) def loads(self, pkl): """Load the grammar tables from a pickle bytes object.""" self.__dict__.update(pickle.loads(pkl)) def copy(self): """ Copy the grammar. """ new = self.__class__() for dict_attr in ("symbol2number", "number2symbol", "dfas", "keywords", "tokens", "symbol2label"): setattr(new, dict_attr, getattr(self, dict_attr).copy()) new.labels = self.labels[:] new.states = self.states[:] new.start = self.start return new def report(self): """Dump the grammar tables to standard output, for debugging.""" from pprint import pprint print "s2n" pprint(self.symbol2number) print "n2s" pprint(self.number2symbol) print "states" pprint(self.states) print "dfas" pprint(self.dfas) print "labels" pprint(self.labels) print "start", self.start def _make_deterministic(top): if isinstance(top, dict): return collections.OrderedDict( sorted(((k, _make_deterministic(v)) for k, v in top.iteritems()))) if isinstance(top, list): return [_make_deterministic(e) for e in top] if isinstance(top, tuple): return tuple(_make_deterministic(e) for e in top) return top # Map from operator to number (since tokenize doesn't do this) opmap_raw = """ ( LPAR ) RPAR [ LSQB ] RSQB : COLON , COMMA ; SEMI + PLUS - MINUS * STAR / SLASH | VBAR & AMPER < LESS > GREATER = EQUAL . DOT % PERCENT ` BACKQUOTE { LBRACE } RBRACE @ AT @= ATEQUAL == EQEQUAL != NOTEQUAL <> NOTEQUAL <= LESSEQUAL >= GREATEREQUAL ~ TILDE ^ CIRCUMFLEX << LEFTSHIFT >> RIGHTSHIFT ** DOUBLESTAR += PLUSEQUAL -= MINEQUAL *= STAREQUAL /= SLASHEQUAL %= PERCENTEQUAL &= AMPEREQUAL |= VBAREQUAL ^= CIRCUMFLEXEQUAL <<= LEFTSHIFTEQUAL >>= RIGHTSHIFTEQUAL **= DOUBLESTAREQUAL // DOUBLESLASH //= DOUBLESLASHEQUAL -> RARROW """ opmap = {} for line in opmap_raw.splitlines(): if line: op, name = line.split() opmap[op] = getattr(token, name) PKb31]ý—Š›%›%conv.pynu„[µü¤# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. # Licensed to PSF under a Contributor Agreement. """Convert graminit.[ch] spit out by pgen to Python code. Pgen is the Python parser generator. It is useful to quickly create a parser from a grammar file in Python's grammar notation. But I don't want my parsers to be written in C (yet), so I'm translating the parsing tables to Python data structures and writing a Python parse engine. Note that the token numbers are constants determined by the standard Python tokenizer. The standard token module defines these numbers and their names (the names are not used much). The token numbers are hardcoded into the Python tokenizer and into pgen. A Python implementation of the Python tokenizer is also available, in the standard tokenize module. On the other hand, symbol numbers (representing the grammar's non-terminals) are assigned by pgen based on the actual grammar input. Note: this module is pretty much obsolete; the pgen module generates equivalent grammar tables directly from the Grammar.txt input file without having to invoke the Python pgen C program. """ # Python imports import re # Local imports from pgen2 import grammar, token class Converter(grammar.Grammar): """Grammar subclass that reads classic pgen output files. The run() method reads the tables as produced by the pgen parser generator, typically contained in two C files, graminit.h and graminit.c. The other methods are for internal use only. See the base class for more documentation. """ def run(self, graminit_h, graminit_c): """Load the grammar tables from the text files written by pgen.""" self.parse_graminit_h(graminit_h) self.parse_graminit_c(graminit_c) self.finish_off() def parse_graminit_h(self, filename): """Parse the .h file written by pgen. (Internal) This file is a sequence of #define statements defining the nonterminals of the grammar as numbers. We build two tables mapping the numbers to names and back. """ try: f = open(filename) except IOError, err: print "Can't open %s: %s" % (filename, err) return False self.symbol2number = {} self.number2symbol = {} lineno = 0 for line in f: lineno += 1 mo = re.match(r"^#define\s+(\w+)\s+(\d+)$", line) if not mo and line.strip(): print "%s(%s): can't parse %s" % (filename, lineno, line.strip()) else: symbol, number = mo.groups() number = int(number) assert symbol not in self.symbol2number assert number not in self.number2symbol self.symbol2number[symbol] = number self.number2symbol[number] = symbol return True def parse_graminit_c(self, filename): """Parse the .c file written by pgen. (Internal) The file looks as follows. The first two lines are always this: #include "pgenheaders.h" #include "grammar.h" After that come four blocks: 1) one or more state definitions 2) a table defining dfas 3) a table defining labels 4) a struct defining the grammar A state definition has the following form: - one or more arc arrays, each of the form: static arc arcs__[] = { {, }, ... }; - followed by a state array, of the form: static state states_[] = { {, arcs__}, ... }; """ try: f = open(filename) except IOError, err: print "Can't open %s: %s" % (filename, err) return False # The code below essentially uses f's iterator-ness! lineno = 0 # Expect the two #include lines lineno, line = lineno+1, f.next() assert line == '#include "pgenheaders.h"\n', (lineno, line) lineno, line = lineno+1, f.next() assert line == '#include "grammar.h"\n', (lineno, line) # Parse the state definitions lineno, line = lineno+1, f.next() allarcs = {} states = [] while line.startswith("static arc "): while line.startswith("static arc "): mo = re.match(r"static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$", line) assert mo, (lineno, line) n, m, k = map(int, mo.groups()) arcs = [] for _ in range(k): lineno, line = lineno+1, f.next() mo = re.match(r"\s+{(\d+), (\d+)},$", line) assert mo, (lineno, line) i, j = map(int, mo.groups()) arcs.append((i, j)) lineno, line = lineno+1, f.next() assert line == "};\n", (lineno, line) allarcs[(n, m)] = arcs lineno, line = lineno+1, f.next() mo = re.match(r"static state states_(\d+)\[(\d+)\] = {$", line) assert mo, (lineno, line) s, t = map(int, mo.groups()) assert s == len(states), (lineno, line) state = [] for _ in range(t): lineno, line = lineno+1, f.next() mo = re.match(r"\s+{(\d+), arcs_(\d+)_(\d+)},$", line) assert mo, (lineno, line) k, n, m = map(int, mo.groups()) arcs = allarcs[n, m] assert k == len(arcs), (lineno, line) state.append(arcs) states.append(state) lineno, line = lineno+1, f.next() assert line == "};\n", (lineno, line) lineno, line = lineno+1, f.next() self.states = states # Parse the dfas dfas = {} mo = re.match(r"static dfa dfas\[(\d+)\] = {$", line) assert mo, (lineno, line) ndfas = int(mo.group(1)) for i in range(ndfas): lineno, line = lineno+1, f.next() mo = re.match(r'\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$', line) assert mo, (lineno, line) symbol = mo.group(2) number, x, y, z = map(int, mo.group(1, 3, 4, 5)) assert self.symbol2number[symbol] == number, (lineno, line) assert self.number2symbol[number] == symbol, (lineno, line) assert x == 0, (lineno, line) state = states[z] assert y == len(state), (lineno, line) lineno, line = lineno+1, f.next() mo = re.match(r'\s+("(?:\\\d\d\d)*")},$', line) assert mo, (lineno, line) first = {} rawbitset = eval(mo.group(1)) for i, c in enumerate(rawbitset): byte = ord(c) for j in range(8): if byte & (1<>=?", r"<<=?", r"<>", r"!=", r"//=?", r"->", r"[+\-*/%&@|^=<>]=?", r"~") Bracket = '[][(){}]' Special = group(r'\r?\n', r'[:;.,`@]') Funny = group(Operator, Bracket, Special) PlainToken = group(Number, Funny, String, Name) Token = Ignore + PlainToken # First (or only) line of ' or " string. ContStr = group(r"[uUbB]?[rR]?'[^\n'\\]*(?:\\.[^\n'\\]*)*" + group("'", r'\\\r?\n'), r'[uUbB]?[rR]?"[^\n"\\]*(?:\\.[^\n"\\]*)*' + group('"', r'\\\r?\n')) PseudoExtras = group(r'\\\r?\n', Comment, Triple) PseudoToken = Whitespace + group(PseudoExtras, Number, Funny, ContStr, Name) tokenprog, pseudoprog, single3prog, double3prog = map( re.compile, (Token, PseudoToken, Single3, Double3)) endprogs = {"'": re.compile(Single), '"': re.compile(Double), "'''": single3prog, '"""': double3prog, "r'''": single3prog, 'r"""': double3prog, "u'''": single3prog, 'u"""': double3prog, "b'''": single3prog, 'b"""': double3prog, "ur'''": single3prog, 'ur"""': double3prog, "br'''": single3prog, 'br"""': double3prog, "R'''": single3prog, 'R"""': double3prog, "U'''": single3prog, 'U"""': double3prog, "B'''": single3prog, 'B"""': double3prog, "uR'''": single3prog, 'uR"""': double3prog, "Ur'''": single3prog, 'Ur"""': double3prog, "UR'''": single3prog, 'UR"""': double3prog, "bR'''": single3prog, 'bR"""': double3prog, "Br'''": single3prog, 'Br"""': double3prog, "BR'''": single3prog, 'BR"""': double3prog, 'r': None, 'R': None, 'u': None, 'U': None, 'b': None, 'B': None} triple_quoted = {} for t in ("'''", '"""', "r'''", 'r"""', "R'''", 'R"""', "u'''", 'u"""', "U'''", 'U"""', "b'''", 'b"""', "B'''", 'B"""', "ur'''", 'ur"""', "Ur'''", 'Ur"""', "uR'''", 'uR"""', "UR'''", 'UR"""', "br'''", 'br"""', "Br'''", 'Br"""', "bR'''", 'bR"""', "BR'''", 'BR"""',): triple_quoted[t] = t single_quoted = {} for t in ("'", '"', "r'", 'r"', "R'", 'R"', "u'", 'u"', "U'", 'U"', "b'", 'b"', "B'", 'B"', "ur'", 'ur"', "Ur'", 'Ur"', "uR'", 'uR"', "UR'", 'UR"', "br'", 'br"', "Br'", 'Br"', "bR'", 'bR"', "BR'", 'BR"', ): single_quoted[t] = t tabsize = 8 class TokenError(Exception): pass class StopTokenizing(Exception): pass def printtoken(type, token, start, end, line): # for testing (srow, scol) = start (erow, ecol) = end print "%d,%d-%d,%d:\t%s\t%s" % \ (srow, scol, erow, ecol, tok_name[type], repr(token)) def tokenize(readline, tokeneater=printtoken): """ The tokenize() function accepts two parameters: one representing the input stream, and one providing an output mechanism for tokenize(). The first parameter, readline, must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. The second parameter, tokeneater, must also be a callable object. It is called once for each token, with five arguments, corresponding to the tuples generated by generate_tokens(). """ try: tokenize_loop(readline, tokeneater) except StopTokenizing: pass # backwards compatible interface def tokenize_loop(readline, tokeneater): for token_info in generate_tokens(readline): tokeneater(*token_info) class Untokenizer: def __init__(self): self.tokens = [] self.prev_row = 1 self.prev_col = 0 def add_whitespace(self, start): row, col = start assert row <= self.prev_row col_offset = col - self.prev_col if col_offset: self.tokens.append(" " * col_offset) def untokenize(self, iterable): for t in iterable: if len(t) == 2: self.compat(t, iterable) break tok_type, token, start, end, line = t self.add_whitespace(start) self.tokens.append(token) self.prev_row, self.prev_col = end if tok_type in (NEWLINE, NL): self.prev_row += 1 self.prev_col = 0 return "".join(self.tokens) def compat(self, token, iterable): startline = False indents = [] toks_append = self.tokens.append toknum, tokval = token if toknum in (NAME, NUMBER): tokval += ' ' if toknum in (NEWLINE, NL): startline = True for tok in iterable: toknum, tokval = tok[:2] if toknum in (NAME, NUMBER): tokval += ' ' if toknum == INDENT: indents.append(tokval) continue elif toknum == DEDENT: indents.pop() continue elif toknum in (NEWLINE, NL): startline = True elif startline and indents: toks_append(indents[-1]) startline = False toks_append(tokval) cookie_re = re.compile(r'^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)') blank_re = re.compile(r'^[ \t\f]*(?:[#\r\n]|$)') def _get_normal_name(orig_enc): """Imitates get_normal_name in tokenizer.c.""" # Only care about the first 12 characters. enc = orig_enc[:12].lower().replace("_", "-") if enc == "utf-8" or enc.startswith("utf-8-"): return "utf-8" if enc in ("latin-1", "iso-8859-1", "iso-latin-1") or \ enc.startswith(("latin-1-", "iso-8859-1-", "iso-latin-1-")): return "iso-8859-1" return orig_enc def detect_encoding(readline): """ The detect_encoding() function is used to detect the encoding that should be used to decode a Python source file. It requires one argument, readline, in the same way as the tokenize() generator. It will call readline a maximum of twice, and return the encoding used (as a string) and a list of any lines (left as bytes) it has read in. It detects the encoding from the presence of a utf-8 bom or an encoding cookie as specified in pep-0263. If both a bom and a cookie are present, but disagree, a SyntaxError will be raised. If the encoding cookie is an invalid charset, raise a SyntaxError. Note that if a utf-8 bom is found, 'utf-8-sig' is returned. If no encoding is specified, then the default of 'utf-8' will be returned. """ bom_found = False encoding = None default = 'utf-8' def read_or_stop(): try: return readline() except StopIteration: return bytes() def find_cookie(line): try: line_string = line.decode('ascii') except UnicodeDecodeError: return None match = cookie_re.match(line_string) if not match: return None encoding = _get_normal_name(match.group(1)) try: codec = lookup(encoding) except LookupError: # This behaviour mimics the Python interpreter raise SyntaxError("unknown encoding: " + encoding) if bom_found: if codec.name != 'utf-8': # This behaviour mimics the Python interpreter raise SyntaxError('encoding problem: utf-8') encoding += '-sig' return encoding first = read_or_stop() if first.startswith(BOM_UTF8): bom_found = True first = first[3:] default = 'utf-8-sig' if not first: return default, [] encoding = find_cookie(first) if encoding: return encoding, [first] if not blank_re.match(first): return default, [first] second = read_or_stop() if not second: return default, [first] encoding = find_cookie(second) if encoding: return encoding, [first, second] return default, [first, second] def untokenize(iterable): """Transform tokens back into Python source code. Each element returned by the iterable must be a token sequence with at least two elements, a token number and token value. If only two tokens are passed, the resulting output is poor. Round-trip invariant for full input: Untokenized source will match input source exactly Round-trip invariant for limited intput: # Output text will tokenize the back to the input t1 = [tok[:2] for tok in generate_tokens(f.readline)] newcode = untokenize(t1) readline = iter(newcode.splitlines(1)).next t2 = [tok[:2] for tokin generate_tokens(readline)] assert t1 == t2 """ ut = Untokenizer() return ut.untokenize(iterable) def generate_tokens(readline): """ The generate_tokens() generator requires one argument, readline, which must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. Alternately, readline can be a callable function terminating with StopIteration: readline = open(myfile).next # Example of alternate readline The generator produces 5-tuples with these members: the token type; the token string; a 2-tuple (srow, scol) of ints specifying the row and column where the token begins in the source; a 2-tuple (erow, ecol) of ints specifying the row and column where the token ends in the source; and the line on which the token was found. The line passed is the logical line; continuation lines are included. """ lnum = parenlev = continued = 0 namechars, numchars = string.ascii_letters + '_', '0123456789' contstr, needcont = '', 0 contline = None indents = [0] while 1: # loop over lines in stream try: line = readline() except StopIteration: line = '' lnum = lnum + 1 pos, max = 0, len(line) if contstr: # continued string if not line: raise TokenError, ("EOF in multi-line string", strstart) endmatch = endprog.match(line) if endmatch: pos = end = endmatch.end(0) yield (STRING, contstr + line[:end], strstart, (lnum, end), contline + line) contstr, needcont = '', 0 contline = None elif needcont and line[-2:] != '\\\n' and line[-3:] != '\\\r\n': yield (ERRORTOKEN, contstr + line, strstart, (lnum, len(line)), contline) contstr = '' contline = None continue else: contstr = contstr + line contline = contline + line continue elif parenlev == 0 and not continued: # new statement if not line: break column = 0 while pos < max: # measure leading whitespace if line[pos] == ' ': column = column + 1 elif line[pos] == '\t': column = (column//tabsize + 1)*tabsize elif line[pos] == '\f': column = 0 else: break pos = pos + 1 if pos == max: break if line[pos] in '#\r\n': # skip comments or blank lines if line[pos] == '#': comment_token = line[pos:].rstrip('\r\n') nl_pos = pos + len(comment_token) yield (COMMENT, comment_token, (lnum, pos), (lnum, pos + len(comment_token)), line) yield (NL, line[nl_pos:], (lnum, nl_pos), (lnum, len(line)), line) else: yield ((NL, COMMENT)[line[pos] == '#'], line[pos:], (lnum, pos), (lnum, len(line)), line) continue if column > indents[-1]: # count indents or dedents indents.append(column) yield (INDENT, line[:pos], (lnum, 0), (lnum, pos), line) while column < indents[-1]: if column not in indents: raise IndentationError( "unindent does not match any outer indentation level", ("", lnum, pos, line)) indents = indents[:-1] yield (DEDENT, '', (lnum, pos), (lnum, pos), line) else: # continued statement if not line: raise TokenError, ("EOF in multi-line statement", (lnum, 0)) continued = 0 while pos < max: pseudomatch = pseudoprog.match(line, pos) if pseudomatch: # scan for tokens start, end = pseudomatch.span(1) spos, epos, pos = (lnum, start), (lnum, end), end token, initial = line[start:end], line[start] if initial in numchars or \ (initial == '.' and token != '.'): # ordinary number yield (NUMBER, token, spos, epos, line) elif initial in '\r\n': newline = NEWLINE if parenlev > 0: newline = NL yield (newline, token, spos, epos, line) elif initial == '#': assert not token.endswith("\n") yield (COMMENT, token, spos, epos, line) elif token in triple_quoted: endprog = endprogs[token] endmatch = endprog.match(line, pos) if endmatch: # all on one line pos = endmatch.end(0) token = line[start:pos] yield (STRING, token, spos, (lnum, pos), line) else: strstart = (lnum, start) # multiple lines contstr = line[start:] contline = line break elif initial in single_quoted or \ token[:2] in single_quoted or \ token[:3] in single_quoted: if token[-1] == '\n': # continued string strstart = (lnum, start) endprog = (endprogs[initial] or endprogs[token[1]] or endprogs[token[2]]) contstr, needcont = line[start:], 1 contline = line break else: # ordinary string yield (STRING, token, spos, epos, line) elif initial in namechars: # ordinary name yield (NAME, token, spos, epos, line) elif initial == '\\': # continued stmt # This yield is new; needed for better idempotency: yield (NL, token, spos, (lnum, pos), line) continued = 1 else: if initial in '([{': parenlev = parenlev + 1 elif initial in ')]}': parenlev = parenlev - 1 yield (OP, token, spos, epos, line) else: yield (ERRORTOKEN, line[pos], (lnum, pos), (lnum, pos+1), line) pos = pos + 1 for indent in indents[1:]: # pop remaining indent levels yield (DEDENT, '', (lnum, 0), (lnum, 0), '') yield (ENDMARKER, '', (lnum, 0), (lnum, 0), '') if __name__ == '__main__': # testing import sys if len(sys.argv) > 1: tokenize(open(sys.argv[1]).readline) else: tokenize(sys.stdin.readline) PKb31]+@™Ë66pgen.pynu„[µü¤# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. # Licensed to PSF under a Contributor Agreement. # Pgen imports from . import grammar, token, tokenize class PgenGrammar(grammar.Grammar): pass class ParserGenerator(object): def __init__(self, filename, stream=None): close_stream = None if stream is None: stream = open(filename) close_stream = stream.close self.filename = filename self.stream = stream self.generator = tokenize.generate_tokens(stream.readline) self.gettoken() # Initialize lookahead self.dfas, self.startsymbol = self.parse() if close_stream is not None: close_stream() self.first = {} # map from symbol name to set of tokens self.addfirstsets() def make_grammar(self): c = PgenGrammar() names = self.dfas.keys() names.sort() names.remove(self.startsymbol) names.insert(0, self.startsymbol) for name in names: i = 256 + len(c.symbol2number) c.symbol2number[name] = i c.number2symbol[i] = name for name in names: dfa = self.dfas[name] states = [] for state in dfa: arcs = [] for label, next in sorted(state.arcs.iteritems()): arcs.append((self.make_label(c, label), dfa.index(next))) if state.isfinal: arcs.append((0, dfa.index(state))) states.append(arcs) c.states.append(states) c.dfas[c.symbol2number[name]] = (states, self.make_first(c, name)) c.start = c.symbol2number[self.startsymbol] return c def make_first(self, c, name): rawfirst = self.first[name] first = {} for label in sorted(rawfirst): ilabel = self.make_label(c, label) ##assert ilabel not in first # XXX failed on <> ... != first[ilabel] = 1 return first def make_label(self, c, label): # XXX Maybe this should be a method on a subclass of converter? ilabel = len(c.labels) if label[0].isalpha(): # Either a symbol name or a named token if label in c.symbol2number: # A symbol name (a non-terminal) if label in c.symbol2label: return c.symbol2label[label] else: c.labels.append((c.symbol2number[label], None)) c.symbol2label[label] = ilabel return ilabel else: # A named token (NAME, NUMBER, STRING) itoken = getattr(token, label, None) assert isinstance(itoken, (int, long)), label assert itoken in token.tok_name, label if itoken in c.tokens: return c.tokens[itoken] else: c.labels.append((itoken, None)) c.tokens[itoken] = ilabel return ilabel else: # Either a keyword or an operator assert label[0] in ('"', "'"), label value = eval(label) if value[0].isalpha(): # A keyword if value in c.keywords: return c.keywords[value] else: c.labels.append((token.NAME, value)) c.keywords[value] = ilabel return ilabel else: # An operator (any non-numeric token) itoken = grammar.opmap[value] # Fails if unknown token if itoken in c.tokens: return c.tokens[itoken] else: c.labels.append((itoken, None)) c.tokens[itoken] = ilabel return ilabel def addfirstsets(self): names = self.dfas.keys() names.sort() for name in names: if name not in self.first: self.calcfirst(name) #print name, self.first[name].keys() def calcfirst(self, name): dfa = self.dfas[name] self.first[name] = None # dummy to detect left recursion state = dfa[0] totalset = {} overlapcheck = {} for label, next in state.arcs.iteritems(): if label in self.dfas: if label in self.first: fset = self.first[label] if fset is None: raise ValueError("recursion for rule %r" % name) else: self.calcfirst(label) fset = self.first[label] totalset.update(fset) overlapcheck[label] = fset else: totalset[label] = 1 overlapcheck[label] = {label: 1} inverse = {} for label, itsfirst in overlapcheck.iteritems(): for symbol in itsfirst: if symbol in inverse: raise ValueError("rule %s is ambiguous; %s is in the" " first sets of %s as well as %s" % (name, symbol, label, inverse[symbol])) inverse[symbol] = label self.first[name] = totalset def parse(self): dfas = {} startsymbol = None # MSTART: (NEWLINE | RULE)* ENDMARKER while self.type != token.ENDMARKER: while self.type == token.NEWLINE: self.gettoken() # RULE: NAME ':' RHS NEWLINE name = self.expect(token.NAME) self.expect(token.OP, ":") a, z = self.parse_rhs() self.expect(token.NEWLINE) #self.dump_nfa(name, a, z) dfa = self.make_dfa(a, z) #self.dump_dfa(name, dfa) oldlen = len(dfa) self.simplify_dfa(dfa) newlen = len(dfa) dfas[name] = dfa #print name, oldlen, newlen if startsymbol is None: startsymbol = name return dfas, startsymbol def make_dfa(self, start, finish): # To turn an NFA into a DFA, we define the states of the DFA # to correspond to *sets* of states of the NFA. Then do some # state reduction. Let's represent sets as dicts with 1 for # values. assert isinstance(start, NFAState) assert isinstance(finish, NFAState) def closure(state): base = {} addclosure(state, base) return base def addclosure(state, base): assert isinstance(state, NFAState) if state in base: return base[state] = 1 for label, next in state.arcs: if label is None: addclosure(next, base) states = [DFAState(closure(start), finish)] for state in states: # NB states grows while we're iterating arcs = {} for nfastate in state.nfaset: for label, next in nfastate.arcs: if label is not None: addclosure(next, arcs.setdefault(label, {})) for label, nfaset in sorted(arcs.iteritems()): for st in states: if st.nfaset == nfaset: break else: st = DFAState(nfaset, finish) states.append(st) state.addarc(st, label) return states # List of DFAState instances; first one is start def dump_nfa(self, name, start, finish): print "Dump of NFA for", name todo = [start] for i, state in enumerate(todo): print " State", i, state is finish and "(final)" or "" for label, next in state.arcs: if next in todo: j = todo.index(next) else: j = len(todo) todo.append(next) if label is None: print " -> %d" % j else: print " %s -> %d" % (label, j) def dump_dfa(self, name, dfa): print "Dump of DFA for", name for i, state in enumerate(dfa): print " State", i, state.isfinal and "(final)" or "" for label, next in sorted(state.arcs.iteritems()): print " %s -> %d" % (label, dfa.index(next)) def simplify_dfa(self, dfa): # This is not theoretically optimal, but works well enough. # Algorithm: repeatedly look for two states that have the same # set of arcs (same labels pointing to the same nodes) and # unify them, until things stop changing. # dfa is a list of DFAState instances changes = True while changes: changes = False for i, state_i in enumerate(dfa): for j in range(i+1, len(dfa)): state_j = dfa[j] if state_i == state_j: #print " unify", i, j del dfa[j] for state in dfa: state.unifystate(state_j, state_i) changes = True break def parse_rhs(self): # RHS: ALT ('|' ALT)* a, z = self.parse_alt() if self.value != "|": return a, z else: aa = NFAState() zz = NFAState() aa.addarc(a) z.addarc(zz) while self.value == "|": self.gettoken() a, z = self.parse_alt() aa.addarc(a) z.addarc(zz) return aa, zz def parse_alt(self): # ALT: ITEM+ a, b = self.parse_item() while (self.value in ("(", "[") or self.type in (token.NAME, token.STRING)): c, d = self.parse_item() b.addarc(c) b = d return a, b def parse_item(self): # ITEM: '[' RHS ']' | ATOM ['+' | '*'] if self.value == "[": self.gettoken() a, z = self.parse_rhs() self.expect(token.OP, "]") a.addarc(z) return a, z else: a, z = self.parse_atom() value = self.value if value not in ("+", "*"): return a, z self.gettoken() z.addarc(a) if value == "+": return a, z else: return a, a def parse_atom(self): # ATOM: '(' RHS ')' | NAME | STRING if self.value == "(": self.gettoken() a, z = self.parse_rhs() self.expect(token.OP, ")") return a, z elif self.type in (token.NAME, token.STRING): a = NFAState() z = NFAState() a.addarc(z, self.value) self.gettoken() return a, z else: self.raise_error("expected (...) or NAME or STRING, got %s/%s", self.type, self.value) def expect(self, type, value=None): if self.type != type or (value is not None and self.value != value): self.raise_error("expected %s/%s, got %s/%s", type, value, self.type, self.value) value = self.value self.gettoken() return value def gettoken(self): tup = self.generator.next() while tup[0] in (tokenize.COMMENT, tokenize.NL): tup = self.generator.next() self.type, self.value, self.begin, self.end, self.line = tup #print token.tok_name[self.type], repr(self.value) def raise_error(self, msg, *args): if args: try: msg = msg % args except: msg = " ".join([msg] + map(str, args)) raise SyntaxError(msg, (self.filename, self.end[0], self.end[1], self.line)) class NFAState(object): def __init__(self): self.arcs = [] # list of (label, NFAState) pairs def addarc(self, next, label=None): assert label is None or isinstance(label, str) assert isinstance(next, NFAState) self.arcs.append((label, next)) class DFAState(object): def __init__(self, nfaset, final): assert isinstance(nfaset, dict) assert isinstance(iter(nfaset).next(), NFAState) assert isinstance(final, NFAState) self.nfaset = nfaset self.isfinal = final in nfaset self.arcs = {} # map from label to DFAState def addarc(self, next, label): assert isinstance(label, str) assert label not in self.arcs assert isinstance(next, DFAState) self.arcs[label] = next def unifystate(self, old, new): for label, next in self.arcs.iteritems(): if next is old: self.arcs[label] = new def __eq__(self, other): # Equality test -- ignore the nfaset instance variable assert isinstance(other, DFAState) if self.isfinal != other.isfinal: return False # Can't just return self.arcs == other.arcs, because that # would invoke this method recursively, with cycles... if len(self.arcs) != len(other.arcs): return False for label, next in self.arcs.iteritems(): if next is not other.arcs.get(label): return False return True __hash__ = None # For Py3 compatibility. def generate_grammar(filename="Grammar.txt"): p = ParserGenerator(filename) return p.make_grammar() PKc31]Œ²r__init__.pynu„[µü¤# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. # Licensed to PSF under a Contributor Agreement. """The pgen2 package.""" PKc31]l—5¸™™ driver.pynu„[µü¤# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. # Licensed to PSF under a Contributor Agreement. # Modifications: # Copyright 2006 Google, Inc. All Rights Reserved. # Licensed to PSF under a Contributor Agreement. """Parser driver. This provides a high-level interface to parse a file into a syntax tree. """ __author__ = "Guido van Rossum " __all__ = ["Driver", "load_grammar"] # Python imports import codecs import os import logging import pkgutil import StringIO import sys # Pgen imports from . import grammar, parse, token, tokenize, pgen class Driver(object): def __init__(self, grammar, convert=None, logger=None): self.grammar = grammar if logger is None: logger = logging.getLogger() self.logger = logger self.convert = convert def parse_tokens(self, tokens, debug=False): """Parse a series of tokens and return the syntax tree.""" # XXX Move the prefix computation into a wrapper around tokenize. p = parse.Parser(self.grammar, self.convert) p.setup() lineno = 1 column = 0 type = value = start = end = line_text = None prefix = u"" for quintuple in tokens: type, value, start, end, line_text = quintuple if start != (lineno, column): assert (lineno, column) <= start, ((lineno, column), start) s_lineno, s_column = start if lineno < s_lineno: prefix += "\n" * (s_lineno - lineno) lineno = s_lineno column = 0 if column < s_column: prefix += line_text[column:s_column] column = s_column if type in (tokenize.COMMENT, tokenize.NL): prefix += value lineno, column = end if value.endswith("\n"): lineno += 1 column = 0 continue if type == token.OP: type = grammar.opmap[value] if debug: self.logger.debug("%s %r (prefix=%r)", token.tok_name[type], value, prefix) if p.addtoken(type, value, (prefix, start)): if debug: self.logger.debug("Stop.") break prefix = "" lineno, column = end if value.endswith("\n"): lineno += 1 column = 0 else: # We never broke out -- EOF is too soon (how can this happen???) raise parse.ParseError("incomplete input", type, value, (prefix, start)) return p.rootnode def parse_stream_raw(self, stream, debug=False): """Parse a stream and return the syntax tree.""" tokens = tokenize.generate_tokens(stream.readline) return self.parse_tokens(tokens, debug) def parse_stream(self, stream, debug=False): """Parse a stream and return the syntax tree.""" return self.parse_stream_raw(stream, debug) def parse_file(self, filename, encoding=None, debug=False): """Parse a file and return the syntax tree.""" stream = codecs.open(filename, "r", encoding) try: return self.parse_stream(stream, debug) finally: stream.close() def parse_string(self, text, debug=False): """Parse a string and return the syntax tree.""" tokens = tokenize.generate_tokens(StringIO.StringIO(text).readline) return self.parse_tokens(tokens, debug) def _generate_pickle_name(gt): head, tail = os.path.splitext(gt) if tail == ".txt": tail = "" return head + tail + ".".join(map(str, sys.version_info)) + ".pickle" def load_grammar(gt="Grammar.txt", gp=None, save=True, force=False, logger=None): """Load the grammar (maybe from a pickle).""" if logger is None: logger = logging.getLogger() gp = _generate_pickle_name(gt) if gp is None else gp if force or not _newer(gp, gt): logger.info("Generating grammar tables from %s", gt) g = pgen.generate_grammar(gt) if save: logger.info("Writing grammar tables to %s", gp) try: g.dump(gp) except IOError as e: logger.info("Writing failed: %s", e) else: g = grammar.Grammar() g.load(gp) return g def _newer(a, b): """Inquire whether file a was written since file b.""" if not os.path.exists(a): return False if not os.path.exists(b): return True return os.path.getmtime(a) >= os.path.getmtime(b) def load_packaged_grammar(package, grammar_source): """Normally, loads a pickled grammar by doing pkgutil.get_data(package, pickled_grammar) where *pickled_grammar* is computed from *grammar_source* by adding the Python version and using a ``.pickle`` extension. However, if *grammar_source* is an extant file, load_grammar(grammar_source) is called instead. This facilitates using a packaged grammar file when needed but preserves load_grammar's automatic regeneration behavior when possible. """ if os.path.isfile(grammar_source): return load_grammar(grammar_source) pickled_name = _generate_pickle_name(os.path.basename(grammar_source)) data = pkgutil.get_data(package, pickled_name) g = grammar.Grammar() g.loads(data) return g def main(*args): """Main program, when run as a script: produce grammar pickle files. Calls load_grammar for each argument, a path to a grammar text file. """ if not args: args = sys.argv[1:] logging.basicConfig(level=logging.INFO, stream=sys.stdout, format='%(message)s') for gt in args: load_grammar(gt, save=True, force=True) return True if __name__ == "__main__": sys.exit(int(not main())) PKc31]Þ¦ªËèètoken.pynuÈ¯Ýí#! /usr/bin/python2.7 """Token constants (from "token.h").""" # Taken from Python (r53757) and modified to include some tokens # originally monkeypatched in by pgen2.tokenize #--start constants-- ENDMARKER = 0 NAME = 1 NUMBER = 2 STRING = 3 NEWLINE = 4 INDENT = 5 DEDENT = 6 LPAR = 7 RPAR = 8 LSQB = 9 RSQB = 10 COLON = 11 COMMA = 12 SEMI = 13 PLUS = 14 MINUS = 15 STAR = 16 SLASH = 17 VBAR = 18 AMPER = 19 LESS = 20 GREATER = 21 EQUAL = 22 DOT = 23 PERCENT = 24 BACKQUOTE = 25 LBRACE = 26 RBRACE = 27 EQEQUAL = 28 NOTEQUAL = 29 LESSEQUAL = 30 GREATEREQUAL = 31 TILDE = 32 CIRCUMFLEX = 33 LEFTSHIFT = 34 RIGHTSHIFT = 35 DOUBLESTAR = 36 PLUSEQUAL = 37 MINEQUAL = 38 STAREQUAL = 39 SLASHEQUAL = 40 PERCENTEQUAL = 41 AMPEREQUAL = 42 VBAREQUAL = 43 CIRCUMFLEXEQUAL = 44 LEFTSHIFTEQUAL = 45 RIGHTSHIFTEQUAL = 46 DOUBLESTAREQUAL = 47 DOUBLESLASH = 48 DOUBLESLASHEQUAL = 49 AT = 50 ATEQUAL = 51 OP = 52 COMMENT = 53 NL = 54 RARROW = 55 ERRORTOKEN = 56 N_TOKENS = 57 NT_OFFSET = 256 #--end constants-- tok_name = {} for _name, _value in globals().items(): if type(_value) is type(0): tok_name[_value] = _name def ISTERMINAL(x): return x < NT_OFFSET def ISNONTERMINAL(x): return x >= NT_OFFSET def ISEOF(x): return x == ENDMARKER PKhP3]N æ3$__pycache__/literals.cpython-311.pycnu„[µü¤§ àÀfcãób—dZddlZddddddd d ddd œ Zd„Zd„Zd„Zedkre¦«dSdS)zŠ>˜$ÑÔÐÐÐÝ × Ò ˜TÑ "Ô "€CØ €Øˆ Ø‡‚sÑÔðVØQRR”ˆÝˆu‰:Œ:˜Š>ˆ>ÝÐAÀDÑHÑIÔIÐIð TÝE˜2‘”ˆAˆAøÝð Tð Tð TÝÐAÀDÑHÑIÔIÈtÐSð Tøøøð VÝD˜!‘”ˆAˆAøÝð Vð Vð VÝÐCÀdÑJÑKÔKÐQUÐUð Vøøøåˆq‰6Œ6€MsÂB%Â%CÃCÃC6có—| d¦«s4| d¦«sJt|dd…¦«¦«‚|d}|dd…|dzkr|dz}| |¦«s-Jt|t|¦«d…¦«¦«‚t|¦«dt|¦«zksJ‚|t|¦«t|¦«…}t jdt|¦«S)Nr rrrérz)\\(\'|\"|\\|[abfnrtv]|x.{0,2}|[0-7]{1,3}))rÚreprÚendswithrÚreÚsubr))ÚsÚqs r(Ú evalStringr2(sï€Ø<Š<˜ÑÔÐ> §¢¨SÑ 1Ô 1Ð>Ð>µ4¸¸"¸1¸"¼±;´;Ñ>Ô>Ð1Ø ˆ!Œ€AØˆˆ!ˆ„u!‘‚|€|Ø ˆa‰CˆØ:Š:a‰=Œ=Ð+Ð+$˜q¥# a¡&¤& œ{Ñ+Ô+Ñ+Ô+ˆ=Ýˆq‰6Œ6Q•s˜1‘v”v‘XÒÐÐÐØ #ˆa‰&Œ&•#a‘&”&ˆ.Ô€AÝ Œ6Ð>ÅÈÑJÔJÐJócó´—td¦«D]G}t|¦«}t|¦«}t|¦«}||krt ||||¦«ŒHdS)Né)Úranger!r,r2Úprint)r'Úcr0Úes r(Útestr:2s`€Ý 3‰ZŒZððˆÝ‰FŒFˆÝ‰GŒGˆÝq‰MŒMˆØŠ6ˆ6Ý!Q˜˜1ÑÔÐøððr3Ú__main__)Ú__doc__r.rr)r2r:Ú__name__©r3r(úr?s•ððCÐBà € € € àØØØØØØØØØð ð €ðððð*KðKðKððððˆzÒÐØ€DF„F€F€F€FðÐr3PKhP3]»Ñ’kJkJ&__pycache__/pgen.cpython-311.opt-1.pycnu„[µü¤§ àÀf6ãóœ—ddlmZmZmZGd„dej¦«ZGd„de¦«ZGd„de¦«ZGd„d e¦«Z d d„Z dS)é)ÚgrammarÚtokenÚtokenizecó—eZdZdS)ÚPgenGrammarN)Ú__name__Ú __module__Ú__qualname__©óú9/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/pgen.pyrrs€€€€€Ø€Drrcó~—eZdZdd„Zd„Zd„Zd„Zd„Zd„Zd„Z d „Z d „Zd„Zd„Z d „Zd„Zd„Zd„Zdd„Zd„Zd„ZdS)ÚParserGeneratorNcóN—d}|€t|d¬¦«}|j}||_||_t j|j¦«|_| ¦«| ¦«\|_ |_| |¦«i|_| ¦«dS)Nzutf-8)Úencoding)ÚopenÚcloseÚfilenameÚstreamrÚgenerate_tokensÚreadlineÚ generatorÚgettokenÚparseÚdfasÚstartsymbolÚfirstÚaddfirstsets)ÚselfrrÚclose_streams r Ú__init__zParserGenerator.__init__s›€ØˆØˆ>Ý˜(¨WÐ5Ñ5Ô5ˆFØ!œ<ˆLØ ˆŒ ØˆŒÝ!Ô1°&´/ÑBÔBˆŒØ Š ‰ŒˆØ&*§j¢j¡l¤lÑ#ˆŒ 4Ô#ØÐ#ØˆL‰NŒNˆNØˆŒ Ø×ÒÑÔÐÐÐrc ó²—t¦«}t|j ¦«¦«}| ¦«| |j¦«| d|j¦«|D]-}dt|j ¦«z}||j |<||j |<Œ.|D]}|j|}g}|D]´}g}t|j ¦«¦«D]C\} } | | || ¦«| | ¦«f¦«ŒD|jr*| d| |¦«f¦«| |¦«Œµ|j |¦«|| ||¦«f|j|j |<Œ|j |j|_|S)Néé)rÚlistrÚkeysÚsortÚremoverÚinsertÚlenÚ symbol2numberÚ number2symbolÚsortedÚarcsÚitemsÚappendÚ make_labelÚindexÚisfinalÚstatesÚ make_firstÚstart)rÚcÚnamesÚnameÚiÚdfar4Ústater.ÚlabelÚnexts r Úmake_grammarzParserGenerator.make_grammarsÂ€Ý‰MŒMˆÝT”Y—^’^Ñ%Ô%Ñ&Ô&ˆØ Š ‰ŒˆØ ŠTÔ%Ñ&Ô&Ð&Ø ŠQ˜Ô(Ñ)Ô)Ð)Øð &ð &ˆDØ•c˜!œ/Ñ*Ô*Ñ*ˆAØ$%ˆAŒO˜DÑ!Ø!%ˆAŒO˜AÑÐØð Oñ OˆDØ”)˜D”/ˆCØˆFØð $ð $ØÝ#)¨%¬*×*:Ò*:Ñ*<Ô*<Ñ#=Ô#=ðNðN‘KE˜4Ø—K’K §¢°°EÑ!:Ô!:¸C¿IºIÀd¹O¼OÐ LÑMÔMÐMÐMØ”=ð7Ø—K’K C§I¢I¨eÑ$4Ô$4Ð 5Ñ6Ô6Ð6Ø— ’ ˜dÑ#Ô#Ð#Ð#Ø ŒHOŠO˜FÑ#Ô#Ð#Ø-3°T·_²_ÀQÈÑ5MÔ5MÐ,NˆAŒF1”? 4Ô(Ñ)Ñ)Ø”/ $Ô"2Ô3ˆŒØˆrcó~—|j|}i}t|¦«D]}| ||¦«}d||<Œ|S©Nr)rr-r1)rr7r9Úrawfirstrr=Úilabels r r5zParserGenerator.make_first4sM€Ø”:˜dÔ#ˆØˆÝ˜HÑ%Ô%ð ð ˆEØ—_’_ Q¨Ñ.Ô.ˆFàˆE&‰MˆMØˆrcó,—t|j¦«}|d ¦«r¦||jvrI||jvr |j|S|j |j|df¦«||j|<|St t|d¦«}||jvr |j|S|j |df¦«||j|<|St|¦«}|d ¦«rH||j vr |j |S|j tj|f¦«||j |<|Stj |}||jvr |j|S|j |df¦«||j|<|S©Nr#)r*ÚlabelsÚisalphar+Úsymbol2labelr0ÚgetattrrÚtokensÚevalÚkeywordsÚNAMErÚopmap)rr7r=rCÚitokenÚvalues r r1zParserGenerator.make_label=s“€åQ”X‘”ˆØŒ8×ÒÑÔð) "à˜œÐ'Ð'à˜AœNÐ*Ð*Øœ>¨%Ô0Ð0à”H—O’O Q¤_°UÔ%;¸TÐ$BÑCÔCÐCØ,2A”N 5Ñ)Ø!Mõ!¥¨¨tÑ4Ô4ð˜QœXÐ%Ð%Øœ8 FÔ+Ð+à”H—O’O V¨T NÑ3Ô3Ð3Ø'-A”H˜VÑ$Ø!Mõ˜‘K”KˆEØQŒx×ÒÑ!Ô!ð "à˜AœJÐ&Ð&Øœ: eÔ,Ð,à”H—O’O¥U¤Z°Ð$7Ñ8Ô8Ð8Ø(.A”J˜uÑ%Ø!Mõ!œ uÔ-Ø˜QœXÐ%Ð%Øœ8 FÔ+Ð+à”H—O’O V¨T NÑ3Ô3Ð3Ø'-A”H˜VÑ$Ø!MrcóÀ—t|j ¦«¦«}| ¦«|D] }||jvr| |¦«Œ!dS©N)r%rr&r'rÚ calcfirst)rr8r9s r rzParserGenerator.addfirstsetsksa€ÝT”Y—^’^Ñ%Ô%Ñ&Ô&ˆØ Š ‰ŒˆØð %ð %ˆDØ˜4œ:Ð%Ð%Ø—’˜tÑ$Ô$Ð$øð %ð %rc ó.—|j|}d|j|<|d}i}i}|j ¦«D]‚\}}||jvrh||jvr"|j|}|€t d|z¦«‚n"| |¦«|j|}| |¦«|||<Œvd||<|di||<Œƒi} | ¦«D]4\}} | D],}|| vr!t d|›d|›d|›d| |›¦«‚|| |<Œ-Œ5||j|<dS)Nr#zrecursion for rule %rrzrule z is ambiguous; z is in the first sets of z as well as )rrr.r/Ú ValueErrorrSÚupdate)rr9r;r<ÚtotalsetÚoverlapcheckr=r>ÚfsetÚinverseÚitsfirstÚsymbols r rSzParserGenerator.calcfirstss†€ØŒi˜ŒoˆØˆŒ 4ÑØA”ˆØˆØˆØ œ:×+Ò+Ñ-Ô-ð 1ð 1‰KˆE4Ø˜œ Ð!Ð!Ø˜DœJÐ&Ð&Øœ: eÔ,DØ|Ý(Ð)@À4Ñ)GÑHÔHÐHð$ð—N’N 5Ñ)Ô)Ð)Øœ: eÔ,DØ—’ Ñ%Ô%Ð%Ø&*˜UÑ#Ð#à"#˜‘Ø',¨a j˜UÑ#Ð#ØˆØ+×1Ò1Ñ3Ô3ð (ð (‰OˆE8Ø"ð (ð (Ø˜WÐ$Ð$Ý$˜*à&* d d¨F¨F¨F°E°E°E¸7À6¼?¸?ð&LñMôMðMð#(˜‘ð (ð$ˆŒ 4ÑÐÐrcót—i}d}|jtjkr|jtjkr)| ¦«|jtjk°)| tj¦«}| tjd¦«| ¦«\}}| tj¦«| ||¦«}t|¦«}| |¦«t|¦«}|||<|€|}|jtjk°||fS)Nú:)ÚtyperÚ ENDMARKERÚNEWLINErÚexpectrMÚOPÚ parse_rhsÚmake_dfar*Úsimplify_dfa) rrrr9ÚaÚzr;ÚoldlenÚnewlens r rzParserGenerator.parse‘s €ØˆØˆàŒi5œ?Ò*Ñ*Ø”)uœ}Ò,Ð,Ø— ’ ‘”ð”)uœ}Ò,Ð,ð—;’;uœzÑ*Ô*ˆDØKŠKœ #Ñ&Ô&Ð&Ø—>’>Ñ#Ô#‰DˆAˆqØKŠKœ Ñ&Ô&Ð&à—-’- 1Ñ%Ô%ˆCå˜‘X”XˆFØ×Ò˜cÑ"Ô"Ð"Ý˜‘X”XˆFØˆD‰JàÐ"Ø"ð#Œi5œ?Ò*Ñ*ð$[Ð Ð rc ó¸‡—ˆfd„}ˆfd„Št||¦«|¦«g}|D]±}i}|jD]1}|jD]'\}} | ‰| | |i¦«¦«Œ(Œ2t | ¦«¦«D]R\}} |D]}|j| krn&Œt| |¦«}| |¦«| ||¦«ŒSŒ²|S)Ncó$•—i}‰||¦«|SrRr)r<ÚbaseÚ addclosures €r Úclosurez)ParserGenerator.make_dfa..closure°sø€ØˆDØˆJu˜dÑ#Ô#Ð#ØˆKrcóT•—||vrdSd||<|jD]\}}|€‰||¦«ŒdSrA©r.)r<rmr=r>rns €r rnz,ParserGenerator.make_dfa..addclosure´sQø€à˜ˆ}ˆ}ØØˆD‰KØ$œzð +ð +‘tØ=ØJ˜t TÑ*Ô*Ð*øð +ð +r)ÚDFAStateÚnfasetr.Ú setdefaultr-r/r0Úaddarc) rr6Úfinishror4r<r.Únfastater=r>rsÚstrns @r rezParserGenerator.make_dfa©sMø€ð ð ð ð ð ð +ð +ð +ð +ð +õ˜7˜7 5™>œ>¨6Ñ2Ô2Ð3ˆØð (ð (ˆEØˆDØ!œLð Eð EØ#+¤=ðEðE‘KE˜4ØÐ(Ø"˜ 4¨¯ª¸ÀÑ)CÔ)CÑDÔDÐDøðEõ"(¨¯ ª ©¬Ñ!5Ô!5ð (ð (‘ vØ ð&ð&BØ”y FÒ*Ð*Ø˜ð+õ" &¨&Ñ1Ô1BØ—M’M "Ñ%Ô%Ð%Ø—’˜R Ñ'Ô'Ð'Ð'ð (ðˆ rcól—td|¦«|g}t|¦«D]\}}td|||urdpd¦«|jD]l\}}||vr| |¦«} n$t |¦«} | |¦«|€td| z¦«ŒXtd|| fz¦«ŒmŒ‘dS)NzDump of NFA forú Stateú(final)Úz -> %dú %s -> %d)ÚprintÚ enumerater.r2r*r0) rr9r6rvÚtodor:r<r=r>Újs r Údump_nfazParserGenerator.dump_nfaÍsä€Ý Ð Ñ&Ô&Ð&ØˆwˆÝ! $™œð 7ð 7‰HˆAˆuÝ)˜Q ¨ Ð =°IÐ CÀÑDÔDÐDØ$œzð 7ð 7‘tØ˜4<<ØŸ š 4Ñ(Ô(AAå˜D™ œ AØ—K’K Ñ%Ô%Ð%Ø=Ý˜+¨™/Ñ*Ô*Ð*Ð*å˜.¨E°1¨:Ñ5Ñ6Ô6Ð6Ð6ð 7ð 7ð 7rc ó*—td|¦«t|¦«D]r\}}td||jrdpd¦«t|j ¦«¦«D],\}}td|| |¦«fz¦«Œ-ŒsdS)NzDump of DFA forrzr{r|r})r~rr3r-r.r/r2)rr9r;r:r<r=r>s r Údump_dfazParserGenerator.dump_dfaÝs®€Ý Ð Ñ&Ô&Ð&Ý! #™œð Að A‰HˆAˆuÝ)˜Q ¤ Ð ;°)Ð A¸rÑBÔBÐBÝ% e¤j×&6Ò&6Ñ&8Ô&8Ñ9Ô9ð Að A‘tÝn¨¨s¯yªy¸©¬Ð'?Ñ?Ñ@Ô@Ð@Ð@ð Að Að Arcóê—d}|rnd}t|¦«D]X\}}t|dzt|¦«¦«D]2}||}||kr"||=|D]}| ||¦«Œd}nŒ3ŒY|°ldSdS)NTFr)rÚranger*Ú unifystate)rr;Úchangesr:Ústate_irÚstate_jr<s r rfzParserGenerator.simplify_dfaäsÃ€ðˆØð ØˆGÝ'¨™nœnð ð ‘ 7Ý˜q ™s¥C¨¡H¤HÑ-Ô-ððAØ! !œfGØ 'Ò)Ð)à ˜FØ%(ð?ð?˜EØ!×,Ò,¨W°gÑ>Ô>Ð>Ð>Ø"&˜Ø˜ð *øðð ð ð ð ð rcó¸—| ¦«\}}|jdkr||fSt¦«}t¦«}| |¦«| |¦«|jdkr`| ¦«| ¦«\}}| |¦«| |¦«|jdk°`||fS)Nú|)Ú parse_altrPÚNFAStaterur)rrgrhÚaaÚzzs r rdzParserGenerator.parse_rhsùsÀ€à~Š~ÑÔ‰ˆˆ1ØŒ:˜ÒÐØa4ˆKå‘”ˆBÝ‘”ˆBØIŠIa‰LŒLˆLØ HŠHR‰LŒLˆLØ”* Ò#Ð#Ø— ’ ‘”Ø—~’~Ñ'Ô'‘1Ø— ’ ˜!‘”Ø—’˜‘”ð ”* Ò#Ð#ð r6ˆMrcó4—| ¦«\}}|jdvs|jtjtjfvrV| ¦«\}}| |¦«|}|jdv°7|jtjtjfv°V||fS)N)ú(ú[)Ú parse_itemrPr_rrMÚSTRINGru)rrgÚbr7Úds r rzParserGenerator.parse_alt s€àŠÑ Ô ‰ˆˆ1ØŒz˜ZÐ'Ð'ØŒyUœZ¬Ð6Ð6Ð6Ø—?’?Ñ$Ô$‰DˆAˆqØ HŠHQ‰KŒKˆKØˆAð Œz˜ZÐ'Ð'ØŒyUœZ¬Ð6Ð6Ð6ð!ˆtˆrcóš—|jdkrd| ¦«| ¦«\}}| tjd¦«| |¦«||fS| ¦«\}}|j}|dvr||fS| ¦«| |¦«|dkr||fS||fS)Nr“ú])ú+Ú*rš)rPrrdrbrrcruÚ parse_atom)rrgrhrPs r r”zParserGenerator.parse_itemsÂ€àŒ:˜ÒÐØMŠM‰OŒOˆOØ—>’>Ñ#Ô#‰DˆAˆqØKŠKœ #Ñ&Ô&Ð&Ø HŠHQ‰KŒKˆKØa4ˆKà—?’?Ñ$Ô$‰DˆAˆqØ”JˆEØ˜JÐ&Ð&Ø˜!tØMŠM‰OŒOˆOØ HŠHQ‰KŒKˆKØ˜Š|ˆ|Ø˜!tà˜!trcóØ—|jdkrO| ¦«| ¦«\}}| tjd¦«||fS|jtjtjfvrOt¦«}t¦«}| ||j¦«| ¦«||fS| d|j|j¦«dS)Nr’ú)z+expected (...) or NAME or STRING, got %s/%s)rPrrdrbrrcr_rMr•rŽruÚraise_error)rrgrhs r rœzParserGenerator.parse_atom(sÐ€àŒ:˜ÒÐØMŠM‰OŒOˆOØ—>’>Ñ#Ô#‰DˆAˆqØKŠKœ #Ñ&Ô&Ð&Øa4ˆKØ ŒY5œ:¥u¤|Ð4Ð 4Ð 4Ý‘ ” ˆAÝ‘ ” ˆAØ HŠHQ˜œ Ñ#Ô#Ð#ØMŠM‰OŒOˆOØa4ˆKà×ÒÐJØ!œY¨¬ ñ 4ô 4ð 4ð 4ð 4rcó²—|j|ks |.|j|kr#| d|||j|j¦«|j}| ¦«|S)Nzexpected %s/%s, got %s/%s)r_rPrŸr)rr_rPs r rbzParserGenerator.expect9sd€ØŒ9˜ÒÐ Ð!2°t´zÀUÒ7JÐ7JØ×ÒÐ8Ø! 5¨$¬)°T´Zñ Aô Að Aà” ˆØ Š ‰ŒˆØˆrcó—t|j¦«}|dtjtjfvr4t|j¦«}|dtjtjfv°4|\|_|_|_|_|_ dSrE) r>rrÚCOMMENTÚNLr_rPÚbeginÚendÚline)rÚtups r rzParserGenerator.gettokenAsr€Ý4”>Ñ"Ô"ˆØ!ŒfÔ)8¬;Ð7Ð7Ð7Ýt”~Ñ&Ô&ˆCð!ŒfÔ)8¬;Ð7Ð7Ð7àADÑ>ˆŒ 4”:˜tœz¨4¬8°T´Y°Y°Yrc óü—|rG ||z}n@#d |gttt|¦«¦«z¦«}YnxYwt ||j|jd|jd|jf¦«‚)Nú r#r)Újoinr%ÚmapÚstrÚSyntaxErrorrr¥r¦)rÚmsgÚargss r rŸzParserGenerator.raise_errorHs€Øð =ð =Ø˜D‘jøð =Ø—h’h ˜u¥tCµ°T©N¬NÑ';Ô';Ñ;Ñ<Ô<øøøÝ˜# ¤ ¨t¬x¸¬{Ø $¤¨¤¨T¬Yð 8ñ9ô9ð 9s „ Š;ArR)rr r r!r?r5r1rrSrrer‚r„rfrdrr”rœrbrrŸrrr rr s4€€€€€ð ð ð ð ðððð2ððð,"ð,"ð,"ð\%ð%ð%ð$ð$ð$ð<!ð!ð!ð0"ð"ð"ðH7ð7ð7ð AðAðAðððð*ððð"ðððððð(4ð4ð4ð"ððððEðEðEð9ð9ð9ð9ð9rrcó—eZdZd„Zdd„ZdS)rŽcó—g|_dSrRrq)rs r r!zNFAState.__init__Ss €ØˆŒ ˆ ˆ rNcó>—|j ||f¦«dSrR)r.r0©rr>r=s r ruzNFAState.addarcVs$€ð Œ ×Ò˜% ˜Ñ'Ô'Ð'Ð'Ð'rrR)rr r r!rurrr rŽrŽQs7€€€€€ðððð(ð(ð(ð(ð(ð(rrŽcó*—eZdZd„Zd„Zd„Zd„ZdZdS)rrcó4—||_||v|_i|_dSrR)rsr3r.)rrsÚfinals r r!zDFAState.__init__]s!€ðˆŒØ ˆŒØˆŒ ˆ ˆ rcó—||j|<dSrRrqr³s r ruzDFAState.addarces€ð ˆŒ %ÑÐÐrcó`—|j ¦«D]\}}||ur ||j|<ŒdSrR)r.r/)rÚoldÚnewr=r>s r r‡zDFAState.unifystateksA€Øœ9Ÿ?š?Ñ,Ô,ð 'ð '‰KˆE4Øsˆ{ˆ{Ø#&” ˜%Ñ øð 'ð 'rcóþ—|j|jkrdSt|j¦«t|j¦«krdS|j ¦«D]$\}}||j |¦«urdSŒ%dS)NFT)r3r*r.r/Úget)rÚotherr=r>s r Ú__eq__zDFAState.__eq__psƒ€ðŒ<˜5œ=Ò(Ð(Ø5õˆtŒy‰>Œ>S ¤™_œ_Ò,Ð,Ø5Øœ9Ÿ?š?Ñ,Ô,ð ð ‰KˆE4Ø˜5œ:Ÿ>š>¨%Ñ0Ô0Ð0Ð0Øuuð1àˆtrN)rr r r!rur‡r¾Ú__hash__rrr rrrr[sQ€€€€€ðððð ð ð ð'ð'ð'ð ððð€H€H€HrrrúGrammar.txtcóH—t|¦«}| ¦«SrR)rr?)rÚps r Úgenerate_grammarrÃ€s€Ý˜Ñ!Ô!€AØ>Š>ÑÔÐrN)rÀ)r|rrrÚGrammarrÚobjectrrŽrrrÃrrr úrÆs÷ðð 'Ð&Ð&Ð&Ð&Ð&Ð&Ð&Ð&Ð&ð ð ð ð ð '”/ñ ô ð ðE9ðE9ðE9ðE9ðE9fñE9ôE9ðE9ðN (ð(ð(ð(ð(ˆvñ(ô(ð(ð#ð#ð#ð#ð#ˆvñ#ô#ð#ðJðððððrPKhP3]ù\ç<ÑNÑN*__pycache__/tokenize.cpython-311.opt-2.pycnu„[µü¤§ àÀfRãóN— dZdZddlZddlZddlmZmZddlTddlm Z d„e e ¦«D¦«gd ¢zZ[ en #e $reZYnwxYwd „Zd„Zd„Zd „ZdZdZeedez¦«zee¦«zZdZdZdZdZedd¦«Zeeeee¦«ZdZedd¦«ee¦«zZdezZeee¦«Zededz¦«Z ee ee¦«Z!dZ"dZ#dZ$d Z%d!Z&ee&d"ze&d#z¦«Z'ee&d$ze&d%z¦«Z(ed&d'd(d)d*d+d,d-d.¦ « Z)d/Z*ed0d1d2¦«Z+ee)e*e+¦«Z,ee!e,e(e¦«Z-ee-zZ.ee&d3zed4d¦«ze&d5zed6d¦«z¦«Z/edee'¦«Z0eee0e!e,e/e¦«zZ1e2ej3e.e1e$e%f¦«\Z4Z5Z6Z7ed7d8d9d:¦«ed7d8d;d<¦«zhd=£zZ8ej3e"¦«ej3e#¦«e6e7d>œd?„e8D¦«¥d@„e8D¦«¥dA„e8D¦«¥Z9d"d#hdB„e8D¦«zdC„e8D¦«zZ:d4d6hdD„e8D¦«zdE„e8D¦«zZ;dFZ<GdG„dHe=¦«Z>GdI„dJe=¦«Z?dK„Z@e@fdL„ZAdM„ZBGdN„dO¦«ZCej3dPejD¦«ZEej3dQejD¦«ZFdR„ZGdS„ZHdT„ZIdU„ZJeKdVkrUddlLZLeMeLjN¦«dkr&eAeOeLjNd¦«jP¦«dSeAeLjQjP¦«dSdS)WzKa-Ping Yee z@GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, Skip MontanaroéN)ÚBOM_UTF8Úlookup)Ú*é)Útokencó*—g|]}|ddk¯|‘ŒS)rÚ_©)Ú.0Úxs ú=/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/tokenize.pyú r%s!€Ð 0Ð 0Ð 0 A a¤D¨C¢K Kˆ1 K K Kó)ÚtokenizeÚgenerate_tokensÚ untokenizecó8—dd |¦«zdzS)Nú(ú|ú))Újoin©Úchoicess r Úgroupr0s€˜C #§(¢(¨7Ñ"3Ô"3Ñ3°cÑ9Ð9rcó—t|ŽdzS)Nr©rrs r Úanyr1s€% ˜/¨CÑ/Ð/rcó—t|ŽdzS)Nú?rrs r Úmayber 2s€E 7˜O¨cÑ1Ð1rcó:‡—tˆfd„‰D¦«¦«S)Nc3ó†•K—|];}‰dzD]3}| ¦«| ¦«k¯,||zV—Œ4Œz _combinations..4s`øèè€ððØ ! e¡)ððØ¨q¯zªz©|¬|¸q¿zºz¹|¼|Ò/KÐ/KˆˆA‰Ð/KÐ/KÐ/KÐ/KÐ/Kððr)Úset)r&s`r Ú _combinationsr)3s;ø€ÝððððØðñôñôðrz[ \f\t]*z #[^\r\n]*z\\\r?\nz\w+z0[bB]_?[01]+(?:_[01]+)*z(0[xX]_?[\da-fA-F]+(?:_[\da-fA-F]+)*[lL]?z0[oO]?_?[0-7]+(?:_[0-7]+)*[lL]?z[1-9]\d*(?:_\d+)*[lL]?z0[lL]?z[eE][-+]?\d+(?:_\d+)*z\d+(?:_\d+)*\.(?:\d+(?:_\d+)*)?z\.\d+(?:_\d+)*z\d+(?:_\d+)*z\d+(?:_\d+)*[jJ]z[jJ]z[^'\\]*(?:\\.[^'\\]*)*'z[^"\\]*(?:\\.[^"\\]*)*"z%[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''z%[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""z'(?:[uUrRbBfF]|[rR][fFbB]|[fFbBuU][rR])?ú'''ú"""z'[^\n'\\]*(?:\\.[^\n'\\]*)*'z"[^\n"\\]*(?:\\.[^\n"\\]*)*"z\*\*=?z>>=?z<<=?z<>z!=z//=?z->z[+\-*/%&@|^=<>]=?ú~z[][(){}]z\r?\nz:=z[:;.,`@]z'[^\n'\\]*(?:\\.[^\n'\\]*)*ú'z"[^\n"\\]*(?:\\.[^\n"\\]*)*ú"ÚrÚRÚfÚFÚbÚB>ÚUÚuÚURÚUrÚuRÚur)r-r.r*r+có$—i|] }|›dt“ŒS©r*)Úsingle3prog©rÚprefixs r ú r@yó €ÐFÐFÐF¨v&ˆ~ˆ~ˆ~{ÐFÐFÐFrcó$—i|] }|›dt“ŒS©r+)Údouble3progr>s r r@r@zrArcó—i|]}|d“ŒS©Nr r>s r r@r@{s€Ð7Ð7Ð7 ˆvtÐ7Ð7Ð7rcó—h|]}|›d’ŒSr<r r>s r ú rHó€Ð/Ð/Ð/˜ˆ€^€^€^Ð/Ð/Ð/rcó—h|]}|›d’ŒSrCr r>s r rHrH€rIrcó—h|]}|›d’ŒS)r-r r>s r rHrH„ó€Ð-Ð-Ð-fˆ€\€\€\Ð-Ð-Ð-rcó—h|]}|›d’ŒS)r.r r>s r rHrH…rLrécó—eZdZdS)Ú TokenErrorN©Ú__name__Ú __module__Ú__qualname__r rr rPrPŠó€€€€€€€rrPcó—eZdZdS)ÚStopTokenizingNrQr rr rWrWŒrUrrWcóz—|\}}|\}}td||||t|t|¦«fz¦«dS)Nz%d,%d-%d,%d: %s %s)ÚprintÚtok_nameÚrepr) ÚtyperÚxxx_todo_changemeÚxxx_todo_changeme1ÚlineÚsrowÚscolÚerowÚecols r Ú printtokenrdŽsR€Ø$L€Tˆ4Ø%L€Tˆ4Ý Ð Ø ˆtT˜4¥¨$¤µ°e±´Ð=ñ>ñ?ô?ð?ð?ð?rcóL— t||¦«dS#t$rYdSwxYwrF)Ú tokenize_looprW)ÚreadlineÚ tokeneaters r rr”sD€ðð Ýh Ñ+Ô+Ð+Ð+Ð+øÝð ð ð Øˆˆð øøøsƒ• #¢#có4—t|¦«D]}||ŽŒdSrF)r)rgrhÚ token_infos r rfrf§s3€Ý% hÑ/Ô/ð ð ˆ Øˆ JÐÐÐð ð rcó&—eZdZd„Zd„Zd„Zd„ZdS)ÚUntokenizercó0—g|_d|_d|_dS)Nrr)ÚtokensÚprev_rowÚprev_col)Úselfs r Ú__init__zUntokenizer.__init__s€ØˆŒØˆŒ ØˆŒ ˆ ˆ rcóf—|\}}||jz }|r|j d|z¦«dSdS)Nú )rprnÚappend)rqÚstartÚrowÚcolÚ col_offsets r Úadd_whitespacezUntokenizer.add_whitespace²sJ€Ø‰ˆˆSà˜4œ=Ñ(ˆ Øð 1ØŒK×Ò˜s ZÑ/Ñ0Ô0Ð0Ð0Ð0ð 1ð 1rcóp—|D]š}t|¦«dkr| ||¦«nn|\}}}}}| |¦«|j |¦«|\|_|_|ttfvr|xjdz c_d|_Œ›d |j¦«S)Nérrr#) ÚlenÚcompatrzrnrurorpÚNEWLINEÚNLr)rqÚiterableÚtÚtok_typerrvÚendr_s r rzUntokenizer.untokenize¹s¼€Øð "ð "ˆAÝ1‰vŒv˜Š{ˆ{Ø—’˜A˜xÑ(Ô(Ð(ØØ01Ñ-ˆHe˜U C¨Ø×Ò Ñ&Ô&Ð&ØŒK×Ò˜uÑ%Ô%Ð%Ø+.Ñ(ˆDŒM˜4œ=ØG¥R˜=Ð(Ð(Ø ” Ñ" ” Ø !” øØwŠwt”{Ñ#Ô#Ð#rcóÐ—d}g}|jj}|\}}|ttfvr|dz }|tt fvrd}|D]¦}|dd…\}}|ttttfvr|dz }|tkr| |¦«ŒQ|tkr| ¦«Œq|tt fvrd}n|r|r||d¦«d}||¦«Œ§dS)NFrtTr|éÿÿÿÿ)rnruÚNAMEÚNUMBERrr€ÚASYNCÚAWAITÚINDENTÚDEDENTÚpop) rqrrÚ startlineÚindentsÚtoks_appendÚtoknumÚtokvalÚtoks r r~zUntokenizer.compatÇs€Øˆ ØˆØ”kÔ(ˆØ‰ˆØ•dF^Ð#Ð#Øc‰MˆFØ•gr]Ð"Ð"ØˆIØð ð ˆCØ ! œW‰NˆFFà$¥uÐ5Ð5Ð5Ø˜#‘ àÒÐØ—’˜vÑ&Ô&Ð&ØØ6Ò!Ð!Ø—’‘ ” ØØG¥R˜=Ð(Ð(Ø Øð "˜wð "Ø˜G BœKÑ(Ô(Ð(Ø! ØˆK˜ÑÔÐÐð# ð rN)rRrSrTrrrzrr~r rr rlrl«sP€€€€€ðððð 1ð1ð1ð$ð$ð$ð ð ð ð ð rrlz&^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)s^[ \t\f]*(?:[#\r\n]|$)cóØ— |dd… ¦« dd¦«}|dks| d¦«rdS|dvs| d¦«rdS|S) Nér ú-úutf-8zutf-8-)zlatin-1ú iso-8859-1ziso-latin-1)zlatin-1-ziso-8859-1-ziso-latin-1-r˜)ÚlowerÚreplaceÚ startswith)Úorig_encÚencs r Ú_get_normal_nameržæsw€Ø2à 3B3Œ-× Ò Ñ Ô × 'Ò '¨¨SÑ 1Ô 1€CØ ˆg‚~€~˜Ÿš¨Ñ1Ô1€~ØˆwØ Ð6Ð6Ð6Ø ‡~‚~ÐAÑBÔBð7àˆ|Ø€OrcóN‡‡— dŠd}d}ˆfd„}ˆfd„}|¦«}| t¦«rdŠ|dd…}d}|s|gfS||¦«}|r||gfSt |¦«s||gfS|¦«}|s||gfS||¦«}|r|||gfS|||gfS)NFr—cóV•— ‰¦«S#t$rt¦«cYSwxYwrF)Ú StopIterationÚbytes)rgs€r Úread_or_stopz%detect_encoding..read_or_stops<ø€ð Ø8‘:”:ÐøÝð ð ð Ý‘7”7ˆNˆNˆNð øøøsƒ (§(có|•— | d¦«}n#t$rYdSwxYwt |¦«}|sdSt | d¦«¦«} t |¦«}n #t$rtd|z¦«‚wxYw‰r|j dkrtd¦«‚|dz }|S)NÚasciirzunknown encoding: r—zencoding problem: utf-8z-sig) ÚdecodeÚUnicodeDecodeErrorÚ cookie_reÚmatchržrrÚLookupErrorÚSyntaxErrorÚname)r_Úline_stringr©ÚencodingÚcodecÚ bom_founds €r Úfind_cookiez$detect_encoding..find_cookiesêø€ð ØŸ+š+ gÑ.Ô.ˆKˆKøÝ!ð ð ð Ø44ð øøøå—’ Ñ,Ô,ˆØð Ø4Ý# E§K¢K°¡N¤NÑ3Ô3ˆð ?Ý˜8Ñ$Ô$ˆEˆEøÝð ?ð ?ð ?åÐ2°XÑ=Ñ>Ô>Ð>ð ?øøøðð ØŒz˜WÒ$Ð$å!Ð";Ñ<Ô<Ð<Ø˜ÑˆHØˆsƒ™ '¦'Á+A;Á;BTéz utf-8-sig)r›rÚblank_rer©)rgr®Údefaultr£r±ÚfirstÚsecondr°s` @r Údetect_encodingr·ñs2øø€ðð"€IØ€HØ€Gððððððððððð, ˆL‰NŒN€EØ×ÒÑ!Ô!ðØˆ Øabb” ˆØˆØðØ˜ˆ{Ðàˆ{˜5Ñ!Ô!€HØð!Ø˜%˜Ð Ð Ý>Š>˜%Ñ Ô ð Ø˜˜ÐÐà ˆ\‰^Œ^€FØð Ø˜˜ÐÐàˆ{˜6Ñ"Ô"€HØð)Ø˜% ˜Ð(Ð(àU˜FOÐ#Ð#rcóJ— t¦«}| |¦«SrF)rlr)rÚuts r rr:s$€ðõ" ‰Œ€BØ =Š=˜Ñ"Ô"Ð"rc#ó´K— dx}x}}d\}}d}dg}d}d} d} d} |¦«}n#t$rd}YnwxYw|dz}dt|¦«}} |rµ|std|¦«‚| |¦«}|r>| d¦«x} }t ||d|…z|||f||zfV—d\}}d}nZ|rA|dd…dkr3|d d…d kr%t||z||t|¦«f|fV—d}d}Œá||z}||z}Œì|dkrï|sì|sn d}| |krO|| dkr|dz}n2|| dkr|tzdztz}n|| d krd}nn| dz} | |k°O| |krnª|r|V—d}|| dvrÅ|| dkry|| d… d¦«}| t|¦«z}t||| f|| t|¦«zf|fV—t||d…||f|t|¦«f|fV—n>ttf|| dk|| d…|| f|t|¦«f|fV—Œ0||dkr/| |¦«t|d| …|df|| f|fV—||dkrT||vrtdd|| |f¦«‚|dd…}| r| |dkrd} d}d} td|| f|| f|fV—||dk°T| r|r| |dkrd} d}d} n|std|df¦«‚d}| |krt || ¦«}|r½| d¦«\}}||f||f|} }}|||…||}}|t"jvs|dkr|dkrt&||||fV—n|dvr,t(}|dkrt}n| rd}|r|V—d}|||||fV—nO|dkr|r|V—d}t||||fV—n1|t*vrpt,|}| || ¦«}|r9| d¦«} ||| …}|r|V—d}t |||| f|fV—nÊ||f}||d…}|}n¿|t.vs"|dd…t.vs|dd…t.vrk|ddkrG||f}t,|p%t,|dpt,|d}||d…d}}|}nA|r|V—d}t ||||fV—n"| ¦«r£|dvr| r|dkrt2nt4||||fV—Œt6||||f}|dkr|s|}Œ/|dvrW|rU|dt6krD|ddkr8|dkr d} |d} t2|d|d|d|dfV—d}|r|V—d}|V—nk|dkr|r|V—d}t|||| f|fV—d}nJ|d vr|dz}n |d!vr|dz }|r|V—d}t8||||fV—n t|| || f|| dzf|fV—| dz} | |k°Œ|r|V—d}|dd…D]}td|df|dfdfV—Œt:d|df|dfdfV—dS)"Nr)r#rFrr#zEOF in multi-line stringéþÿÿÿz\ éýÿÿÿz\ rtú úz# ú#z r†z3unindent does not match any outer indentation levelz zEOF in multi-line statementú.Tr|r²ú )ÚasyncÚawaitrÂ)ÚdefÚforrÄéú\z([{z)]})r¡r}rPr©r„ÚSTRINGÚ ERRORTOKENÚtabsizeÚrstripÚCOMMENTr€rur‹ÚIndentationErrorrŒÚ pseudoprogÚspanÚstringÚdigitsrˆrÚ triple_quotedÚendprogsÚ single_quotedÚisidentifierr‰rŠr‡ÚOPÚ ENDMARKER)rgÚlnumÚparenlevÚ continuedÚcontstrÚneedcontÚcontlinerÚstashedÚ async_defÚasync_def_indentÚasync_def_nlr_ÚposÚmaxÚstrstartÚendprogÚendmatchr„ÚcolumnÚ comment_tokenÚnl_posÚpseudomatchrvÚsposÚeposrÚinitialÚnewliner“Úindents r rrOsË èè€ðð#$Ð#€DÐ#ˆ8iØÑ€GˆXØ€HØˆc€Gð€GØ€IØÐØ€Lð}ð Ø8‘:”:ˆDˆDøÝð ð ð ØˆDˆDˆDð øøøàa‰xˆØ•c˜$‘i”iˆSˆàðJ Øð GÝ Ð!;¸XÑFÔFÐFØ—}’} TÑ*Ô*ˆHØð Ø$ŸLšL¨™OœOÐ+cÝ˜w¨¨d¨s¨d¬Ñ3Ø $¨ ¨h¸©oð?ð?ð?ð?à$)Ñ!˜Ø‘Øð ˜d 2 3 3œi¨6Ò1Ð1°d¸2¸3¸3´iÀ8Ò6KÐ6KÝ! 7¨T¡>Ø# dC°©I¬IÐ%6¸ðBðBðBðBàØØà! D™.Ø# d™?Øà ˜Š]‰] 9‰]ØÐ™ØˆFØ˜’))Ø˜”9 Ò#Ð#¨f°q©j V VØ˜#”Y $Ò&Ð&°&½'±/ÀAÑ2EÅwÑ1N¨¨Ø˜#”Y $Ò&Ð&°¨¨ØØ˜A‘gð˜’))ðcŠzˆz™5àð Ø ØàCŒy˜GÐ#Ð#Ø˜”9 Ò#Ð#Ø$(¨¨¨¤J×$5Ò$5°fÑ$=Ô$=MØ ¥3 }Ñ#5Ô#5Ñ5FÝ" MØ #˜;¨¨sµS¸Ñ5GÔ5GÑ/GÐ(HÈ$ðPðPðPðPå˜t F G Gœ}Ø &˜>¨Dµ#°d±)´)Ð+<¸dðDðDðDðDðDõ¥˜=¨¨c¬°cÒ)9Ô:¸DÀÀÀ¼JØ #˜;¨s°4©y¬yÐ(9¸4ðAðAðAðAáà˜ œÒ#Ð#Ø—’˜vÑ&Ô&Ð&Ý˜t D S Dœz¨D°!¨9°t¸S°kÀ4ÐHÐHÐHÐHØ˜7 2œ;Ò&Ð&Ø Ð(Ð(Ý*ØMØ% t¨S°$Ð7ñ9ô9ð9ð" # 2 #œ,àð)Ð!1°W¸R´[Ò!@Ð!@Ø %IØ#(LØ'(Ð$å˜r D¨# ;°°s°¸TÐBÐBÐBÐBð˜7 2œ;Ò&Ð&ðð %˜\ð %Ð.>À'È"Ä+Ò.MÐ.MØ! Ø$Ø#$Ð øðð KÝ Ð!>ÀÀqÀ ÑJÔJÐJØˆIàCŠi‰iÝ$×*Ò*¨4°Ñ5Ô5ˆKØñg Ø(×-Ò-¨aÑ0Ô0‘ sØ#'¨ -°$¸°¸c˜CdØ!% e¨C i¤°$°u´+wàfœmÐ+Ð+Ø˜s’NN u°¢| |Ý! 5¨$°°dÐ;Ð;Ð;Ð;Ñ;Ø Ð&Ð&Ý%GØ !’||Ý"$˜˜Ø"ð,Ø'+˜Øð'Ø%˜ ˜ ˜ Ø"&˜Ø" E¨4°°tÐ<Ð<Ð<Ð<Ñ<à ’^^àð'Ø%˜ ˜ ˜ Ø"&˜Ý" E¨4°°tÐ<Ð<Ð<Ð<Ñ<ØmÐ+Ð+Ý& uœoGØ&Ÿ}š}¨T°3Ñ7Ô7HØðØ&Ÿlšl¨1™oœo˜Ø $ U¨3 Y¤˜Ø"ð+Ø")˜M˜M˜MØ&*˜GÝ% u¨d°T¸3°KÀÐFÐFÐFÐFÑFà$(¨% =˜Ø"& u v v¤,˜Ø#'˜ÙØ¥ Ð-Ð-Ø˜"˜1˜"”I¥Ð.Ð.Ø˜"˜1˜"”I¥Ð.Ð.Ø˜R”y DÒ(Ð(Ø$(¨% =˜Ý#+¨GÔ#4ð$6½ÀÀqÄÔ8Jð$6Ý#+¨E°!¬HÔ#5ð à,0°°°¬L¸! ˜Ø#'˜Ùà"ð+Ø")˜M˜M˜MØ&*˜GÝ% u¨d°D¸$Ð?Ð?Ð?Ð?Ñ?Ø×)Ò)Ñ+Ô+ð,8ØÐ 2Ð2Ð2Ø$ð%Ø,1°WÒ,<Ð,<¥5 5Å%Ø#(¨$°°dð#<ð<ð<ð<á$å ¨¨d°DÐ9CØ Ò'Ð'°Ð'Ø"%˜Ù à Ð.Ð.Ø#ð+Ø$+¨A¤Jµ$Ò$6Ð$6Ø$+¨A¤J°'Ò$9Ð$9à$¨š~˜~Ø,0 Ø3:¸2´;Ð 0å#(¨'°!¬*Ø#*¨1¤:¨w°q¬zØ#*¨1¤:ð#/ð/ð/ð/ð'+˜Gàð'Ø%˜ ˜ ˜ Ø"&˜àIIIIØ ’__àð'Ø%˜ ˜ ˜ Ø"&˜Ý˜u d¨T°3¨K¸Ð>Ð>Ð>Ð>Ø !IIà %Ð'Ð'°H¸q±L¨¨Ø EÐ)Ð)°hÀ±l¨8Øð'Ø%˜ ˜ ˜ Ø"&˜Ý˜u d¨D°$Ð7Ð7Ð7Ð7Ð7å! 4¨¤9Ø #˜;¨¨s°1©u¨ °tð=ð=ð=ð=à˜A‘gðSCŠi‰iñi}ð~ðØˆ ˆ ˆ Øˆà˜!˜"˜"”+ð5ð5ˆÝr˜D !˜9 t¨Q i°Ð4Ð4Ð4Ð4Ð4Ýb˜4 ˜) d¨A Y°Ð 3Ð3Ð3Ð3Ð3Ð3sž )©8·8Ú__main__)RÚ __author__Ú__credits__rÐÚreÚcodecsrrÚlib2to3.pgen2.tokenr#rÚdirÚ__all__r¢Ú NameErrorÚstrrrr r)Ú WhitespaceÚCommentÚIgnoreÚNameÚ BinnumberÚ HexnumberÚ OctnumberÚ DecnumberÚ IntnumberÚExponentÚ PointfloatÚExpfloatÚFloatnumberÚ ImagnumberÚNumberÚSingleÚDoubleÚSingle3ÚDouble3Ú _litprefixÚTripleÚStringÚOperatorÚBracketÚSpecialÚFunnyÚ PlainTokenÚTokenÚContStrÚPseudoExtrasÚPseudoTokenÚmapÚcompileÚ tokenprogrÎr=rDÚ_strprefixesrÓrÒrÔrÊÚ ExceptionrPrWrdrrfrlÚASCIIr¨r³ržr·rrrRÚsysr}ÚargvÚopenrgÚstdinr rr úr#sòðð#ð0*€ àFððÐÐÐÐÐÐÐØ#Ð#Ð#Ð#Ð#Ð#Ð#Ð#Ø!Ð!Ð!Ð!àÐÐÐÐÐØ 0Ð 0cc˜%‘j”jÐ 0Ñ 0Ô 0ð4,ð4,ð4,ñ,€à ðØ €E€EøØðððð €E€E€Eðøøøð :Ð9Ð9Ø/Ð/Ð/Ø1Ð1Ð1ðððð € Ø €Ø cc˜* zÑ1Ñ2Ô2Ñ 2°U°U¸7±^´^Ñ C€Ø €à&€ Ø7€ Ø.€ ØˆEÐ+¨XÑ6Ô6€ ØˆE)˜Y¨ °9Ñ=Ô=€ Ø#€Ø ˆUÐ5Ð7HÑ IÔ IÈEÈEÐRZÉOÌOÑ [€ Ø˜XÑ%€ØˆeJ Ñ)Ô)€Ø ˆUÐ&¨°gÑ(=Ñ >Ô >€ Ø ˆˆz˜;¨ Ñ 2Ô 2€ð $€à #€à 2€à 2€Ø 7€ Ø ˆˆz˜EÑ! :°Ñ#5Ñ 6Ô 6€à ˆˆzÐ;Ñ;ØÐ;Ñ;ñ =ô =€ðˆ5˜G W¨e°UØ˜%Ø%Øñô€ð €Ø ˆ%˜% Ñ -Ô -€Ø ˆˆh˜ Ñ)Ô)€à ˆU6˜5 &¨$Ñ /Ô /€ ØÑ€ðˆ% Ð;Ñ;Øc˜:Ñ&Ô&ñ'àÐ;Ñ;Øc˜:Ñ&Ô&ñ'ñ(ô(€ðˆuZ ¨&Ñ1Ô1€Ø˜5˜5 ¨v°u¸gÀtÑLÔLÑL€à25°#Ø„J˜ W¨gÐ6ñ38ô38Ñ/€ ˆ:{ Kð€M#s˜C Ñ%Ô%Ø€M#s˜C Ñ%Ô%ñ&à&Ð&Ð&ñ'ð ð”˜FÑ#Ô#¨*¨"¬*°VÑ*<Ô*<Ø {ð9ð9àFÐF¸ÐFÑFÔFð9ðGÐF¸ÐFÑFÔFð9ð8Ð7¨,Ð7Ñ7Ô7ð 9€ðˆE€NØ/Ð/ ,Ð/Ñ/Ô/ñ0à/Ð/ ,Ð/Ñ/Ô/ñ0ðð ˆ#€JØ-Ð- Ð-Ñ-Ô-ñ.à-Ð- Ð-Ñ-Ô-ñ.ðð€à!Ð!Ð!Ð!Ð!Ñ!Ô!Ð!à%Ð%Ð%Ð%Ð%YÑ%Ô%Ð%ð?ð?ð?ð#-ð ð ð ð ð& ð ð ð6 ð6 ð6 ð6 ð6 ñ6 ô6 ð6 ðp ˆBŒJÐ@À"Ä(ÑKÔK€ Øˆ2Œ:Ð0°"´(Ñ;Ô;€ð ð ð ðG$ðG$ðG$ðR#ð#ð#ð*`4ð`4ð`4ðDˆzÒÐØ€J€J€JØ €sˆ3Œ8}„}qÒÐ˜(˜( 4 4¨¬°¬Ñ#4Ô#4Ô#=Ñ>Ô>Ð>Ð>Ð>Ø ˆ(3”9Ô%Ñ &Ô &Ð &Ð &Ð &ðÐs¼?¿A ÁA PKhP3]ªýF;` ` *__pycache__/literals.cpython-311.opt-2.pycnu„[µü¤§ àÀfcãó`— ddlZdddddddd d ddœ Zd „Zd„Zd„Zedkre¦«dSdS)éNúúúú ú ú úú'ú"ú\) ÚaÚbÚfÚnÚrÚtÚvr rrcóâ—| dd¦«\}}t |¦«}||S| d¦«rb|dd…}t |¦«dkrtd|z¦«‚ t |d¦«}nT#t $rtd|z¦«d‚wxYw t |d¦«}n!#t $rtd|z¦«d‚wxYwt|¦«S) NréÚxéz!invalid hex string escape ('\%s')ééz#invalid octal string escape ('\%s'))ÚgroupÚsimple_escapesÚgetÚ startswithÚlenÚ ValueErrorÚintÚchr)ÚmÚallÚtailÚescÚhexesÚis ú=/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/literals.pyÚescaper)s€Ø—’˜˜1‘ ” I€Cˆå × Ò ˜TÑ "Ô "€CØ €Øˆ Ø‡‚sÑÔðVØQRR”ˆÝˆu‰:Œ:˜Š>ˆ>ÝÐAÀDÑHÑIÔIÐIð TÝE˜2‘”ˆAˆAøÝð Tð Tð TÝÐAÀDÑHÑIÔIÈtÐSð Tøøøð VÝD˜!‘”ˆAˆAøÝð Vð Vð VÝÐCÀdÑJÑKÔKÐQUÐUð Vøøøåˆq‰6Œ6€MsÁ=BÂB,Â0CÃCcó¾—|d}|dd…|dzkr|dz}|t|¦«t|¦«…}tjdt|¦«S)Nréz)\\(\'|\"|\\|[abfnrtv]|x.{0,2}|[0-7]{1,3}))rÚreÚsubr))ÚsÚqs r(Ú evalStringr0(s\€à ˆ!Œ€AØˆˆ!ˆ„u!‘‚|€|Ø ˆa‰Cˆð #ˆa‰&Œ&•#a‘&”&ˆ.Ô€AÝ Œ6Ð>ÅÈÑJÔJÐJócó´—td¦«D]G}t|¦«}t|¦«}t|¦«}||krt ||||¦«ŒHdS)Né)Úranger!Úreprr0Úprint)r'Úcr.Úes r(Útestr92s`€Ý 3‰ZŒZððˆÝ‰FŒFˆÝ‰GŒGˆÝq‰MŒMˆØŠ6ˆ6Ý!Q˜˜1ÑÔÐøððr1Ú__main__)r,rr)r0r9Ú__name__©r1r(úr=s’ððCà € € € àØØØØØØØØØð ð €ðððð*KðKðKððððˆzÒÐØ€DF„F€F€F€FðÐr1PKhP3]H;±Ë¨¨*__pycache__/__init__.cpython-311.opt-2.pycnu„[µü¤§ àÀfãó—dS)N©róú=/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/__init__.pyúrs ððÐrPKhP3].•íËÍ3Í3 __pycache__/conv.cpython-311.pycnu„[µü¤§ àÀfª%ãóH—dZddlZddlmZmZGd„dej¦«ZdS)aýConvert graminit.[ch] spit out by pgen to Python code. Pgen is the Python parser generator. It is useful to quickly create a parser from a grammar file in Python's grammar notation. But I don't want my parsers to be written in C (yet), so I'm translating the parsing tables to Python data structures and writing a Python parse engine. Note that the token numbers are constants determined by the standard Python tokenizer. The standard token module defines these numbers and their names (the names are not used much). The token numbers are hardcoded into the Python tokenizer and into pgen. A Python implementation of the Python tokenizer is also available, in the standard tokenize module. On the other hand, symbol numbers (representing the grammar's non-terminals) are assigned by pgen based on the actual grammar input. Note: this module is pretty much obsolete; the pgen module generates equivalent grammar tables directly from the Grammar.txt input file without having to invoke the Python pgen C program. éN)ÚgrammarÚtokencó*—eZdZdZd„Zd„Zd„Zd„ZdS)Ú Convertera2Grammar subclass that reads classic pgen output files. The run() method reads the tables as produced by the pgen parser generator, typically contained in two C files, graminit.h and graminit.c. The other methods are for internal use only. See the base class for more documentation. có‚—| |¦«| |¦«| ¦«dS)z| ¦«r*t|›d|›d | ¦«›¦«Œ\| ¦«\}}t|¦«}||jvsJ‚||jvsJ‚||j|<||j|<Œd S)zðParse the .h file written by pgen. (Internal) This file is a sequence of #define statements defining the nonterminals of the grammar as numbers. We build two tables mapping the numbers to names and back. úCan't open ú: NFréz^#define\s+(\w+)\s+(\d+)$ú(z): can't parse T) ÚopenÚOSErrorÚprintÚ symbol2numberÚ number2symbolÚreÚmatchÚstripÚgroupsÚint) rÚfilenameÚfÚerrÚlinenoÚlineÚmoÚsymbolÚnumbers rrzConverter.parse_graminit_h5sU€ð ÝX‘”ˆAˆAøÝð ð ð ÝˆE¨¨¨°3°3Ð7Ñ8Ô8Ð8Ø55555øøøøð øøøð ˆÔØˆÔØˆØð 4ð 4ˆDØa‰KˆFÝ”Ð6¸Ñ=Ô=ˆBØð 4˜$Ÿ*š*™,œ,ð 4Ý°(°(°(¸F¸F¸FØ26·*²*±,´,°,ð@ñAôAðAðAð"$§¢¡¤‘˜Ý˜V™œØ TÔ%7Ð7Ð7Ð7Ð7Ø TÔ%7Ð7Ð7Ð7Ð7Ø-3Ô" 6Ñ*Ø-3Ô" 6Ñ*Ð*Øˆts‚’ <œ7·_[] = { {, }, ... }; - followed by a state array, of the form: static state states_[] = { {, arcs__}, ... }; rrNFrrz#include "pgenheaders.h" z#include "grammar.h" zstatic arc z)static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$z\s+{(\d+), (\d+)},$z}; z'static state states_(\d+)\[(\d+)\] = {$z\s+{(\d+), arcs_(\d+)_(\d+)},$zstatic dfa dfas\[(\d+)\] = {$z0\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$ééééz\s+("(?:\\\d\d\d)*")},$éz!static label labels\[(\d+)\] = {$z\s+{(\d+), (0|"\w+")},$Ú0zgrammar _PyParser_Grammar = { z \s+(\d+),$z dfas, z\s+{(\d+), labels},$z \s+(\d+)$)rrrÚnextÚ startswithrrÚlistÚmaprrÚrangeÚappendÚlenÚstatesÚgrouprrÚevalÚ enumerateÚordÚdfasÚlabelsÚstartÚ StopIteration)!rr r!r"r#r$Úallarcsr6r%ÚnÚmÚkÚarcsÚ_ÚiÚjÚsÚtÚstater;Úndfasr&r'ÚxÚyÚzÚfirstÚ rawbitsetÚcÚbyter<Únlabelsr=s! rr zConverter.parse_graminit_cTs³ €ð8 ÝX‘”ˆAˆAøÝð ð ð ÝˆE¨¨¨°3°3Ð7Ñ8Ô8Ð8Ø55555øøøøð øøøðˆð˜a‘x¥ a¡¤ˆØÐ3Ò3Ð3Ð3°f¸d°^Ñ3Ô3Ð3Ø˜a‘x¥ a¡¤ˆØÐ/Ò/Ð/Ð/°&¸$°Ñ/Ô/Ð/ð˜a‘x¥ a¡¤ˆØˆØˆØoŠo˜mÑ,Ô,ñ! -Ø—/’/ -Ñ0Ô0ñ 1Ý”XÐJØ"ñ$ô$àÐ)Ð)˜F D˜>Ñ)Ô)rÝs¥3¨¯ ª ©¬Ñ4Ô4Ñ5Ô5‘1aØÝ˜q™œð(ð(AØ#)¨!¡8T°!©W¬W˜DFÝœÐ"8¸$Ñ?Ô?BØÐ-Ð- ¨˜~Ñ-Ô-˜2Ý¥¥C¨¯ª©¬Ñ 5Ô 5Ñ6Ô6‘DAqØ—K’K A Ñ'Ô'Ð'Ð'Ø% a™x¨a©¬˜Ø˜v’~~~¨° ~‘~”~~Ø"&˜˜A˜‘Ø% a™x¨a©¬˜ð—/’/ -Ñ0Ô0ñ 1õ ”ÐDÀdÑKÔKˆBØÐ%Ð%˜ ~Ñ%Ô%2ÝC §¢¡¤Ñ-Ô-Ñ.Ô.‰DˆAˆqØ˜F™œÒ#Ð#Ð# f¨d ^Ñ#Ô#Ð#ØˆEÝ˜1‘X”Xð #ð #Ø% a™x¨a©¬˜Ý”XÐ?ÀÑFÔFØÐ)Ð)˜F D˜>Ñ)Ô)rÝs¥3¨¯ ª ©¬Ñ4Ô4Ñ5Ô5‘1aØ˜q !˜t”}ØC ™IœI’~~~¨° ~‘~”~~Ø—’˜TÑ"Ô"Ð"Ð"ØMŠM˜%Ñ Ô Ð Ø! !™8¥T¨!¡W¤WDˆFØ˜6’>>> F¨D >‘>”>>Ø! !™8¥T¨!¡W¤WDˆFðCoŠo˜mÑ,Ô,ñ! -ðDˆŒðˆÝ ŒXÐ6¸Ñ =Ô =ˆØÐ!Ð!F˜D>Ñ!Ô!ˆrÝB—H’H˜Q‘K”KÑ Ô ˆÝu‘”ð *ñ *ˆAØ! !™8¥T¨!¡W¤WDˆFÝ”ÐMØñ ô ˆBàÐ%Ð%˜ ~Ñ%Ô%2Ø—X’X˜a‘[”[ˆFÝ"¥3¥s¨B¯HªH°Q¸¸1¸aÑ,@Ô,@Ñ#AÔ#AÑBÔB‰OˆFAq˜!ØÔ% fÔ-°Ò7Ð7Ð7¸&À$¸Ñ7Ô7Ð7ØÔ% fÔ-°Ò7Ð7Ð7¸&À$¸Ñ7Ô7Ð7Ø˜’666˜F D˜>‘6”66Ø˜1”IˆEØ˜E™ œ ’??? V¨T N‘?”??Ø! !™8¥T¨!¡W¤WDˆFÝ”Ð4°dÑ;Ô;ˆBØÐ%Ð%˜ ~Ñ%Ô%2ØˆEÝ˜RŸXšX a™[œ[Ñ)Ô)ˆIÝ! )Ñ,Ô,ð +ð +‘1Ý˜1‘v”vÝ˜q™œð+ð+AØ˜q !™t‘}ð+Ø)*˜˜a ™c A™g™øð+ð" 5˜>ˆD‰L‰LØ˜a‘x¥ a¡¤ˆØvŠ~ˆ~ˆ~ ¨˜~‰~Œ~ˆ~ØˆŒ ðˆØ˜a‘x¥ a¡¤ˆÝ ŒXÐ:¸DÑ AÔ AˆØÐ!Ð!F˜D>Ñ!Ô!ˆrÝb—h’h˜q‘k”kÑ"Ô"ˆÝw‘”ð "ð "ˆAØ! !™8¥T¨!¡W¤WDˆFÝ”Ð4°dÑ;Ô;ˆBØÐ%Ð%˜ ~Ñ%Ô%2Ø—9’9‘;”;‰DˆAˆqÝA‘”ˆAØCŠxˆxØå˜‘G”GØMŠM˜1˜a˜&Ñ!Ô!Ð!Ð!Ø˜a‘x¥ a¡¤ˆØvŠ~ˆ~ˆ~ ¨˜~‰~Œ~ˆ~ØˆŒð˜a‘x¥ a¡¤ˆØÐ8Ò8Ð8Ð8¸6À4¸.Ñ8Ô8Ð8Ø˜a‘x¥ a¡¤ˆÝ ŒXm TÑ *Ô *ˆØÐ!Ð!F˜D>Ñ!Ô!ˆrÝB—H’H˜Q‘K”KÑ Ô ˆØ˜DœI™œÒ&Ð&Ð&Ð&Ø˜a‘x¥ a¡¤ˆØ{Ò"Ð"Ð" V¨T NÑ"Ô"Ð"Ø˜a‘x¥ a¡¤ˆÝ ŒXÐ-¨tÑ 4Ô 4ˆØÐ!Ð!F˜D>Ñ!Ô!ˆrÝb—h’h˜q‘k”kÑ"Ô"ˆØ#˜dœkÑ*Ô*Ò*Ð*Ð*¨V°T¨NÑ*Ô*Ð*Ø˜a‘x¥ a¡¤ˆÝ ŒXl DÑ )Ô )ˆØÐ!Ð!F˜D>Ñ!Ô!ˆrÝB—H’H˜Q‘K”KÑ Ô ˆØ˜Ô*Ð*Ð*Ð*¨V°T¨NÑ*Ô*Ð*ØˆŒ Ø˜a‘x¥ a¡¤ˆØvŠ~ˆ~ˆ~ ¨˜~‰~Œ~ˆ~ð %Ø! !™8¥T¨!¡W¤WDˆFð %v˜tnÑ$Ô$1øõð ð ð ØˆDˆDð øøøs"‚’ <œ7·<ã/dä dädcó®—i|_i|_t|j¦«D]1\}\}}|tjkr |||j|<Œ%|€ ||j|<Œ2dS)z1Create additional useful structures. (Internal).N)ÚkeywordsÚtokensr9r<rÚNAME)rÚilabelÚtypeÚvalues rr zConverter.finish_offùso€àˆŒ ØˆŒÝ%.¨t¬{Ñ%;Ô%;ð +ð +Ñ!ˆF‘MT˜5Ø•u”zÒ!Ð! eÐ&7Ø'-” ˜eÑ$Ð$ØØ$*”˜DÑ!øð +ð +rN)Ú__name__Ú __module__Ú__qualname__Ú__doc__rrr r ©rrrr$s^€€€€€ððððððððð>c%ðc%ðc%ðJ+ð+ð+ð+ð+rr)r]rÚpgen2rrÚGrammarrr^rrúrastðððð4 € € € ð!Ð Ð Ð Ð Ð Ð Ð ð]+ð]+ð]+ð]+ð]+”ñ]+ô]+ð]+ð]+ð]+rPKhP3]»Ñ’kJkJ&__pycache__/pgen.cpython-311.opt-2.pycnu„[µü¤§ àÀf6ãóœ—ddlmZmZmZGd„dej¦«ZGd„de¦«ZGd„de¦«ZGd„d e¦«Z d d„Z dS)é)ÚgrammarÚtokenÚtokenizecó—eZdZdS)ÚPgenGrammarN)Ú__name__Ú __module__Ú__qualname__©óú9/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/pgen.pyrrs€€€€€Ø€Drrcó~—eZdZdd„Zd„Zd„Zd„Zd„Zd„Zd„Z d „Z d „Zd„Zd„Z d „Zd„Zd„Zd„Zdd„Zd„Zd„ZdS)ÚParserGeneratorNcóN—d}|€t|d¬¦«}|j}||_||_t j|j¦«|_| ¦«| ¦«\|_ |_| |¦«i|_| ¦«dS)Nzutf-8)Úencoding)ÚopenÚcloseÚfilenameÚstreamrÚgenerate_tokensÚreadlineÚ generatorÚgettokenÚparseÚdfasÚstartsymbolÚfirstÚaddfirstsets)ÚselfrrÚclose_streams r Ú__init__zParserGenerator.__init__s›€ØˆØˆ>Ý˜(¨WÐ5Ñ5Ô5ˆFØ!œ<ˆLØ ˆŒ ØˆŒÝ!Ô1°&´/ÑBÔBˆŒØ Š ‰ŒˆØ&*§j¢j¡l¤lÑ#ˆŒ 4Ô#ØÐ#ØˆL‰NŒNˆNØˆŒ Ø×ÒÑÔÐÐÐrc ó²—t¦«}t|j ¦«¦«}| ¦«| |j¦«| d|j¦«|D]-}dt|j ¦«z}||j |<||j |<Œ.|D]}|j|}g}|D]´}g}t|j ¦«¦«D]C\} } | | || ¦«| | ¦«f¦«ŒD|jr*| d| |¦«f¦«| |¦«Œµ|j |¦«|| ||¦«f|j|j |<Œ|j |j|_|S)Néé)rÚlistrÚkeysÚsortÚremoverÚinsertÚlenÚ symbol2numberÚ number2symbolÚsortedÚarcsÚitemsÚappendÚ make_labelÚindexÚisfinalÚstatesÚ make_firstÚstart)rÚcÚnamesÚnameÚiÚdfar4Ústater.ÚlabelÚnexts r Úmake_grammarzParserGenerator.make_grammarsÂ€Ý‰MŒMˆÝT”Y—^’^Ñ%Ô%Ñ&Ô&ˆØ Š ‰ŒˆØ ŠTÔ%Ñ&Ô&Ð&Ø ŠQ˜Ô(Ñ)Ô)Ð)Øð &ð &ˆDØ•c˜!œ/Ñ*Ô*Ñ*ˆAØ$%ˆAŒO˜DÑ!Ø!%ˆAŒO˜AÑÐØð Oñ OˆDØ”)˜D”/ˆCØˆFØð $ð $ØÝ#)¨%¬*×*:Ò*:Ñ*<Ô*<Ñ#=Ô#=ðNðN‘KE˜4Ø—K’K §¢°°EÑ!:Ô!:¸C¿IºIÀd¹O¼OÐ LÑMÔMÐMÐMØ”=ð7Ø—K’K C§I¢I¨eÑ$4Ô$4Ð 5Ñ6Ô6Ð6Ø— ’ ˜dÑ#Ô#Ð#Ð#Ø ŒHOŠO˜FÑ#Ô#Ð#Ø-3°T·_²_ÀQÈÑ5MÔ5MÐ,NˆAŒF1”? 4Ô(Ñ)Ñ)Ø”/ $Ô"2Ô3ˆŒØˆrcó~—|j|}i}t|¦«D]}| ||¦«}d||<Œ|S©Nr)rr-r1)rr7r9Úrawfirstrr=Úilabels r r5zParserGenerator.make_first4sM€Ø”:˜dÔ#ˆØˆÝ˜HÑ%Ô%ð ð ˆEØ—_’_ Q¨Ñ.Ô.ˆFàˆE&‰MˆMØˆrcó,—t|j¦«}|d ¦«r¦||jvrI||jvr |j|S|j |j|df¦«||j|<|St t|d¦«}||jvr |j|S|j |df¦«||j|<|St|¦«}|d ¦«rH||j vr |j |S|j tj|f¦«||j |<|Stj |}||jvr |j|S|j |df¦«||j|<|S©Nr#)r*ÚlabelsÚisalphar+Úsymbol2labelr0ÚgetattrrÚtokensÚevalÚkeywordsÚNAMErÚopmap)rr7r=rCÚitokenÚvalues r r1zParserGenerator.make_label=s“€åQ”X‘”ˆØŒ8×ÒÑÔð) "à˜œÐ'Ð'à˜AœNÐ*Ð*Øœ>¨%Ô0Ð0à”H—O’O Q¤_°UÔ%;¸TÐ$BÑCÔCÐCØ,2A”N 5Ñ)Ø!Mõ!¥¨¨tÑ4Ô4ð˜QœXÐ%Ð%Øœ8 FÔ+Ð+à”H—O’O V¨T NÑ3Ô3Ð3Ø'-A”H˜VÑ$Ø!Mõ˜‘K”KˆEØQŒx×ÒÑ!Ô!ð "à˜AœJÐ&Ð&Øœ: eÔ,Ð,à”H—O’O¥U¤Z°Ð$7Ñ8Ô8Ð8Ø(.A”J˜uÑ%Ø!Mõ!œ uÔ-Ø˜QœXÐ%Ð%Øœ8 FÔ+Ð+à”H—O’O V¨T NÑ3Ô3Ð3Ø'-A”H˜VÑ$Ø!MrcóÀ—t|j ¦«¦«}| ¦«|D] }||jvr| |¦«Œ!dS©N)r%rr&r'rÚ calcfirst)rr8r9s r rzParserGenerator.addfirstsetsksa€ÝT”Y—^’^Ñ%Ô%Ñ&Ô&ˆØ Š ‰ŒˆØð %ð %ˆDØ˜4œ:Ð%Ð%Ø—’˜tÑ$Ô$Ð$øð %ð %rc ó.—|j|}d|j|<|d}i}i}|j ¦«D]‚\}}||jvrh||jvr"|j|}|€t d|z¦«‚n"| |¦«|j|}| |¦«|||<Œvd||<|di||<Œƒi} | ¦«D]4\}} | D],}|| vr!t d|›d|›d|›d| |›¦«‚|| |<Œ-Œ5||j|<dS)Nr#zrecursion for rule %rrzrule z is ambiguous; z is in the first sets of z as well as )rrr.r/Ú ValueErrorrSÚupdate)rr9r;r<ÚtotalsetÚoverlapcheckr=r>ÚfsetÚinverseÚitsfirstÚsymbols r rSzParserGenerator.calcfirstss†€ØŒi˜ŒoˆØˆŒ 4ÑØA”ˆØˆØˆØ œ:×+Ò+Ñ-Ô-ð 1ð 1‰KˆE4Ø˜œ Ð!Ð!Ø˜DœJÐ&Ð&Øœ: eÔ,DØ|Ý(Ð)@À4Ñ)GÑHÔHÐHð$ð—N’N 5Ñ)Ô)Ð)Øœ: eÔ,DØ—’ Ñ%Ô%Ð%Ø&*˜UÑ#Ð#à"#˜‘Ø',¨a j˜UÑ#Ð#ØˆØ+×1Ò1Ñ3Ô3ð (ð (‰OˆE8Ø"ð (ð (Ø˜WÐ$Ð$Ý$˜*à&* d d¨F¨F¨F°E°E°E¸7À6¼?¸?ð&LñMôMðMð#(˜‘ð (ð$ˆŒ 4ÑÐÐrcót—i}d}|jtjkr|jtjkr)| ¦«|jtjk°)| tj¦«}| tjd¦«| ¦«\}}| tj¦«| ||¦«}t|¦«}| |¦«t|¦«}|||<|€|}|jtjk°||fS)Nú:)ÚtyperÚ ENDMARKERÚNEWLINErÚexpectrMÚOPÚ parse_rhsÚmake_dfar*Úsimplify_dfa) rrrr9ÚaÚzr;ÚoldlenÚnewlens r rzParserGenerator.parse‘s €ØˆØˆàŒi5œ?Ò*Ñ*Ø”)uœ}Ò,Ð,Ø— ’ ‘”ð”)uœ}Ò,Ð,ð—;’;uœzÑ*Ô*ˆDØKŠKœ #Ñ&Ô&Ð&Ø—>’>Ñ#Ô#‰DˆAˆqØKŠKœ Ñ&Ô&Ð&à—-’- 1Ñ%Ô%ˆCå˜‘X”XˆFØ×Ò˜cÑ"Ô"Ð"Ý˜‘X”XˆFØˆD‰JàÐ"Ø"ð#Œi5œ?Ò*Ñ*ð$[Ð Ð rc ó¸‡—ˆfd„}ˆfd„Št||¦«|¦«g}|D]±}i}|jD]1}|jD]'\}} | ‰| | |i¦«¦«Œ(Œ2t | ¦«¦«D]R\}} |D]}|j| krn&Œt| |¦«}| |¦«| ||¦«ŒSŒ²|S)Ncó$•—i}‰||¦«|SrRr)r<ÚbaseÚ addclosures €r Úclosurez)ParserGenerator.make_dfa..closure°sø€ØˆDØˆJu˜dÑ#Ô#Ð#ØˆKrcóT•—||vrdSd||<|jD]\}}|€‰||¦«ŒdSrA©r.)r<rmr=r>rns €r rnz,ParserGenerator.make_dfa..addclosure´sQø€à˜ˆ}ˆ}ØØˆD‰KØ$œzð +ð +‘tØ=ØJ˜t TÑ*Ô*Ð*øð +ð +r)ÚDFAStateÚnfasetr.Ú setdefaultr-r/r0Úaddarc) rr6Úfinishror4r<r.Únfastater=r>rsÚstrns @r rezParserGenerator.make_dfa©sMø€ð ð ð ð ð ð +ð +ð +ð +ð +õ˜7˜7 5™>œ>¨6Ñ2Ô2Ð3ˆØð (ð (ˆEØˆDØ!œLð Eð EØ#+¤=ðEðE‘KE˜4ØÐ(Ø"˜ 4¨¯ª¸ÀÑ)CÔ)CÑDÔDÐDøðEõ"(¨¯ ª ©¬Ñ!5Ô!5ð (ð (‘ vØ ð&ð&BØ”y FÒ*Ð*Ø˜ð+õ" &¨&Ñ1Ô1BØ—M’M "Ñ%Ô%Ð%Ø—’˜R Ñ'Ô'Ð'Ð'ð (ðˆ rcól—td|¦«|g}t|¦«D]\}}td|||urdpd¦«|jD]l\}}||vr| |¦«} n$t |¦«} | |¦«|€td| z¦«ŒXtd|| fz¦«ŒmŒ‘dS)NzDump of NFA forú Stateú(final)Úz -> %dú %s -> %d)ÚprintÚ enumerater.r2r*r0) rr9r6rvÚtodor:r<r=r>Újs r Údump_nfazParserGenerator.dump_nfaÍsä€Ý Ð Ñ&Ô&Ð&ØˆwˆÝ! $™œð 7ð 7‰HˆAˆuÝ)˜Q ¨ Ð =°IÐ CÀÑDÔDÐDØ$œzð 7ð 7‘tØ˜4<<ØŸ š 4Ñ(Ô(AAå˜D™ œ AØ—K’K Ñ%Ô%Ð%Ø=Ý˜+¨™/Ñ*Ô*Ð*Ð*å˜.¨E°1¨:Ñ5Ñ6Ô6Ð6Ð6ð 7ð 7ð 7rc ó*—td|¦«t|¦«D]r\}}td||jrdpd¦«t|j ¦«¦«D],\}}td|| |¦«fz¦«Œ-ŒsdS)NzDump of DFA forrzr{r|r})r~rr3r-r.r/r2)rr9r;r:r<r=r>s r Údump_dfazParserGenerator.dump_dfaÝs®€Ý Ð Ñ&Ô&Ð&Ý! #™œð Að A‰HˆAˆuÝ)˜Q ¤ Ð ;°)Ð A¸rÑBÔBÐBÝ% e¤j×&6Ò&6Ñ&8Ô&8Ñ9Ô9ð Að A‘tÝn¨¨s¯yªy¸©¬Ð'?Ñ?Ñ@Ô@Ð@Ð@ð Að Að Arcóê—d}|rnd}t|¦«D]X\}}t|dzt|¦«¦«D]2}||}||kr"||=|D]}| ||¦«Œd}nŒ3ŒY|°ldSdS)NTFr)rÚranger*Ú unifystate)rr;Úchangesr:Ústate_irÚstate_jr<s r rfzParserGenerator.simplify_dfaäsÃ€ðˆØð ØˆGÝ'¨™nœnð ð ‘ 7Ý˜q ™s¥C¨¡H¤HÑ-Ô-ððAØ! !œfGØ 'Ò)Ð)à ˜FØ%(ð?ð?˜EØ!×,Ò,¨W°gÑ>Ô>Ð>Ð>Ø"&˜Ø˜ð *øðð ð ð ð ð rcó¸—| ¦«\}}|jdkr||fSt¦«}t¦«}| |¦«| |¦«|jdkr`| ¦«| ¦«\}}| |¦«| |¦«|jdk°`||fS)Nú|)Ú parse_altrPÚNFAStaterur)rrgrhÚaaÚzzs r rdzParserGenerator.parse_rhsùsÀ€à~Š~ÑÔ‰ˆˆ1ØŒ:˜ÒÐØa4ˆKå‘”ˆBÝ‘”ˆBØIŠIa‰LŒLˆLØ HŠHR‰LŒLˆLØ”* Ò#Ð#Ø— ’ ‘”Ø—~’~Ñ'Ô'‘1Ø— ’ ˜!‘”Ø—’˜‘”ð ”* Ò#Ð#ð r6ˆMrcó4—| ¦«\}}|jdvs|jtjtjfvrV| ¦«\}}| |¦«|}|jdv°7|jtjtjfv°V||fS)N)ú(ú[)Ú parse_itemrPr_rrMÚSTRINGru)rrgÚbr7Úds r rzParserGenerator.parse_alt s€àŠÑ Ô ‰ˆˆ1ØŒz˜ZÐ'Ð'ØŒyUœZ¬Ð6Ð6Ð6Ø—?’?Ñ$Ô$‰DˆAˆqØ HŠHQ‰KŒKˆKØˆAð Œz˜ZÐ'Ð'ØŒyUœZ¬Ð6Ð6Ð6ð!ˆtˆrcóš—|jdkrd| ¦«| ¦«\}}| tjd¦«| |¦«||fS| ¦«\}}|j}|dvr||fS| ¦«| |¦«|dkr||fS||fS)Nr“ú])ú+Ú*rš)rPrrdrbrrcruÚ parse_atom)rrgrhrPs r r”zParserGenerator.parse_itemsÂ€àŒ:˜ÒÐØMŠM‰OŒOˆOØ—>’>Ñ#Ô#‰DˆAˆqØKŠKœ #Ñ&Ô&Ð&Ø HŠHQ‰KŒKˆKØa4ˆKà—?’?Ñ$Ô$‰DˆAˆqØ”JˆEØ˜JÐ&Ð&Ø˜!tØMŠM‰OŒOˆOØ HŠHQ‰KŒKˆKØ˜Š|ˆ|Ø˜!tà˜!trcóØ—|jdkrO| ¦«| ¦«\}}| tjd¦«||fS|jtjtjfvrOt¦«}t¦«}| ||j¦«| ¦«||fS| d|j|j¦«dS)Nr’ú)z+expected (...) or NAME or STRING, got %s/%s)rPrrdrbrrcr_rMr•rŽruÚraise_error)rrgrhs r rœzParserGenerator.parse_atom(sÐ€àŒ:˜ÒÐØMŠM‰OŒOˆOØ—>’>Ñ#Ô#‰DˆAˆqØKŠKœ #Ñ&Ô&Ð&Øa4ˆKØ ŒY5œ:¥u¤|Ð4Ð 4Ð 4Ý‘ ” ˆAÝ‘ ” ˆAØ HŠHQ˜œ Ñ#Ô#Ð#ØMŠM‰OŒOˆOØa4ˆKà×ÒÐJØ!œY¨¬ ñ 4ô 4ð 4ð 4ð 4rcó²—|j|ks |.|j|kr#| d|||j|j¦«|j}| ¦«|S)Nzexpected %s/%s, got %s/%s)r_rPrŸr)rr_rPs r rbzParserGenerator.expect9sd€ØŒ9˜ÒÐ Ð!2°t´zÀUÒ7JÐ7JØ×ÒÐ8Ø! 5¨$¬)°T´Zñ Aô Að Aà” ˆØ Š ‰ŒˆØˆrcó—t|j¦«}|dtjtjfvr4t|j¦«}|dtjtjfv°4|\|_|_|_|_|_ dSrE) r>rrÚCOMMENTÚNLr_rPÚbeginÚendÚline)rÚtups r rzParserGenerator.gettokenAsr€Ý4”>Ñ"Ô"ˆØ!ŒfÔ)8¬;Ð7Ð7Ð7Ýt”~Ñ&Ô&ˆCð!ŒfÔ)8¬;Ð7Ð7Ð7àADÑ>ˆŒ 4”:˜tœz¨4¬8°T´Y°Y°Yrc óü—|rG ||z}n@#d |gttt|¦«¦«z¦«}YnxYwt ||j|jd|jd|jf¦«‚)Nú r#r)Újoinr%ÚmapÚstrÚSyntaxErrorrr¥r¦)rÚmsgÚargss r rŸzParserGenerator.raise_errorHs€Øð =ð =Ø˜D‘jøð =Ø—h’h ˜u¥tCµ°T©N¬NÑ';Ô';Ñ;Ñ<Ô<øøøÝ˜# ¤ ¨t¬x¸¬{Ø $¤¨¤¨T¬Yð 8ñ9ô9ð 9s „ Š;ArR)rr r r!r?r5r1rrSrrer‚r„rfrdrr”rœrbrrŸrrr rr s4€€€€€ð ð ð ð ðððð2ððð,"ð,"ð,"ð\%ð%ð%ð$ð$ð$ð<!ð!ð!ð0"ð"ð"ðH7ð7ð7ð AðAðAðððð*ððð"ðððððð(4ð4ð4ð"ððððEðEðEð9ð9ð9ð9ð9rrcó—eZdZd„Zdd„ZdS)rŽcó—g|_dSrRrq)rs r r!zNFAState.__init__Ss €ØˆŒ ˆ ˆ rNcó>—|j ||f¦«dSrR)r.r0©rr>r=s r ruzNFAState.addarcVs$€ð Œ ×Ò˜% ˜Ñ'Ô'Ð'Ð'Ð'rrR)rr r r!rurrr rŽrŽQs7€€€€€ðððð(ð(ð(ð(ð(ð(rrŽcó*—eZdZd„Zd„Zd„Zd„ZdZdS)rrcó4—||_||v|_i|_dSrR)rsr3r.)rrsÚfinals r r!zDFAState.__init__]s!€ðˆŒØ ˆŒØˆŒ ˆ ˆ rcó—||j|<dSrRrqr³s r ruzDFAState.addarces€ð ˆŒ %ÑÐÐrcó`—|j ¦«D]\}}||ur ||j|<ŒdSrR)r.r/)rÚoldÚnewr=r>s r r‡zDFAState.unifystateksA€Øœ9Ÿ?š?Ñ,Ô,ð 'ð '‰KˆE4Øsˆ{ˆ{Ø#&” ˜%Ñ øð 'ð 'rcóþ—|j|jkrdSt|j¦«t|j¦«krdS|j ¦«D]$\}}||j |¦«urdSŒ%dS)NFT)r3r*r.r/Úget)rÚotherr=r>s r Ú__eq__zDFAState.__eq__psƒ€ðŒ<˜5œ=Ò(Ð(Ø5õˆtŒy‰>Œ>S ¤™_œ_Ò,Ð,Ø5Øœ9Ÿ?š?Ñ,Ô,ð ð ‰KˆE4Ø˜5œ:Ÿ>š>¨%Ñ0Ô0Ð0Ð0Øuuð1àˆtrN)rr r r!rur‡r¾Ú__hash__rrr rrrr[sQ€€€€€ðððð ð ð ð'ð'ð'ð ððð€H€H€HrrrúGrammar.txtcóH—t|¦«}| ¦«SrR)rr?)rÚps r Úgenerate_grammarrÃ€s€Ý˜Ñ!Ô!€AØ>Š>ÑÔÐrN)rÀ)r|rrrÚGrammarrÚobjectrrŽrrrÃrrr úrÆs÷ðð 'Ð&Ð&Ð&Ð&Ð&Ð&Ð&Ð&Ð&ð ð ð ð ð '”/ñ ô ð ðE9ðE9ðE9ðE9ðE9fñE9ôE9ðE9ðN (ð(ð(ð(ð(ˆvñ(ô(ð(ð#ð#ð#ð#ð#ˆvñ#ô#ð#ðJðððððrPKhP3]Â«Ðv"v""__pycache__/driver.cpython-311.pycnu„[µü¤§ àÀfQãóî—dZdZddgZddlZddlZddlZddlZddlZddlm Z m Z mZmZm Z Gd„de¦«Zd „Z dd „Zd„Zd„Zd„Zedkr$ejee¦«¦«¦«dSdS)zZParser driver. This provides a high-level interface to parse a file into a syntax tree. z#Guido van Rossum ÚDriverÚload_grammaréNé)ÚgrammarÚparseÚtokenÚtokenizeÚpgencó>—eZdZd d„Zd d„Zd d„Zd d„Zdd„Zd d„ZdS)rNcóZ—||_|€tj¦«}||_||_dS)N)rÚloggingÚ getLoggerÚloggerÚconvert)Úselfrrrs ú;/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/driver.pyÚ__init__zDriver.__init__s.€ØˆŒØˆ>ÝÔ&Ñ(Ô(ˆFØˆŒØˆŒˆˆóFcóX—tj|j|j¦«}| ¦«d}d}dx}x}x}x} } d}|D]D}|\}}}} } |||fkrE||f|ksJ||f|f¦«‚|\} }|| kr|d| |z zz }| }d}||kr|| ||…z }|}|t jt jfvr'||z }| \}}| d¦«r|dz }d}Œ™|tj krtj|}|r-|j dtj|||¦«| ||||f¦«r|r|j d¦«n>d}| \}}| d¦«r|dz }d}ŒFtjd||||f¦«‚|jS) z4Parse a series of tokens and return the syntax tree.rrNÚú z%s %r (prefix=%r)zStop.zincomplete input)rÚParserrrÚsetupr ÚCOMMENTÚNLÚendswithrÚOPÚopmaprÚdebugÚtok_nameÚaddtokenÚ ParseErrorÚrootnode)rÚtokensrÚpÚlinenoÚcolumnÚtypeÚvalueÚstartÚendÚ line_textÚprefixÚ quintupleÚs_linenoÚs_columns rÚparse_tokenszDriver.parse_tokens&s9€õ ŒL˜œ t¤|Ñ4Ô4ˆØ Š‰ Œ ˆ ØˆØˆØ15Ð5ˆÐ5ˆuÐ5uÐ5˜s YØˆØð$ Añ$ AˆIØ1:Ñ.ˆD%˜ YØ˜ Ð(Ò(Ð(Ø Ð'¨5Ò0Ð0Ð0°F¸FÐ3CÀUÐ2KÑ0Ô0Ð0Ø%*Ñ"˜(Ø˜HÒ$Ð$Ø˜d h°Ñ&7Ñ8Ñ8FØ%FØFØ˜HÒ$Ð$Ø˜i¨¨x¨Ô8Ñ8FØ%FØÔ((¬+Ð6Ð6Ð6Ø˜%‘Ø!$‘˜Ø—>’> $Ñ'Ô'ðØ˜a‘KFØFØØ•u”xÒÐÝ”} UÔ+Øð GØ”×!Ò!Ð"5Ý"'¤.°Ô"6¸¸vñGôGðGàzŠz˜$ ¨° Ñ7Ô7ð Øð/Ø”K×%Ò% gÑ.Ô.Ð.ØØˆFØ ‰NˆFFØ~Š~˜dÑ#Ô#ð Ø˜!‘ØùõÔ"Ð#5Ø#'¨°¸°ñAôAð AàŒzÐrcó`—tj|j¦«}| ||¦«S©z*Parse a stream and return the syntax tree.)r Úgenerate_tokensÚreadliner1)rÚstreamrr$s rÚparse_stream_rawzDriver.parse_stream_rawVs*€åÔ)¨&¬/Ñ:Ô:ˆØ× Ò ¨Ñ/Ô/Ð/rcó.—| ||¦«Sr3)r7)rr6rs rÚparse_streamzDriver.parse_stream[s€à×$Ò$ V¨UÑ3Ô3Ð3rcó—tj|d|¬¦«5}| ||¦«cddd¦«S#1swxYwYdS)z(Parse a file and return the syntax tree.Úr)ÚencodingN)ÚioÚopenr9)rÚfilenamer<rr6s rÚ parse_filezDriver.parse_file_s€å ŒWX˜s¨XÐ 6Ñ 6Ô 6ð 4¸&Ø×$Ò$ V¨UÑ3Ô3ð 4ð 4ð 4ð 4ñ 4ô 4ð 4ð 4ð 4ð 4ð 4ð 4øøøð 4ð 4ð 4ð 4ð 4ð 4s ˜;»?Á?có„—tjtj|¦«j¦«}| ||¦«S)z*Parse a string and return the syntax tree.)r r4r=ÚStringIOr5r1)rÚtextrr$s rÚparse_stringzDriver.parse_stringds5€åÔ)"¬+°dÑ*;Ô*;Ô*DÑEÔEˆØ× Ò ¨Ñ/Ô/Ð/r)NN)F)NF) Ú__name__Ú __module__Ú__qualname__rr1r7r9r@rD©rrrrs€€€€€ððððð.ð.ð.ð.ð`0ð0ð0ð0ð 4ð4ð4ð4ð4ð4ð4ð4ð 0ð0ð0ð0ð0ð0rcóÌ—tj |¦«\}}|dkrd}||zd t t tj¦«¦«zdzS)Nz.txtrú.z.pickle)ÚosÚpathÚsplitextÚjoinÚmapÚstrÚsysÚversion_info)ÚgtÚheadÚtails rÚ_generate_pickle_namerVjsV€Ý”×!Ò! "Ñ%Ô%J€Dˆ$Øˆv‚~€~ØˆØ$‰;˜Ÿš¥#¥c3Ô+;Ñ"<Ô"<Ñ=Ô=Ñ=À ÑIÐIrúGrammar.txtTFcóØ—|€tj¦«}|€t|¦«n|}|st||¦«s‡| d|¦«tj|¦«}|rZ| d|¦« | |¦«nV#t$r }| d|¦«Yd}~n1d}~wwxYwn(tj ¦«}| |¦«|S)z'Load the grammar (maybe from a pickle).Nz!Generating grammar tables from %szWriting grammar tables to %szWriting failed: %s)r rrVÚ_newerÚinfor Úgenerate_grammarÚdumpÚOSErrorrÚGrammarÚload)rSÚgpÚsaveÚforcerÚgÚes rrrqs€ð€~ÝÔ"Ñ$Ô$ˆØ&( jÕ ˜rÑ "Ô "Ð "°b€BØð•F˜2˜r‘N”NðØŠÐ7¸Ñ<Ô<Ð<ÝÔ! "Ñ%Ô%ˆØð 5ØKŠKÐ6¸Ñ;Ô;Ð;ð 5Ø—’r‘ ” øÝð 5ð 5ð 5Ø—’Ð0°!Ñ4Ô4Ð4Ð4Ð4Ð4Ð4Ð4øøøøð 5øøøð 5õ ŒOÑÔˆØ Šˆr‰ Œ ˆ Ø€HsÁ>BÂ B>ÂB9Â9B>có—tj |¦«sdStj |¦«sdStj |¦«tj |¦«kS)z0Inquire whether file a was written since file b.FT)rKrLÚexistsÚgetmtime)ÚaÚbs rrYrY†sc€å Œ7>Š>˜!ÑÔðØˆuÝ Œ7>Š>˜!ÑÔðØˆtÝ Œ7×Ò˜AÑÔ¥"¤'×"2Ò"2°1Ñ"5Ô"5Ò5Ð5rcó4—tj |¦«rt|¦«St tj |¦«¦«}t j||¦«}tj ¦«}| |¦«|S)aÙNormally, loads a pickled grammar by doing pkgutil.get_data(package, pickled_grammar) where *pickled_grammar* is computed from *grammar_source* by adding the Python version and using a ``.pickle`` extension. However, if *grammar_source* is an extant file, load_grammar(grammar_source) is called instead. This facilitates using a packaged grammar file when needed but preserves load_grammar's automatic regeneration behavior when possible. )rKrLÚisfilerrVÚbasenameÚpkgutilÚget_datarr^Úloads)ÚpackageÚgrammar_sourceÚpickled_nameÚdatarcs rÚload_packaged_grammarrtsx€õ „w‡~‚~nÑ%Ô%ð,Ý˜NÑ+Ô+Ð+Ý(¬×)9Ò)9¸.Ñ)IÔ)IÑJÔJ€LÝÔ˜G \Ñ2Ô2€DÝŒÑÔ€AØ‡G‚GˆDM„M€MØ€Hrcó¶—|stjdd…}tjtjtjd¬¦«|D]}t |dd¬¦«ŒdS)zMain program, when run as a script: produce grammar pickle files. Calls load_grammar for each argument, a path to a grammar text file. rNz%(message)s)Úlevelr6ÚformatT)rarb)rQÚargvr ÚbasicConfigÚINFOÚstdoutr)ÚargsrSs rÚmainr}£sl€ð ðÝŒx˜˜˜Œ|ˆÝÔgœlµ3´:Ø,ð.ñ.ô.ð.àð0ð0ˆÝR˜d¨$Ð/Ñ/Ô/Ð/Ð/Øˆ4rÚ__main__)rWNTFN)Ú__doc__Ú __author__Ú__all__r=rKr rmrQrrrrr r ÚobjectrrVrrYrtr}rEÚexitÚintrHrrúr…sFðððð3€ à^Ð $€ð € € € Ø € € € Ø€€€Ø€€€Ø € € € ð4Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3ðJ0ðJ0ðJ0ðJ0ðJ0ˆVñJ0ôJ0ðJ0ðZJðJðJð'+Ø04ð ð ð ð ð*6ð6ð6ð ð ð ð(ðððˆzÒÐØ€C„HˆSˆSTT‘V”V‰_Œ_ÑÔÐÐÐðÐrPKhP3] æZV#V#!__pycache__/parse.cpython-311.pycnu„[µü¤§ àÀfÛãóN—dZddlmZGd„de¦«ZGd„de¦«ZdS)zÈParser engine for the grammar tables generated by pgen. The grammar table must be loaded first. See Parser/parser.c in the Python distribution for additional info on how this parsing engine works. é)Útokencó—eZdZdZd„Zd„ZdS)Ú ParseErrorz(Exception to signal the parser is stuck.c óŠ—t ||›d|›d|›d|›¦«||_||_||_||_dS)Nz: type=z, value=z , context=)Ú ExceptionÚ__init__ÚmsgÚtypeÚvalueÚcontext)Úselfr r rrs ú:/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/parse.pyrzParseError.__init__sX€Ý×Ò˜4Ø˜C˜C u u u¨g¨gð"7ñ 8ô 8ð 8àˆŒØˆŒ ØˆŒ ØˆŒˆˆócóT—t|¦«|j|j|j|jffS©N)r r rr)r s rÚ __reduce__zParseError.__reduce__s$€ÝD‰zŒz˜DœH d¤i°´¸T¼\ÐJÐJÐJrN)Ú__name__Ú __module__Ú__qualname__Ú__doc__rr©rrrrs=€€€€€Ø2Ð2ððððKðKðKðKðKrrcó@—eZdZdZd d„Zd d„Zd„Zd„Zd„Zd„Z d „Z dS)ÚParsera5Parser engine. The proper usage sequence is: p = Parser(grammar, [converter]) # create instance p.setup([start]) # prepare for parsing : if p.addtoken(...): # parse a token; may raise ParseError break root = p.rootnode # root of abstract syntax tree A Parser instance may be reused by calling setup() repeatedly. A Parser instance contains state pertaining to the current token sequence, and should not be used concurrently by different threads to parse separate token sequences. See driver.py for how to get input tokens by tokenizing a file or string. Parsing is complete when addtoken() returns True; the root of the abstract syntax tree can then be retrieved from the rootnode instance variable. When a syntax error occurs, addtoken() raises the ParseError exception. There is no error recovery; the parser cannot be used after a syntax error was reported (but it can be reinitialized by calling setup()). Ncó(—||_|pd„|_dS)aÚConstructor. The grammar argument is a grammar.Grammar instance; see the grammar module for more information. The parser is not ready yet for parsing; you must call the setup() method to get it started. The optional convert argument is a function mapping concrete syntax tree nodes to abstract syntax tree nodes. If not given, no conversion is done and the syntax tree produced is the concrete syntax tree. If given, it must be a function of two arguments, the first being the grammar (a grammar.Grammar instance), and the second being the concrete syntax tree node to be converted. The syntax tree is converted from the bottom up. A concrete syntax tree node is a (type, value, context, nodes) tuple, where type is the node type (a token or symbol number), value is None for symbols and a string for tokens, context is None or an opaque value used for error reporting (typically a (lineno, offset) pair), and nodes is a list of children for symbols, and None for tokens. An abstract syntax tree node may be anything; this is entirely up to the converter function. có—|Srr)ÚgrammarÚnodes rúz!Parser.__init__..Zs€¸€rN)rÚconvert)r rrs rrzParser.__init__<s€ð:ˆŒØÐ>Ð#=Ð#=ˆŒˆˆrcóœ—|€|jj}|ddgf}|jj|d|f}|g|_d|_t¦«|_dS)a›Prepare for parsing. This *must* be called before starting to parse. The optional argument is an alternative start symbol; it defaults to the grammar's start symbol. You can use a Parser instance to parse any number of programs; each time you call setup() the parser is reset to an initial state determined by the (implicit or explicit) start symbol. Né)rÚstartÚdfasÚstackÚrootnodeÚsetÚ used_names)r r"ÚnewnodeÚ stackentrys rÚsetupzParser.setup\sX€ðˆ=Ø”LÔ&ˆEð˜$ bÐ)ˆØ”lÔ'¨Ô.°°7Ð;ˆ Ø \ˆŒ ØˆŒ Ý™%œ%ˆŒˆˆrcóÈ—| |||¦«} |jd\}}}|\}} ||} | D]â\}}|jj|\} }||krw| dksJ‚| ||||¦«|}||d|fgkrC| ¦«|jsdS|jd\}}}|\}} ||d|fgk°CdS| dkrE|jj| }|\}}||vr*| | |jj| ||¦«nGŒãd|f| vr.| ¦«|jstd|||¦«‚ntd|||¦«‚ŒK)zÔ>Ð>à$EØ œ-¨Q°¨J¨<Ò7Ð7ØŸš™ œ ˜ Ø#œzð(à#' 4 4Ø+/¬:°b¬>Ñ(˜˜U DØ(+™ ˜ ð ! œ-¨Q°¨J¨<Ò7Ð7ð!˜5˜5Ø˜#’XXà!œ\Ô.¨qÔ1FØ*0Ñ'I˜xØ Ð)Ð)àŸ š ! T¤\Ô%6°qÔ%9¸8ÀWÑMÔMÐMØ˜øàu: Ð%Ð%à—H’H‘J”JJØœ:ð?å(Ð)9Ø)-¨u°gñ?ô?ð?ð?õ% [°$¸¸wÑGÔGÐGñS) Hrcó—|tjkr=|j |¦«|jj |¦«}||S|jj |¦«}|€td|||¦«‚|S)z&Turn a token into a label. (Internal)Nz bad token) rÚNAMEr'ÚaddrÚkeywordsÚgetÚtokensr)r r rrr3s rr.zParser.classify¤s~€à•5”:ÒÐàŒO×Ò Ñ&Ô&Ð&à”\Ô*×.Ò.¨uÑ5Ô5ˆFØÐ!Ø Ø”Ô$×(Ò(¨Ñ.Ô.ˆØˆ>Ý˜[¨$°°wÑ?Ô?Ð?Øˆ rcó¾—|jd\}}}|||df}| |j|¦«}||d |¦«|||f|jd<dS)zShift a token. (Internal)r,N)r$rrÚappend) r r rr:rr4r5rr(s rr0zParser.shift²si€àœ: bœ>ÑˆˆUDØ˜ ¨Ð.ˆØ—,’,˜tœ|¨WÑ5Ô5ˆØÐØŒHOŠO˜GÑ$Ô$Ð$Ø˜x¨Ð.ˆŒ 2‰ˆˆrcóˆ—|jd\}}}|d|gf}|||f|jd<|j |d|f¦«dS)zPush a nonterminal. (Internal)r,Nr!)r$rH) r r Únewdfar:rr4r5rr(s rr2zParser.push»sW€àœ: bœ>ÑˆˆUDØ˜˜w¨Ð+ˆØ˜x¨Ð.ˆŒ 2‰ØŒ ×Ò˜6 1 gÐ.Ñ/Ô/Ð/Ð/Ð/rcó—|j ¦«\}}}| |j|¦«}|O|jr.|jd\}}}|d |¦«dS||_|j|j_dSdS)zPop a nonterminal. (Internal)Nr,)r$r1rrrHr%r')r ÚpopdfaÚpopstateÚpopnoder(r4r5rs rr1z Parser.popÂsŽ€à$(¤J§N¢NÑ$4Ô$4Ñ!ˆ˜'Ø—,’,˜tœ|¨WÑ5Ô5ˆØÐØŒzð ;Ø#'¤:¨b¤>Ñ U˜DØR”—’ Ñ(Ô(Ð(Ð(Ð(à '” Ø+/¬?” Ô(Ð(Ð(ð Ðrr)rrrrrr*r@r.r0r2r1rrrrrs–€€€€€ððð:?ð?ð?ð?ð@ ð ð ð ð0.Hð.Hð.Hð`ððð/ð/ð/ð0ð0ð0ð ;ð ;ð ;ð ;ð ;rrN)rÚrrrÚobjectrrrrúrQs“ððððÐÐÐÐÐðKðKðKðKðKñKôKðKðn;ðn;ðn;ðn;ðn;ˆVñn;ôn;ðn;ðn;ðn;rPKhP3]Ìû:““#__pycache__/grammar.cpython-311.pycnu„[µü¤§ àÀf°ãóÆ—dZddlZddlmZGd„de¦«ZdZiZe ¦«D]*Z e r&e ¦«\ZZe ee¦«ee<Œ+[ [[dS)a‡This module defines the data structures used to represent a grammar. These are a bit arcane because they are derived from the data structures used by Python's 'pgen' parser generator. There's also a table here mapping operators to their names in the token module; the Python tokenize module reports all operators as the fallback token code OP, but the parser needs the actual token code. éNé)Útokencó6—eZdZdZd„Zd„Zd„Zd„Zd„Zd„Z dS) ÚGrammara¶ Pgen parsing tables conversion class. Once initialized, this class supplies the grammar tables for the parsing engine implemented by parse.py. The parsing engine accesses the instance variables directly. The class here does not provide initialization of the tables; several subclasses exist to do this (see the conv and pgen modules). The load() method reads the tables from a pickle file, which is much faster than the other ways offered by subclasses. The pickle file is written by calling dump() (after loading the grammar tables using a subclass). The report() method prints a readable representation of the tables to stdout, for debugging. The instance variables are as follows: symbol2number -- a dict mapping symbol names to numbers. Symbol numbers are always 256 or higher, to distinguish them from token numbers, which are between 0 and 255 (inclusive). number2symbol -- a dict mapping numbers to symbol names; these two are each other's inverse. states -- a list of DFAs, where each DFA is a list of states, each state is a list of arcs, and each arc is a (i, j) pair where i is a label and j is a state number. The DFA number is the index into this list. (This name is slightly confusing.) Final states are represented by a special arc of the form (0, j) where j is its own state number. dfas -- a dict mapping symbol numbers to (DFA, first) pairs, where DFA is an item from the states list above, and first is a set of tokens that can begin this grammar rule (represented by a dict whose values are always 1). labels -- a list of (x, y) pairs where x is either a token number or a symbol number, and y is either None or a string; the strings are keywords. The label number is the index in this list; label numbers are used to mark state transitions (arcs) in the DFAs. start -- the number of the grammar's start symbol. keywords -- a dict mapping keyword strings to arc labels. tokens -- a dict mapping token numbers to arc labels. có†—i|_i|_g|_i|_dg|_i|_i|_i|_d|_dS)N)rÚEMPTYé) Ú symbol2numberÚ number2symbolÚstatesÚdfasÚlabelsÚkeywordsÚtokensÚsymbol2labelÚstart)Úselfs ú GREATER = EQUAL . DOT % PERCENT ` BACKQUOTE { LBRACE } RBRACE @ AT @= ATEQUAL == EQEQUAL != NOTEQUAL <> NOTEQUAL <= LESSEQUAL >= GREATEREQUAL ~ TILDE ^ CIRCUMFLEX << LEFTSHIFT >> RIGHTSHIFT ** DOUBLESTAR += PLUSEQUAL -= MINEQUAL *= STAREQUAL /= SLASHEQUAL %= PERCENTEQUAL &= AMPEREQUAL |= VBAREQUAL ^= CIRCUMFLEXEQUAL <<= LEFTSHIFTEQUAL >>= RIGHTSHIFTEQUAL **= DOUBLESTAREQUAL // DOUBLESLASH //= DOUBLESLASHEQUAL -> RARROW := COLONEQUAL )r8rÚrÚobjectrÚ opmap_rawÚopmapÚ splitlinesÚlineÚsplitÚopÚnamer+r9rrúrCsÅðð ð ð€ € € ðÐÐÐÐÐðj#ðj#ðj#ðj#ðj#ˆfñj#ôj#ðj#ð^1 € ðf €Ø× Ò Ñ"Ô"ð)ð)€DØð)Ø—:’:‘<”<‰ˆˆDØG˜E 4Ñ(Ô(ˆˆb‰ øØˆ"ˆdˆdˆdrPKhP3]qD Ð;#;#'__pycache__/parse.cpython-311.opt-1.pycnu„[µü¤§ àÀfÛãóN—dZddlmZGd„de¦«ZGd„de¦«ZdS)zÈParser engine for the grammar tables generated by pgen. The grammar table must be loaded first. See Parser/parser.c in the Python distribution for additional info on how this parsing engine works. é)Útokencó—eZdZdZd„Zd„ZdS)Ú ParseErrorz(Exception to signal the parser is stuck.c óŠ—t ||›d|›d|›d|›¦«||_||_||_||_dS)Nz: type=z, value=z , context=)Ú ExceptionÚ__init__ÚmsgÚtypeÚvalueÚcontext)Úselfr r rrs ú:/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/parse.pyrzParseError.__init__sX€Ý×Ò˜4Ø˜C˜C u u u¨g¨gð"7ñ 8ô 8ð 8àˆŒØˆŒ ØˆŒ ØˆŒˆˆócóT—t|¦«|j|j|j|jffS©N)r r rr)r s rÚ __reduce__zParseError.__reduce__s$€ÝD‰zŒz˜DœH d¤i°´¸T¼\ÐJÐJÐJrN)Ú__name__Ú __module__Ú__qualname__Ú__doc__rr©rrrrs=€€€€€Ø2Ð2ððððKðKðKðKðKrrcó@—eZdZdZd d„Zd d„Zd„Zd„Zd„Zd„Z d „Z dS)ÚParsera5Parser engine. The proper usage sequence is: p = Parser(grammar, [converter]) # create instance p.setup([start]) # prepare for parsing : if p.addtoken(...): # parse a token; may raise ParseError break root = p.rootnode # root of abstract syntax tree A Parser instance may be reused by calling setup() repeatedly. A Parser instance contains state pertaining to the current token sequence, and should not be used concurrently by different threads to parse separate token sequences. See driver.py for how to get input tokens by tokenizing a file or string. Parsing is complete when addtoken() returns True; the root of the abstract syntax tree can then be retrieved from the rootnode instance variable. When a syntax error occurs, addtoken() raises the ParseError exception. There is no error recovery; the parser cannot be used after a syntax error was reported (but it can be reinitialized by calling setup()). Ncó(—||_|pd„|_dS)aÚConstructor. The grammar argument is a grammar.Grammar instance; see the grammar module for more information. The parser is not ready yet for parsing; you must call the setup() method to get it started. The optional convert argument is a function mapping concrete syntax tree nodes to abstract syntax tree nodes. If not given, no conversion is done and the syntax tree produced is the concrete syntax tree. If given, it must be a function of two arguments, the first being the grammar (a grammar.Grammar instance), and the second being the concrete syntax tree node to be converted. The syntax tree is converted from the bottom up. A concrete syntax tree node is a (type, value, context, nodes) tuple, where type is the node type (a token or symbol number), value is None for symbols and a string for tokens, context is None or an opaque value used for error reporting (typically a (lineno, offset) pair), and nodes is a list of children for symbols, and None for tokens. An abstract syntax tree node may be anything; this is entirely up to the converter function. có—|Srr)ÚgrammarÚnodes rúz!Parser.__init__..Zs€¸€rN)rÚconvert)r rrs rrzParser.__init__<s€ð:ˆŒØÐ>Ð#=Ð#=ˆŒˆˆrcóœ—|€|jj}|ddgf}|jj|d|f}|g|_d|_t¦«|_dS)a›Prepare for parsing. This *must* be called before starting to parse. The optional argument is an alternative start symbol; it defaults to the grammar's start symbol. You can use a Parser instance to parse any number of programs; each time you call setup() the parser is reset to an initial state determined by the (implicit or explicit) start symbol. Né)rÚstartÚdfasÚstackÚrootnodeÚsetÚ used_names)r r"ÚnewnodeÚ stackentrys rÚsetupzParser.setup\sX€ðˆ=Ø”LÔ&ˆEð˜$ bÐ)ˆØ”lÔ'¨Ô.°°7Ð;ˆ Ø \ˆŒ ØˆŒ Ý™%œ%ˆŒˆˆrcó¸—| |||¦«} |jd\}}}|\}} ||} | D]Ú\}}|jj|\} }||kro| ||||¦«|}||d|fgkrC| ¦«|jsdS|jd\}}}|\}} ||d|fgk°CdS| dkrE|jj| }|\}}||vr*| | |jj| ||¦«nGŒÛd|f| vr.| ¦«|jstd|||¦«‚ntd|||¦«‚ŒC)zÔ>Ð>à$EØ œ-¨Q°¨J¨<Ò7Ð7ØŸš™ œ ˜ Ø#œzð(à#' 4 4Ø+/¬:°b¬>Ñ(˜˜U DØ(+™ ˜ ð ! œ-¨Q°¨J¨<Ò7Ð7ð!˜5˜5Ø˜#’XXà!œ\Ô.¨qÔ1FØ*0Ñ'I˜xØ Ð)Ð)àŸ š ! T¤\Ô%6°qÔ%9¸8ÀWÑMÔMÐMØ˜øàu: Ð%Ð%à—H’H‘J”JJØœ:ð?å(Ð)9Ø)-¨u°gñ?ô?ð?ð?õ% [°$¸¸wÑGÔGÐGñS) Hrcó—|tjkr=|j |¦«|jj |¦«}||S|jj |¦«}|€td|||¦«‚|S)z&Turn a token into a label. (Internal)Nz bad token) rÚNAMEr'ÚaddrÚkeywordsÚgetÚtokensr)r r rrr3s rr.zParser.classify¤s~€à•5”:ÒÐàŒO×Ò Ñ&Ô&Ð&à”\Ô*×.Ò.¨uÑ5Ô5ˆFØÐ!Ø Ø”Ô$×(Ò(¨Ñ.Ô.ˆØˆ>Ý˜[¨$°°wÑ?Ô?Ð?Øˆ rcó¾—|jd\}}}|||df}| |j|¦«}||d |¦«|||f|jd<dS)zShift a token. (Internal)r,N)r$rrÚappend) r r rr:rr4r5rr(s rr0zParser.shift²si€àœ: bœ>ÑˆˆUDØ˜ ¨Ð.ˆØ—,’,˜tœ|¨WÑ5Ô5ˆØÐØŒHOŠO˜GÑ$Ô$Ð$Ø˜x¨Ð.ˆŒ 2‰ˆˆrcóˆ—|jd\}}}|d|gf}|||f|jd<|j |d|f¦«dS)zPush a nonterminal. (Internal)r,Nr!)r$rH) r r Únewdfar:rr4r5rr(s rr2zParser.push»sW€àœ: bœ>ÑˆˆUDØ˜˜w¨Ð+ˆØ˜x¨Ð.ˆŒ 2‰ØŒ ×Ò˜6 1 gÐ.Ñ/Ô/Ð/Ð/Ð/rcó—|j ¦«\}}}| |j|¦«}|O|jr.|jd\}}}|d |¦«dS||_|j|j_dSdS)zPop a nonterminal. (Internal)Nr,)r$r1rrrHr%r')r ÚpopdfaÚpopstateÚpopnoder(r4r5rs rr1z Parser.popÂsŽ€à$(¤J§N¢NÑ$4Ô$4Ñ!ˆ˜'Ø—,’,˜tœ|¨WÑ5Ô5ˆØÐØŒzð ;Ø#'¤:¨b¤>Ñ U˜DØR”—’ Ñ(Ô(Ð(Ð(Ð(à '” Ø+/¬?” Ô(Ð(Ð(ð Ðrr)rrrrrr*r@r.r0r2r1rrrrrs–€€€€€ððð:?ð?ð?ð?ð@ ð ð ð ð0.Hð.Hð.Hð`ððð/ð/ð/ð0ð0ð0ð ;ð ;ð ;ð ;ð ;rrN)rÚrrrÚobjectrrrrúrQs“ððððÐÐÐÐÐðKðKðKðKðKñKôKðKðn;ðn;ðn;ðn;ðn;ˆVñn;ôn;ðn;ðn;ðn;rPKhP3]’`K K !__pycache__/token.cpython-311.pycnu„[µü¤§ àÀf#ãó¤—dZdZdZdZdZdZdZdZdZd Z d Z dZdZd Z dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd Z d!Z!d"Z"d#Z#d$Z$d%Z%d&Z&d'Z'd(Z(d)Z)d*Z*d+Z+d,Z,d-Z-d.Z.d/Z/d0Z0d1Z1d2Z2d3Z3d4Z4d5Z5d6Z6d7Z7d8Z8d9Z9d:Z:d;Z;dZ>iZ?e@eA¦« B¦«¦«D] \ZCZDeEeD¦«eEd¦«ureCe?eD<Œ!d?„ZFd@„ZGdA„ZHdBS)Cz!Token constants (from "token.h").éééééééééé é ééé ééééééééééééééééééé é!é"é#é$é%é&é'é(é)é*é+é,é-é.é/é0é1é2é3é4é5é6é7é8é9é:é;é<écó—|tkS©N©Ú NT_OFFSET©Úxs ú:/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/token.pyÚ ISTERMINALrGOs€ØyŠ=Ðócó—|tkSrArBrDs rFÚ ISNONTERMINALrJRó€Ø• Š>ÐrHcó—|tkSrA)Ú ENDMARKERrDs rFÚISEOFrNUrKrHN)IÚ__doc__rMÚNAMEÚNUMBERÚSTRINGÚNEWLINEÚINDENTÚDEDENTÚLPARÚRPARÚLSQBÚRSQBÚCOLONÚCOMMAÚSEMIÚPLUSÚMINUSÚSTARÚSLASHÚVBARÚAMPERÚLESSÚGREATERÚEQUALÚDOTÚPERCENTÚ BACKQUOTEÚLBRACEÚRBRACEÚEQEQUALÚNOTEQUALÚ LESSEQUALÚGREATEREQUALÚTILDEÚ CIRCUMFLEXÚ LEFTSHIFTÚ RIGHTSHIFTÚ DOUBLESTARÚ PLUSEQUALÚMINEQUALÚ STAREQUALÚ SLASHEQUALÚPERCENTEQUALÚ AMPEREQUALÚ VBAREQUALÚCIRCUMFLEXEQUALÚLEFTSHIFTEQUALÚRIGHTSHIFTEQUALÚDOUBLESTAREQUALÚDOUBLESLASHÚDOUBLESLASHEQUALÚATÚATEQUALÚOPÚCOMMENTÚNLÚRARROWÚAWAITÚASYNCÚ ERRORTOKENÚ COLONEQUALÚN_TOKENSrCÚtok_nameÚlistÚglobalsÚitemsÚ_nameÚ_valueÚtyperGrJrN©rHrFúr”s×ðð(Ð'ð € Ø€Ø €Ø €Ø €Ø €Ø €Ø€Ø€Ø€Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø€Ø €Ø€ Ø €Ø €Ø €Ø €Ø€ Ø€Ø €Ø € Ø€ Ø € Ø € Ø€ Ø €Ø€ Ø € Ø€Ø € Ø€ Ø€Ø€Ø€Ø€Ø€ØÐØ€Ø €Ø€Ø €Ø€Ø €Ø €Ø €Ø € Ø € Ø €Ø€ ð€ØT˜'˜'™)œ)Ÿ/š/Ñ+Ô+Ñ,Ô,ð!ð!M€Eˆ6Ø€tˆF|„|tt˜A‘w”wÐÐØ ˆÑøðððððððððððrHPKhP3]‹c """"(__pycache__/driver.cpython-311.opt-1.pycnu„[µü¤§ àÀfQãóî—dZdZddgZddlZddlZddlZddlZddlZddlm Z m Z mZmZm Z Gd„de¦«Zd „Z dd „Zd„Zd„Zd„Zedkr$ejee¦«¦«¦«dSdS)zZParser driver. This provides a high-level interface to parse a file into a syntax tree. z#Guido van Rossum ÚDriverÚload_grammaréNé)ÚgrammarÚparseÚtokenÚtokenizeÚpgencó>—eZdZd d„Zd d„Zd d„Zd d„Zdd„Zd d„ZdS)rNcóZ—||_|€tj¦«}||_||_dS)N)rÚloggingÚ getLoggerÚloggerÚconvert)Úselfrrrs ú;/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/driver.pyÚ__init__zDriver.__init__s.€ØˆŒØˆ>ÝÔ&Ñ(Ô(ˆFØˆŒØˆŒˆˆóFcó,—tj|j|j¦«}| ¦«d}d}dx}x}x}x} } d}|D].}|\}}}} } |||fkr/|\} }|| kr|d| |z zz }| }d}||kr|| ||…z }|}|t jt jfvr'||z }| \}}| d¦«r|dz }d}Œƒ|tj krtj|}|r-|j dtj|||¦«| ||||f¦«r|r|j d¦«n>d}| \}}| d¦«r|dz }d}Œ0tjd||||f¦«‚|jS) z4Parse a series of tokens and return the syntax tree.rrNÚú z%s %r (prefix=%r)zStop.zincomplete input)rÚParserrrÚsetupr ÚCOMMENTÚNLÚendswithrÚOPÚopmaprÚdebugÚtok_nameÚaddtokenÚ ParseErrorÚrootnode)rÚtokensrÚpÚlinenoÚcolumnÚtypeÚvalueÚstartÚendÚ line_textÚprefixÚ quintupleÚs_linenoÚs_columns rÚparse_tokenszDriver.parse_tokens&s€õ ŒL˜œ t¤|Ñ4Ô4ˆØ Š‰ Œ ˆ ØˆØˆØ15Ð5ˆÐ5ˆuÐ5uÐ5˜s YØˆØð$ Añ$ AˆIØ1:Ñ.ˆD%˜ YØ˜ Ð(Ò(Ð(à%*Ñ"˜(Ø˜HÒ$Ð$Ø˜d h°Ñ&7Ñ8Ñ8FØ%FØFØ˜HÒ$Ð$Ø˜i¨¨x¨Ô8Ñ8FØ%FØÔ((¬+Ð6Ð6Ð6Ø˜%‘Ø!$‘˜Ø—>’> $Ñ'Ô'ðØ˜a‘KFØFØØ•u”xÒÐÝ”} UÔ+Øð GØ”×!Ò!Ð"5Ý"'¤.°Ô"6¸¸vñGôGðGàzŠz˜$ ¨° Ñ7Ô7ð Øð/Ø”K×%Ò% gÑ.Ô.Ð.ØØˆFØ ‰NˆFFØ~Š~˜dÑ#Ô#ð Ø˜!‘ØùõÔ"Ð#5Ø#'¨°¸°ñAôAð AàŒzÐrcó`—tj|j¦«}| ||¦«S©z*Parse a stream and return the syntax tree.)r Úgenerate_tokensÚreadliner1)rÚstreamrr$s rÚparse_stream_rawzDriver.parse_stream_rawVs*€åÔ)¨&¬/Ñ:Ô:ˆØ× Ò ¨Ñ/Ô/Ð/rcó.—| ||¦«Sr3)r7)rr6rs rÚparse_streamzDriver.parse_stream[s€à×$Ò$ V¨UÑ3Ô3Ð3rcó—tj|d|¬¦«5}| ||¦«cddd¦«S#1swxYwYdS)z(Parse a file and return the syntax tree.Úr)ÚencodingN)ÚioÚopenr9)rÚfilenamer<rr6s rÚ parse_filezDriver.parse_file_s€å ŒWX˜s¨XÐ 6Ñ 6Ô 6ð 4¸&Ø×$Ò$ V¨UÑ3Ô3ð 4ð 4ð 4ð 4ñ 4ô 4ð 4ð 4ð 4ð 4ð 4ð 4øøøð 4ð 4ð 4ð 4ð 4ð 4s ˜;»?Á?có„—tjtj|¦«j¦«}| ||¦«S)z*Parse a string and return the syntax tree.)r r4r=ÚStringIOr5r1)rÚtextrr$s rÚparse_stringzDriver.parse_stringds5€åÔ)"¬+°dÑ*;Ô*;Ô*DÑEÔEˆØ× Ò ¨Ñ/Ô/Ð/r)NN)F)NF) Ú__name__Ú __module__Ú__qualname__rr1r7r9r@rD©rrrrs€€€€€ððððð.ð.ð.ð.ð`0ð0ð0ð0ð 4ð4ð4ð4ð4ð4ð4ð4ð 0ð0ð0ð0ð0ð0rcóÌ—tj |¦«\}}|dkrd}||zd t t tj¦«¦«zdzS)Nz.txtrú.z.pickle)ÚosÚpathÚsplitextÚjoinÚmapÚstrÚsysÚversion_info)ÚgtÚheadÚtails rÚ_generate_pickle_namerVjsV€Ý”×!Ò! "Ñ%Ô%J€Dˆ$Øˆv‚~€~ØˆØ$‰;˜Ÿš¥#¥c3Ô+;Ñ"<Ô"<Ñ=Ô=Ñ=À ÑIÐIrúGrammar.txtTFcóØ—|€tj¦«}|€t|¦«n|}|st||¦«s‡| d|¦«tj|¦«}|rZ| d|¦« | |¦«nV#t$r }| d|¦«Yd}~n1d}~wwxYwn(tj ¦«}| |¦«|S)z'Load the grammar (maybe from a pickle).Nz!Generating grammar tables from %szWriting grammar tables to %szWriting failed: %s)r rrVÚ_newerÚinfor Úgenerate_grammarÚdumpÚOSErrorrÚGrammarÚload)rSÚgpÚsaveÚforcerÚgÚes rrrqs€ð€~ÝÔ"Ñ$Ô$ˆØ&( jÕ ˜rÑ "Ô "Ð "°b€BØð•F˜2˜r‘N”NðØŠÐ7¸Ñ<Ô<Ð<ÝÔ! "Ñ%Ô%ˆØð 5ØKŠKÐ6¸Ñ;Ô;Ð;ð 5Ø—’r‘ ” øÝð 5ð 5ð 5Ø—’Ð0°!Ñ4Ô4Ð4Ð4Ð4Ð4Ð4Ð4øøøøð 5øøøð 5õ ŒOÑÔˆØ Šˆr‰ Œ ˆ Ø€HsÁ>BÂ B>ÂB9Â9B>có—tj |¦«sdStj |¦«sdStj |¦«tj |¦«kS)z0Inquire whether file a was written since file b.FT)rKrLÚexistsÚgetmtime)ÚaÚbs rrYrY†sc€å Œ7>Š>˜!ÑÔðØˆuÝ Œ7>Š>˜!ÑÔðØˆtÝ Œ7×Ò˜AÑÔ¥"¤'×"2Ò"2°1Ñ"5Ô"5Ò5Ð5rcó4—tj |¦«rt|¦«St tj |¦«¦«}t j||¦«}tj ¦«}| |¦«|S)aÙNormally, loads a pickled grammar by doing pkgutil.get_data(package, pickled_grammar) where *pickled_grammar* is computed from *grammar_source* by adding the Python version and using a ``.pickle`` extension. However, if *grammar_source* is an extant file, load_grammar(grammar_source) is called instead. This facilitates using a packaged grammar file when needed but preserves load_grammar's automatic regeneration behavior when possible. )rKrLÚisfilerrVÚbasenameÚpkgutilÚget_datarr^Úloads)ÚpackageÚgrammar_sourceÚpickled_nameÚdatarcs rÚload_packaged_grammarrtsx€õ „w‡~‚~nÑ%Ô%ð,Ý˜NÑ+Ô+Ð+Ý(¬×)9Ò)9¸.Ñ)IÔ)IÑJÔJ€LÝÔ˜G \Ñ2Ô2€DÝŒÑÔ€AØ‡G‚GˆDM„M€MØ€Hrcó¶—|stjdd…}tjtjtjd¬¦«|D]}t |dd¬¦«ŒdS)zMain program, when run as a script: produce grammar pickle files. Calls load_grammar for each argument, a path to a grammar text file. rNz%(message)s)Úlevelr6ÚformatT)rarb)rQÚargvr ÚbasicConfigÚINFOÚstdoutr)ÚargsrSs rÚmainr}£sl€ð ðÝŒx˜˜˜Œ|ˆÝÔgœlµ3´:Ø,ð.ñ.ô.ð.àð0ð0ˆÝR˜d¨$Ð/Ñ/Ô/Ð/Ð/Øˆ4rÚ__main__)rWNTFN)Ú__doc__Ú __author__Ú__all__r=rKr rmrQrrrrr r ÚobjectrrVrrYrtr}rEÚexitÚintrHrrúr…sFðððð3€ à^Ð $€ð € € € Ø € € € Ø€€€Ø€€€Ø € € € ð4Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3ðJ0ðJ0ðJ0ðJ0ðJ0ˆVñJ0ôJ0ðJ0ðZJðJðJð'+Ø04ð ð ð ð ð*6ð6ð6ð ð ð ð(ðððˆzÒÐØ€C„HˆSˆSTT‘V”V‰_Œ_ÑÔÐÐÐðÐrPKhP3]O=Gž¬ ¬ *__pycache__/literals.cpython-311.opt-1.pycnu„[µü¤§ àÀfcãób—dZddlZddddddd d ddd œ Zd„Zd„Zd„Zedkre¦«dSdS)zˆ>ÝÐAÀDÑHÑIÔIÐIð TÝE˜2‘”ˆAˆAøÝð Tð Tð TÝÐAÀDÑHÑIÔIÈtÐSð Tøøøð VÝD˜!‘”ˆAˆAøÝð Vð Vð VÝÐCÀdÑJÑKÔKÐQUÐUð Vøøøåˆq‰6Œ6€MsÁ=BÂB,Â0CÃCcó¾—|d}|dd…|dzkr|dz}|t|¦«t|¦«…}tjdt|¦«S)Nréz)\\(\'|\"|\\|[abfnrtv]|x.{0,2}|[0-7]{1,3}))rÚreÚsubr))ÚsÚqs r(Ú evalStringr0(s\€à ˆ!Œ€AØˆˆ!ˆ„u!‘‚|€|Ø ˆa‰Cˆð #ˆa‰&Œ&•#a‘&”&ˆ.Ô€AÝ Œ6Ð>ÅÈÑJÔJÐJócó´—td¦«D]G}t|¦«}t|¦«}t|¦«}||krt ||||¦«ŒHdS)Né)Úranger!Úreprr0Úprint)r'Úcr.Úes r(Útestr92s`€Ý 3‰ZŒZððˆÝ‰FŒFˆÝ‰GŒGˆÝq‰MŒMˆØŠ6ˆ6Ý!Q˜˜1ÑÔÐøððr1Ú__main__)Ú__doc__r,rr)r0r9Ú__name__©r1r(úr>s•ððCÐBà € € € àØØØØØØØØØð ð €ðððð*KðKðKððððˆzÒÐØ€DF„F€F€F€FðÐr1PKhP3]’`K K '__pycache__/token.cpython-311.opt-1.pycnu„[µü¤§ àÀf#ãó¤—dZdZdZdZdZdZdZdZdZd Z d Z dZdZd Z dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd Z d!Z!d"Z"d#Z#d$Z$d%Z%d&Z&d'Z'd(Z(d)Z)d*Z*d+Z+d,Z,d-Z-d.Z.d/Z/d0Z0d1Z1d2Z2d3Z3d4Z4d5Z5d6Z6d7Z7d8Z8d9Z9d:Z:d;Z;dZ>iZ?e@eA¦« B¦«¦«D] \ZCZDeEeD¦«eEd¦«ureCe?eD<Œ!d?„ZFd@„ZGdA„ZHdBS)Cz!Token constants (from "token.h").éééééééééé é ééé ééééééééééééééééééé é!é"é#é$é%é&é'é(é)é*é+é,é-é.é/é0é1é2é3é4é5é6é7é8é9é:é;é<écó—|tkS©N©Ú NT_OFFSET©Úxs ú:/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/token.pyÚ ISTERMINALrGOs€ØyŠ=Ðócó—|tkSrArBrDs rFÚ ISNONTERMINALrJRó€Ø• Š>ÐrHcó—|tkSrA)Ú ENDMARKERrDs rFÚISEOFrNUrKrHN)IÚ__doc__rMÚNAMEÚNUMBERÚSTRINGÚNEWLINEÚINDENTÚDEDENTÚLPARÚRPARÚLSQBÚRSQBÚCOLONÚCOMMAÚSEMIÚPLUSÚMINUSÚSTARÚSLASHÚVBARÚAMPERÚLESSÚGREATERÚEQUALÚDOTÚPERCENTÚ BACKQUOTEÚLBRACEÚRBRACEÚEQEQUALÚNOTEQUALÚ LESSEQUALÚGREATEREQUALÚTILDEÚ CIRCUMFLEXÚ LEFTSHIFTÚ RIGHTSHIFTÚ DOUBLESTARÚ PLUSEQUALÚMINEQUALÚ STAREQUALÚ SLASHEQUALÚPERCENTEQUALÚ AMPEREQUALÚ VBAREQUALÚCIRCUMFLEXEQUALÚLEFTSHIFTEQUALÚRIGHTSHIFTEQUALÚDOUBLESTAREQUALÚDOUBLESLASHÚDOUBLESLASHEQUALÚATÚATEQUALÚOPÚCOMMENTÚNLÚRARROWÚAWAITÚASYNCÚ ERRORTOKENÚ COLONEQUALÚN_TOKENSrCÚtok_nameÚlistÚglobalsÚitemsÚ_nameÚ_valueÚtyperGrJrN©rHrFúr”s×ðð(Ð'ð € Ø€Ø €Ø €Ø €Ø €Ø €Ø€Ø€Ø€Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø€Ø €Ø€ Ø €Ø €Ø €Ø €Ø€ Ø€Ø €Ø € Ø€ Ø € Ø € Ø€ Ø €Ø€ Ø € Ø€Ø € Ø€ Ø€Ø€Ø€Ø€Ø€ØÐØ€Ø €Ø€Ø €Ø€Ø €Ø €Ø €Ø € Ø € Ø €Ø€ ð€ØT˜'˜'™)œ)Ÿ/š/Ñ+Ô+Ñ,Ô,ð!ð!M€Eˆ6Ø€tˆF|„|tt˜A‘w”wÐÐØ ˆÑøðððððððððððrHPKhP3]Ç8)(ÈÈ'__pycache__/parse.cpython-311.opt-2.pycnu„[µü¤§ àÀfÛãóL— ddlmZGd„de¦«ZGd„de¦«ZdS)é)Útokencó—eZdZ d„Zd„ZdS)Ú ParseErrorc óŠ—t ||›d|›d|›d|›¦«||_||_||_||_dS)Nz: type=z, value=z , context=)Ú ExceptionÚ__init__ÚmsgÚtypeÚvalueÚcontext)Úselfr r rrs ú:/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/parse.pyrzParseError.__init__sX€Ý×Ò˜4Ø˜C˜C u u u¨g¨gð"7ñ 8ô 8ð 8àˆŒØˆŒ ØˆŒ ØˆŒˆˆócóT—t|¦«|j|j|j|jffS©N)r r rr)r s rÚ __reduce__zParseError.__reduce__s$€ÝD‰zŒz˜DœH d¤i°´¸T¼\ÐJÐJÐJrN)Ú__name__Ú __module__Ú__qualname__rr©rrrrs:€€€€€Ø2ððððKðKðKðKðKrrcó>—eZdZ d d„Zd d„Zd„Zd„Zd„Zd„Zd„Z dS) ÚParserNcó*— ||_|pd„|_dS)Ncó—|Srr)ÚgrammarÚnodes rúz!Parser.__init__..Zs€¸€r)rÚconvert)r rrs rrzParser.__init__<s$€ð ð8ˆŒØÐ>Ð#=Ð#=ˆŒˆˆrcóž— |€|jj}|ddgf}|jj|d|f}|g|_d|_t¦«|_dS)Né)rÚstartÚdfasÚstackÚrootnodeÚsetÚ used_names)r r!ÚnewnodeÚ stackentrys rÚsetupzParser.setup\s]€ð ðˆ=Ø”LÔ&ˆEð˜$ bÐ)ˆØ”lÔ'¨Ô.°°7Ð;ˆ Ø \ˆŒ ØˆŒ Ý™%œ%ˆŒˆˆrcóº— | |||¦«} |jd\}}}|\}} ||} | D]Ú\}}|jj|\} }||kro| ||||¦«|}||d|fgkrC| ¦«|jsdS|jd\}}}|\}} ||d|fgk°CdS| dkrE|jj| }|\}}||vr*| | |jj| ||¦«nGŒÛd|f| vr.| ¦«|jstd|||¦«‚ntd|||¦«‚ŒC)NTéÿÿÿÿr Féztoo much inputz bad input) Úclassifyr#rÚlabelsÚshiftÚpopr"Úpushr)r r rrÚilabelÚdfaÚstaterÚstatesÚfirstÚarcsÚiÚnewstateÚtÚvÚitsdfaÚ itsstatesÚitsfirsts rÚaddtokenzParser.addtokents»€ØJà—’˜t U¨GÑ4Ô4ˆð) HØ#œz¨"œ~ÑˆC˜Ø‰MˆFEØ˜%”=ˆDà#ð$ Hð$ H‘8Ø”|Ô*¨1Ô-‘1Ø˜Q’;;ð—J’J˜t U¨H°gÑ>Ô>Ð>à$EØ œ-¨Q°¨J¨<Ò7Ð7ØŸš™ œ ˜ Ø#œzð(à#' 4 4Ø+/¬:°b¬>Ñ(˜˜U DØ(+™ ˜ ð ! œ-¨Q°¨J¨<Ò7Ð7ð!˜5˜5Ø˜#’XXà!œ\Ô.¨qÔ1FØ*0Ñ'I˜xØ Ð)Ð)àŸ š ! T¤\Ô%6°qÔ%9¸8ÀWÑMÔMÐMØ˜øàu: Ð%Ð%à—H’H‘J”JJØœ:ð?å(Ð)9Ø)-¨u°gñ?ô?ð?ð?õ% [°$¸¸wÑGÔGÐGñS) Hrcó— |tjkr=|j |¦«|jj |¦«}||S|jj |¦«}|€td|||¦«‚|S)Nz bad token) rÚNAMEr&ÚaddrÚkeywordsÚgetÚtokensr)r r rrr2s rr-zParser.classify¤s€Ø4Ø•5”:ÒÐàŒO×Ò Ñ&Ô&Ð&à”\Ô*×.Ò.¨uÑ5Ô5ˆFØÐ!Ø Ø”Ô$×(Ò(¨Ñ.Ô.ˆØˆ>Ý˜[¨$°°wÑ?Ô?Ð?Øˆ rcóÀ— |jd\}}}|||df}| |j|¦«}||d |¦«|||f|jd<dS©Nr+)r#rrÚappend) r r rr9rr3r4rr's rr/zParser.shift²sl€Ø(Øœ: bœ>ÑˆˆUDØ˜ ¨Ð.ˆØ—,’,˜tœ|¨WÑ5Ô5ˆØÐØŒHOŠO˜GÑ$Ô$Ð$Ø˜x¨Ð.ˆŒ 2‰ˆˆrcóŠ— |jd\}}}|d|gf}|||f|jd<|j |d|f¦«dS)Nr+r )r#rH) r r Únewdfar9rr3r4rr's rr1zParser.push»sZ€Ø-Øœ: bœ>ÑˆˆUDØ˜˜w¨Ð+ˆØ˜x¨Ð.ˆŒ 2‰ØŒ ×Ò˜6 1 gÐ.Ñ/Ô/Ð/Ð/Ð/rcó— |j ¦«\}}}| |j|¦«}|O|jr.|jd\}}}|d |¦«dS||_|j|j_dSdSrG)r#r0rrrHr$r&)r ÚpopdfaÚpopstateÚpopnoder'r3r4rs rr0z Parser.popÂs‘€Ø,Ø$(¤J§N¢NÑ$4Ô$4Ñ!ˆ˜'Ø—,’,˜tœ|¨WÑ5Ô5ˆØÐØŒzð ;Ø#'¤:¨b¤>Ñ U˜DØR”—’ Ñ(Ô(Ð(Ð(Ð(à '” Ø+/¬?” Ô(Ð(Ð(ð Ðrr) rrrrr)r?r-r/r1r0rrrrrs‘€€€€€ðð:?ð?ð?ð?ð@ ð ð ð ð0.Hð.Hð.Hð`ððð/ð/ð/ð0ð0ð0ð ;ð ;ð ;ð ;ð ;rrN)ÚrrrÚobjectrrrrúrQsŽðððÐÐÐÐÐðKðKðKðKðKñKôKðKðn;ðn;ðn;ðn;ðn;ˆVñn;ôn;ðn;ðn;ðn;rPKhP3]@{¢?ë]ë]*__pycache__/tokenize.cpython-311.opt-1.pycnu„[µü¤§ àÀfRãóP—dZdZdZddlZddlZddlmZmZddlTddl m Z d „ee ¦«D¦«gd ¢zZ[ e n #e$reZ YnwxYwd„Zd„Zd „Zd„ZdZdZeedez¦«zee¦«zZdZdZdZdZedd¦«Zeeeee¦«ZdZedd¦«ee¦«zZdezZeee¦«Z ede dz¦«Z!ee!e e¦«Z"dZ#dZ$d Z%d!Z&d"Z'ee'd#ze'd$z¦«Z(ee'd%ze'd&z¦«Z)ed'd(d)d*d+d,d-d.d/¦ « Z*d0Z+ed1d2d3¦«Z,ee*e+e,¦«Z-ee"e-e)e¦«Z.ee.zZ/ee'd4zed5d¦«ze'd6zed7d¦«z¦«Z0edee(¦«Z1eee1e"e-e0e¦«zZ2e3ej4e/e2e%e&f¦«\Z5Z6Z7Z8ed8d9d:d;¦«ed8d9d£zZ9ej4e#¦«ej4e$¦«e7e8d?œd@„e9D¦«¥dA„e9D¦«¥dB„e9D¦«¥Z:d#d$hdC„e9D¦«zdD„e9D¦«zZ;d5d7hdE„e9D¦«zdF„e9D¦«zZ¦«Z?GdJ„dKe>¦«Z@dL„ZAeAfdM„ZBdN„ZCGdO„dP¦«ZDej4dQejE¦«ZFej4dRejE¦«ZGdS„ZHdT„ZIdU„ZJdV„ZKeLdWkrUddlMZMeNeMjO¦«dkr&eBePeMjOd¦«jQ¦«dSeBeMjRjQ¦«dSdS)XaÀTokenization help for Python programs. generate_tokens(readline) is a generator that breaks a stream of text into Python tokens. It accepts a readline-like method which is called repeatedly to get the next line of input (or "" for EOF). It generates 5-tuples with these members: the token type (see token.py) the token (a string) the starting (row, column) indices of the token (a 2-tuple of ints) the ending (row, column) indices of the token (a 2-tuple of ints) the original line (string) It is designed to match the working of the Python tokenizer exactly, except that it produces COMMENT tokens for comments and gives type OP for all operators Older entry points tokenize_loop(readline, tokeneater) tokenize(readline, tokeneater=printtoken) are the same, except instead of generating tokens, tokeneater is a callback function to which the 5 fields described above are passed as 5 arguments, each time a new token is found.zKa-Ping Yee z@GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, Skip MontanaroéN)ÚBOM_UTF8Úlookup)Ú*é)Útokencó*—g|]}|ddk¯|‘ŒS)rÚ_©)Ú.0Úxs ú=/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/tokenize.pyú r%s!€Ð 0Ð 0Ð 0 A a¤D¨C¢K Kˆ1 K K Kó)ÚtokenizeÚgenerate_tokensÚ untokenizecó8—dd |¦«zdzS)Nú(ú|ú))Újoin©Úchoicess r Úgroupr0s€˜C #§(¢(¨7Ñ"3Ô"3Ñ3°cÑ9Ð9rcó—t|ŽdzS)Nr©rrs r Úanyr1s€% ˜/¨CÑ/Ð/rcó—t|ŽdzS)Nú?rrs r Úmayber 2s€E 7˜O¨cÑ1Ð1rcó:‡—tˆfd„‰D¦«¦«S)Nc3ó†•K—|];}‰dzD]3}| ¦«| ¦«k¯,||zV—Œ4Œz _combinations..4s`øèè€ððØ ! e¡)ððØ¨q¯zªz©|¬|¸q¿zºz¹|¼|Ò/KÐ/KˆˆA‰Ð/KÐ/KÐ/KÐ/KÐ/Kððr)Úset)r&s`r Ú _combinationsr)3s;ø€ÝððððØðñôñôðrz[ \f\t]*z #[^\r\n]*z\\\r?\nz\w+z0[bB]_?[01]+(?:_[01]+)*z(0[xX]_?[\da-fA-F]+(?:_[\da-fA-F]+)*[lL]?z0[oO]?_?[0-7]+(?:_[0-7]+)*[lL]?z[1-9]\d*(?:_\d+)*[lL]?z0[lL]?z[eE][-+]?\d+(?:_\d+)*z\d+(?:_\d+)*\.(?:\d+(?:_\d+)*)?z\.\d+(?:_\d+)*z\d+(?:_\d+)*z\d+(?:_\d+)*[jJ]z[jJ]z[^'\\]*(?:\\.[^'\\]*)*'z[^"\\]*(?:\\.[^"\\]*)*"z%[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''z%[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""z'(?:[uUrRbBfF]|[rR][fFbB]|[fFbBuU][rR])?ú'''ú"""z'[^\n'\\]*(?:\\.[^\n'\\]*)*'z"[^\n"\\]*(?:\\.[^\n"\\]*)*"z\*\*=?z>>=?z<<=?z<>z!=z//=?z->z[+\-*/%&@|^=<>]=?ú~z[][(){}]z\r?\nz:=z[:;.,`@]z'[^\n'\\]*(?:\\.[^\n'\\]*)*ú'z"[^\n"\\]*(?:\\.[^\n"\\]*)*ú"ÚrÚRÚfÚFÚbÚB>ÚUÚuÚURÚUrÚuRÚur)r-r.r*r+có$—i|] }|›dt“ŒS©r*)Úsingle3prog©rÚprefixs r ú r@yó €ÐFÐFÐF¨v&ˆ~ˆ~ˆ~{ÐFÐFÐFrcó$—i|] }|›dt“ŒS©r+)Údouble3progr>s r r@r@zrArcó—i|]}|d“ŒS©Nr r>s r r@r@{s€Ð7Ð7Ð7 ˆvtÐ7Ð7Ð7rcó—h|]}|›d’ŒSr<r r>s r ú rHó€Ð/Ð/Ð/˜ˆ€^€^€^Ð/Ð/Ð/rcó—h|]}|›d’ŒSrCr r>s r rHrH€rIrcó—h|]}|›d’ŒS)r-r r>s r rHrH„ó€Ð-Ð-Ð-fˆ€\€\€\Ð-Ð-Ð-rcó—h|]}|›d’ŒS)r.r r>s r rHrH…rLrécó—eZdZdS)Ú TokenErrorN©Ú__name__Ú __module__Ú__qualname__r rr rPrPŠó€€€€€€€rrPcó—eZdZdS)ÚStopTokenizingNrQr rr rWrWŒrUrrWcóz—|\}}|\}}td||||t|t|¦«fz¦«dS)Nz%d,%d-%d,%d: %s %s)ÚprintÚtok_nameÚrepr) ÚtyperÚxxx_todo_changemeÚxxx_todo_changeme1ÚlineÚsrowÚscolÚerowÚecols r Ú printtokenrdŽsR€Ø$L€Tˆ4Ø%L€Tˆ4Ý Ð Ø ˆtT˜4¥¨$¤µ°e±´Ð=ñ>ñ?ô?ð?ð?ð?rcóJ— t||¦«dS#t$rYdSwxYw)a: The tokenize() function accepts two parameters: one representing the input stream, and one providing an output mechanism for tokenize(). The first parameter, readline, must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. The second parameter, tokeneater, must also be a callable object. It is called once for each token, with five arguments, corresponding to the tuples generated by generate_tokens(). N)Ú tokenize_looprW)ÚreadlineÚ tokeneaters r rr”s?€ð Ýh Ñ+Ô+Ð+Ð+Ð+øÝð ð ð Øˆˆð øøøs‚” "¡"có4—t|¦«D]}||ŽŒdSrF)r)rgrhÚ token_infos r rfrf§s3€Ý% hÑ/Ô/ð ð ˆ Øˆ JÐÐÐð ð rcó&—eZdZd„Zd„Zd„Zd„ZdS)ÚUntokenizercó0—g|_d|_d|_dS)Nrr)ÚtokensÚprev_rowÚprev_col)Úselfs r Ú__init__zUntokenizer.__init__s€ØˆŒØˆŒ ØˆŒ ˆ ˆ rcóf—|\}}||jz }|r|j d|z¦«dSdS)Nú )rprnÚappend)rqÚstartÚrowÚcolÚ col_offsets r Úadd_whitespacezUntokenizer.add_whitespace²sJ€Ø‰ˆˆSà˜4œ=Ñ(ˆ Øð 1ØŒK×Ò˜s ZÑ/Ñ0Ô0Ð0Ð0Ð0ð 1ð 1rcóp—|D]š}t|¦«dkr| ||¦«nn|\}}}}}| |¦«|j |¦«|\|_|_|ttfvr|xjdz c_d|_Œ›d |j¦«S)Nérrr#) ÚlenÚcompatrzrnrurorpÚNEWLINEÚNLr)rqÚiterableÚtÚtok_typerrvÚendr_s r rzUntokenizer.untokenize¹s¼€Øð "ð "ˆAÝ1‰vŒv˜Š{ˆ{Ø—’˜A˜xÑ(Ô(Ð(ØØ01Ñ-ˆHe˜U C¨Ø×Ò Ñ&Ô&Ð&ØŒK×Ò˜uÑ%Ô%Ð%Ø+.Ñ(ˆDŒM˜4œ=ØG¥R˜=Ð(Ð(Ø ” Ñ" ” Ø !” øØwŠwt”{Ñ#Ô#Ð#rcóÐ—d}g}|jj}|\}}|ttfvr|dz }|tt fvrd}|D]¦}|dd…\}}|ttttfvr|dz }|tkr| |¦«ŒQ|tkr| ¦«Œq|tt fvrd}n|r|r||d¦«d}||¦«Œ§dS)NFrtTr|éÿÿÿÿ)rnruÚNAMEÚNUMBERrr€ÚASYNCÚAWAITÚINDENTÚDEDENTÚpop) rqrrÚ startlineÚindentsÚtoks_appendÚtoknumÚtokvalÚtoks r r~zUntokenizer.compatÇs€Øˆ ØˆØ”kÔ(ˆØ‰ˆØ•dF^Ð#Ð#Øc‰MˆFØ•gr]Ð"Ð"ØˆIØð ð ˆCØ ! œW‰NˆFFà$¥uÐ5Ð5Ð5Ø˜#‘ àÒÐØ—’˜vÑ&Ô&Ð&ØØ6Ò!Ð!Ø—’‘ ” ØØG¥R˜=Ð(Ð(Ø Øð "˜wð "Ø˜G BœKÑ(Ô(Ð(Ø! ØˆK˜ÑÔÐÐð# ð rN)rRrSrTrrrzrr~r rr rlrl«sP€€€€€ðððð 1ð1ð1ð$ð$ð$ð ð ð ð ð rrlz&^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)s^[ \t\f]*(?:[#\r\n]|$)cóÖ—|dd… ¦« dd¦«}|dks| d¦«rdS|dvs| d¦«rd S|S) z(Imitates get_normal_name in tokenizer.c.Nér ú-úutf-8zutf-8-)zlatin-1ú iso-8859-1ziso-latin-1)zlatin-1-ziso-8859-1-ziso-latin-1-r˜)ÚlowerÚreplaceÚ startswith)Úorig_encÚencs r Ú_get_normal_nameržæsv€ð3B3Œ-× Ò Ñ Ô × 'Ò '¨¨SÑ 1Ô 1€CØ ˆg‚~€~˜Ÿš¨Ñ1Ô1€~ØˆwØ Ð6Ð6Ð6Ø ‡~‚~ÐAÑBÔBð7àˆ|Ø€OrcóL‡‡—dŠd}d}ˆfd„}ˆfd„}|¦«}| t¦«rdŠ|dd…}d}|s|gfS||¦«}|r||gfSt |¦«s||gfS|¦«}|s||gfS||¦«}|r|||gfS|||gfS) a The detect_encoding() function is used to detect the encoding that should be used to decode a Python source file. It requires one argument, readline, in the same way as the tokenize() generator. It will call readline a maximum of twice, and return the encoding used (as a string) and a list of any lines (left as bytes) it has read in. It detects the encoding from the presence of a utf-8 bom or an encoding cookie as specified in pep-0263. If both a bom and a cookie are present, but disagree, a SyntaxError will be raised. If the encoding cookie is an invalid charset, raise a SyntaxError. Note that if a utf-8 bom is found, 'utf-8-sig' is returned. If no encoding is specified, then the default of 'utf-8' will be returned. FNr—cóV•— ‰¦«S#t$rt¦«cYSwxYwrF)Ú StopIterationÚbytes)rgs€r Úread_or_stopz%detect_encoding..read_or_stops<ø€ð Ø8‘:”:ÐøÝð ð ð Ý‘7”7ˆNˆNˆNð øøøsƒ (§(có|•— | d¦«}n#t$rYdSwxYwt |¦«}|sdSt | d¦«¦«} t |¦«}n #t$rtd|z¦«‚wxYw‰r|j dkrtd¦«‚|dz }|S)NÚasciirzunknown encoding: r—zencoding problem: utf-8z-sig) ÚdecodeÚUnicodeDecodeErrorÚ cookie_reÚmatchržrrÚLookupErrorÚSyntaxErrorÚname)r_Úline_stringr©ÚencodingÚcodecÚ bom_founds €r Úfind_cookiez$detect_encoding..find_cookiesêø€ð ØŸ+š+ gÑ.Ô.ˆKˆKøÝ!ð ð ð Ø44ð øøøå—’ Ñ,Ô,ˆØð Ø4Ý# E§K¢K°¡N¤NÑ3Ô3ˆð ?Ý˜8Ñ$Ô$ˆEˆEøÝð ?ð ?ð ?åÐ2°XÑ=Ñ>Ô>Ð>ð ?øøøðð ØŒz˜WÒ$Ð$å!Ð";Ñ<Ô<Ð<Ø˜ÑˆHØˆsƒ™ '¦'Á+A;Á;BTéz utf-8-sig)r›rÚblank_rer©)rgr®Údefaultr£r±ÚfirstÚsecondr°s` @r Údetect_encodingr·ñs-øø€ð$€IØ€HØ€Gððððððððððð, ˆL‰NŒN€EØ×ÒÑ!Ô!ðØˆ Øabb” ˆØˆØðØ˜ˆ{Ðàˆ{˜5Ñ!Ô!€HØð!Ø˜%˜Ð Ð Ý>Š>˜%Ñ Ô ð Ø˜˜ÐÐà ˆ\‰^Œ^€FØð Ø˜˜ÐÐàˆ{˜6Ñ"Ô"€HØð)Ø˜% ˜Ð(Ð(àU˜FOÐ#Ð#rcóH—t¦«}| |¦«S)a«Transform tokens back into Python source code. Each element returned by the iterable must be a token sequence with at least two elements, a token number and token value. If only two tokens are passed, the resulting output is poor. Round-trip invariant for full input: Untokenized source will match input source exactly Round-trip invariant for limited input: # Output text will tokenize the back to the input t1 = [tok[:2] for tok in generate_tokens(f.readline)] newcode = untokenize(t1) readline = iter(newcode.splitlines(1)).next t2 = [tok[:2] for tokin generate_tokens(readline)] assert t1 == t2 )rlr)rÚuts r rr:s€õ$ ‰Œ€BØ =Š=˜Ñ"Ô"Ð"rc#ó²K—dx}x}}d\}}d}dg}d}d} d} d} |¦«}n#t$rd}YnwxYw|dz}dt|¦«}} |rµ|std|¦«‚| |¦«}|r>| d¦«x} }t ||d|…z|||f||zfV—d\}}d}nZ|rA|dd…d kr3|d d…dkr%t||z||t|¦«f|fV—d}d}Œá||z}||z}Œì|dkrï|sì|sn d}| |krO|| dkr|dz}n2|| d kr|tzdztz}n|| dkrd}nn| dz} | |k°O| |krnª|r|V—d}|| dvrÅ|| dkry|| d… d¦«}| t|¦«z}t||| f|| t|¦«zf|fV—t||d…||f|t|¦«f|fV—n>ttf|| dk|| d…|| f|t|¦«f|fV—Œ0||dkr/| |¦«t|d| …|df|| f|fV—||dkrT||vrtdd|| |f¦«‚|dd…}| r| |dkrd} d}d} td|| f|| f|fV—||dk°T| r|r| |dkrd} d}d} n|std|df¦«‚d}| |krt || ¦«}|r½| d¦«\}}||f||f|} }}|||…||}}|t"jvs|dkr|dkrt&||||fV—n|dvr,t(}|dkrt}n| rd}|r|V—d}|||||fV—nO|dkr|r|V—d}t||||fV—n1|t*vrpt,|}| || ¦«}|r9| d¦«} ||| …}|r|V—d}t |||| f|fV—nÊ||f}||d…}|}n¿|t.vs"|dd…t.vs|dd…t.vrk|ddkrG||f}t,|p%t,|dpt,|d}||d…d}}|}nA|r|V—d}t ||||fV—n"| ¦«r£|dvr| r|dkrt2nt4||||fV—Œt6||||f}|dkr|s|}Œ/|dvrW|rU|dt6krD|ddkr8|dkr d} |d} t2|d|d|d|dfV—d}|r|V—d}|V—nk|d kr|r|V—d}t|||| f|fV—d}nJ|d!vr|dz}n |d"vr|dz }|r|V—d}t8||||fV—n t|| || f|| dzf|fV—| dz} | |k°Œ|r|V—d}|dd…D]}td|df|dfdfV—Œt:d|df|dfdfV—dS)#a4 The generate_tokens() generator requires one argument, readline, which must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. Alternately, readline can be a callable function terminating with StopIteration: readline = open(myfile).next # Example of alternate readline The generator produces 5-tuples with these members: the token type; the token string; a 2-tuple (srow, scol) of ints specifying the row and column where the token begins in the source; a 2-tuple (erow, ecol) of ints specifying the row and column where the token ends in the source; and the line on which the token was found. The line passed is the physical line. r)r#rNFrr#zEOF in multi-line stringéþÿÿÿz\ éýÿÿÿz\ rtú úz# ú#z r†z3unindent does not match any outer indentation levelz zEOF in multi-line statementú.Tr|r²ú )ÚasyncÚawaitrÂ)ÚdefÚforrÄéú\z([{z)]})r¡r}rPr©r„ÚSTRINGÚ ERRORTOKENÚtabsizeÚrstripÚCOMMENTr€rur‹ÚIndentationErrorrŒÚ pseudoprogÚspanÚstringÚdigitsrˆrÚ triple_quotedÚendprogsÚ single_quotedÚisidentifierr‰rŠr‡ÚOPÚ ENDMARKER)rgÚlnumÚparenlevÚ continuedÚcontstrÚneedcontÚcontlinerÚstashedÚ async_defÚasync_def_indentÚasync_def_nlr_ÚposÚmaxÚstrstartÚendprogÚendmatchr„ÚcolumnÚ comment_tokenÚnl_posÚpseudomatchrvÚsposÚeposrÚinitialÚnewliner“Úindents r rrOsÆ èè€ð #$Ð#€DÐ#ˆ8iØÑ€GˆXØ€HØˆc€Gð€GØ€IØÐØ€Lð}ð Ø8‘:”:ˆDˆDøÝð ð ð ØˆDˆDˆDð øøøàa‰xˆØ•c˜$‘i”iˆSˆàðJ Øð GÝ Ð!;¸XÑFÔFÐFØ—}’} TÑ*Ô*ˆHØð Ø$ŸLšL¨™OœOÐ+cÝ˜w¨¨d¨s¨d¬Ñ3Ø $¨ ¨h¸©oð?ð?ð?ð?à$)Ñ!˜Ø‘Øð ˜d 2 3 3œi¨6Ò1Ð1°d¸2¸3¸3´iÀ8Ò6KÐ6KÝ! 7¨T¡>Ø# dC°©I¬IÐ%6¸ðBðBðBðBàØØà! D™.Ø# d™?Øà ˜Š]‰] 9‰]ØÐ™ØˆFØ˜’))Ø˜”9 Ò#Ð#¨f°q©j V VØ˜#”Y $Ò&Ð&°&½'±/ÀAÑ2EÅwÑ1N¨¨Ø˜#”Y $Ò&Ð&°¨¨ØØ˜A‘gð˜’))ðcŠzˆz™5àð Ø ØàCŒy˜GÐ#Ð#Ø˜”9 Ò#Ð#Ø$(¨¨¨¤J×$5Ò$5°fÑ$=Ô$=MØ ¥3 }Ñ#5Ô#5Ñ5FÝ" MØ #˜;¨¨sµS¸Ñ5GÔ5GÑ/GÐ(HÈ$ðPðPðPðPå˜t F G Gœ}Ø &˜>¨Dµ#°d±)´)Ð+<¸dðDðDðDðDðDõ¥˜=¨¨c¬°cÒ)9Ô:¸DÀÀÀ¼JØ #˜;¨s°4©y¬yÐ(9¸4ðAðAðAðAáà˜ œÒ#Ð#Ø—’˜vÑ&Ô&Ð&Ý˜t D S Dœz¨D°!¨9°t¸S°kÀ4ÐHÐHÐHÐHØ˜7 2œ;Ò&Ð&Ø Ð(Ð(Ý*ØMØ% t¨S°$Ð7ñ9ô9ð9ð" # 2 #œ,àð)Ð!1°W¸R´[Ò!@Ð!@Ø %IØ#(LØ'(Ð$å˜r D¨# ;°°s°¸TÐBÐBÐBÐBð˜7 2œ;Ò&Ð&ðð %˜\ð %Ð.>À'È"Ä+Ò.MÐ.MØ! Ø$Ø#$Ð øðð KÝ Ð!>ÀÀqÀ ÑJÔJÐJØˆIàCŠi‰iÝ$×*Ò*¨4°Ñ5Ô5ˆKØñg Ø(×-Ò-¨aÑ0Ô0‘ sØ#'¨ -°$¸°¸c˜CdØ!% e¨C i¤°$°u´+wàfœmÐ+Ð+Ø˜s’NN u°¢| |Ý! 5¨$°°dÐ;Ð;Ð;Ð;Ñ;Ø Ð&Ð&Ý%GØ !’||Ý"$˜˜Ø"ð,Ø'+˜Øð'Ø%˜ ˜ ˜ Ø"&˜Ø" E¨4°°tÐ<Ð<Ð<Ð<Ñ<à ’^^àð'Ø%˜ ˜ ˜ Ø"&˜Ý" E¨4°°tÐ<Ð<Ð<Ð<Ñ<ØmÐ+Ð+Ý& uœoGØ&Ÿ}š}¨T°3Ñ7Ô7HØðØ&Ÿlšl¨1™oœo˜Ø $ U¨3 Y¤˜Ø"ð+Ø")˜M˜M˜MØ&*˜GÝ% u¨d°T¸3°KÀÐFÐFÐFÐFÑFà$(¨% =˜Ø"& u v v¤,˜Ø#'˜ÙØ¥ Ð-Ð-Ø˜"˜1˜"”I¥Ð.Ð.Ø˜"˜1˜"”I¥Ð.Ð.Ø˜R”y DÒ(Ð(Ø$(¨% =˜Ý#+¨GÔ#4ð$6½ÀÀqÄÔ8Jð$6Ý#+¨E°!¬HÔ#5ð à,0°°°¬L¸! ˜Ø#'˜Ùà"ð+Ø")˜M˜M˜MØ&*˜GÝ% u¨d°D¸$Ð?Ð?Ð?Ð?Ñ?Ø×)Ò)Ñ+Ô+ð,8ØÐ 2Ð2Ð2Ø$ð%Ø,1°WÒ,<Ð,<¥5 5Å%Ø#(¨$°°dð#<ð<ð<ð<á$å ¨¨d°DÐ9CØ Ò'Ð'°Ð'Ø"%˜Ù à Ð.Ð.Ø#ð+Ø$+¨A¤Jµ$Ò$6Ð$6Ø$+¨A¤J°'Ò$9Ð$9à$¨š~˜~Ø,0 Ø3:¸2´;Ð 0å#(¨'°!¬*Ø#*¨1¤:¨w°q¬zØ#*¨1¤:ð#/ð/ð/ð/ð'+˜Gàð'Ø%˜ ˜ ˜ Ø"&˜àIIIIØ ’__àð'Ø%˜ ˜ ˜ Ø"&˜Ý˜u d¨T°3¨K¸Ð>Ð>Ð>Ð>Ø !IIà %Ð'Ð'°H¸q±L¨¨Ø EÐ)Ð)°hÀ±l¨8Øð'Ø%˜ ˜ ˜ Ø"&˜Ý˜u d¨D°$Ð7Ð7Ð7Ð7Ð7å! 4¨¤9Ø #˜;¨¨s°1©u¨ °tð=ð=ð=ð=à˜A‘gðSCŠi‰iñi}ð~ðØˆ ˆ ˆ Øˆà˜!˜"˜"”+ð5ð5ˆÝr˜D !˜9 t¨Q i°Ð4Ð4Ð4Ð4Ð4Ýb˜4 ˜) d¨A Y°Ð 3Ð3Ð3Ð3Ð3Ð3s (¨7¶7Ú__main__)SÚ__doc__Ú __author__Ú__credits__rÐÚreÚcodecsrrÚlib2to3.pgen2.tokenr#rÚdirÚ__all__r¢Ú NameErrorÚstrrrr r)Ú WhitespaceÚCommentÚIgnoreÚNameÚ BinnumberÚ HexnumberÚ OctnumberÚ DecnumberÚ IntnumberÚExponentÚ PointfloatÚExpfloatÚFloatnumberÚ ImagnumberÚNumberÚSingleÚDoubleÚSingle3ÚDouble3Ú _litprefixÚTripleÚStringÚOperatorÚBracketÚSpecialÚFunnyÚ PlainTokenÚTokenÚContStrÚPseudoExtrasÚPseudoTokenÚmapÚcompileÚ tokenprogrÎr=rDÚ_strprefixesrÓrÒrÔrÊÚ ExceptionrPrWrdrrfrlÚASCIIr¨r³ržr·rrrRÚsysr}ÚargvÚopenrgÚstdinr rr úr$s÷ðð#ð#ð0*€ àFððÐÐÐÐÐÐÐØ#Ð#Ð#Ð#Ð#Ð#Ð#Ð#Ø!Ð!Ð!Ð!àÐÐÐÐÐØ 0Ð 0cc˜%‘j”jÐ 0Ñ 0Ô 0ð4,ð4,ð4,ñ,€à ðØ €E€EøØðððð €E€E€Eðøøøð :Ð9Ð9Ø/Ð/Ð/Ø1Ð1Ð1ðððð € Ø €Ø cc˜* zÑ1Ñ2Ô2Ñ 2°U°U¸7±^´^Ñ C€Ø €à&€ Ø7€ Ø.€ ØˆEÐ+¨XÑ6Ô6€ ØˆE)˜Y¨ °9Ñ=Ô=€ Ø#€Ø ˆUÐ5Ð7HÑ IÔ IÈEÈEÐRZÉOÌOÑ [€ Ø˜XÑ%€ØˆeJ Ñ)Ô)€Ø ˆUÐ&¨°gÑ(=Ñ >Ô >€ Ø ˆˆz˜;¨ Ñ 2Ô 2€ð $€à #€à 2€à 2€Ø 7€ Ø ˆˆz˜EÑ! :°Ñ#5Ñ 6Ô 6€à ˆˆzÐ;Ñ;ØÐ;Ñ;ñ =ô =€ðˆ5˜G W¨e°UØ˜%Ø%Øñô€ð €Ø ˆ%˜% Ñ -Ô -€Ø ˆˆh˜ Ñ)Ô)€à ˆU6˜5 &¨$Ñ /Ô /€ ØÑ€ðˆ% Ð;Ñ;Øc˜:Ñ&Ô&ñ'àÐ;Ñ;Øc˜:Ñ&Ô&ñ'ñ(ô(€ðˆuZ ¨&Ñ1Ô1€Ø˜5˜5 ¨v°u¸gÀtÑLÔLÑL€à25°#Ø„J˜ W¨gÐ6ñ38ô38Ñ/€ ˆ:{ Kð€M#s˜C Ñ%Ô%Ø€M#s˜C Ñ%Ô%ñ&à&Ð&Ð&ñ'ð ð”˜FÑ#Ô#¨*¨"¬*°VÑ*<Ô*<Ø {ð9ð9àFÐF¸ÐFÑFÔFð9ðGÐF¸ÐFÑFÔFð9ð8Ð7¨,Ð7Ñ7Ô7ð 9€ðˆE€NØ/Ð/ ,Ð/Ñ/Ô/ñ0à/Ð/ ,Ð/Ñ/Ô/ñ0ðð ˆ#€JØ-Ð- Ð-Ñ-Ô-ñ.à-Ð- Ð-Ñ-Ô-ñ.ðð€à!Ð!Ð!Ð!Ð!Ñ!Ô!Ð!à%Ð%Ð%Ð%Ð%YÑ%Ô%Ð%ð?ð?ð?ð#-ð ð ð ð ð& ð ð ð6 ð6 ð6 ð6 ð6 ñ6 ô6 ð6 ðp ˆBŒJÐ@À"Ä(ÑKÔK€ Øˆ2Œ:Ð0°"´(Ñ;Ô;€ð ð ð ðG$ðG$ðG$ðR#ð#ð#ð*`4ð`4ð`4ðDˆzÒÐØ€J€J€JØ €sˆ3Œ8}„}qÒÐ˜(˜( 4 4¨¬°¬Ñ#4Ô#4Ô#=Ñ>Ô>Ð>Ð>Ð>Ø ˆ(3”9Ô%Ñ &Ô &Ð &Ð &Ð &ðÐs½AÁA Á A PKhP3]³“õ[c^c^$__pycache__/tokenize.cpython-311.pycnu„[µü¤§ àÀfRãóP—dZdZdZddlZddlZddlmZmZddlTddl m Z d „ee ¦«D¦«gd ¢zZ[ e n #e$reZ YnwxYwd„Zd„Zd „Zd„ZdZdZeedez¦«zee¦«zZdZdZdZdZedd¦«Zeeeee¦«ZdZedd¦«ee¦«zZdezZeee¦«Z ede dz¦«Z!ee!e e¦«Z"dZ#dZ$d Z%d!Z&d"Z'ee'd#ze'd$z¦«Z(ee'd%ze'd&z¦«Z)ed'd(d)d*d+d,d-d.d/¦ « Z*d0Z+ed1d2d3¦«Z,ee*e+e,¦«Z-ee"e-e)e¦«Z.ee.zZ/ee'd4zed5d¦«ze'd6zed7d¦«z¦«Z0edee(¦«Z1eee1e"e-e0e¦«zZ2e3ej4e/e2e%e&f¦«\Z5Z6Z7Z8ed8d9d:d;¦«ed8d9d£zZ9ej4e#¦«ej4e$¦«e7e8d?œd@„e9D¦«¥dA„e9D¦«¥dB„e9D¦«¥Z:d#d$hdC„e9D¦«zdD„e9D¦«zZ;d5d7hdE„e9D¦«zdF„e9D¦«zZ¦«Z?GdJ„dKe>¦«Z@dL„ZAeAfdM„ZBdN„ZCGdO„dP¦«ZDej4dQejE¦«ZFej4dRejE¦«ZGdS„ZHdT„ZIdU„ZJdV„ZKeLdWkrUddlMZMeNeMjO¦«dkr&eBePeMjOd¦«jQ¦«dSeBeMjRjQ¦«dSdS)XaÀTokenization help for Python programs. generate_tokens(readline) is a generator that breaks a stream of text into Python tokens. It accepts a readline-like method which is called repeatedly to get the next line of input (or "" for EOF). It generates 5-tuples with these members: the token type (see token.py) the token (a string) the starting (row, column) indices of the token (a 2-tuple of ints) the ending (row, column) indices of the token (a 2-tuple of ints) the original line (string) It is designed to match the working of the Python tokenizer exactly, except that it produces COMMENT tokens for comments and gives type OP for all operators Older entry points tokenize_loop(readline, tokeneater) tokenize(readline, tokeneater=printtoken) are the same, except instead of generating tokens, tokeneater is a callback function to which the 5 fields described above are passed as 5 arguments, each time a new token is found.zKa-Ping Yee z@GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, Skip MontanaroéN)ÚBOM_UTF8Úlookup)Ú*é)Útokencó*—g|]}|ddk¯|‘ŒS)rÚ_©)Ú.0Úxs ú=/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/tokenize.pyú r%s!€Ð 0Ð 0Ð 0 A a¤D¨C¢K Kˆ1 K K Kó)ÚtokenizeÚgenerate_tokensÚ untokenizecó8—dd |¦«zdzS)Nú(ú|ú))Újoin©Úchoicess r Úgroupr0s€˜C #§(¢(¨7Ñ"3Ô"3Ñ3°cÑ9Ð9rcó—t|ŽdzS)Nr©rrs r Úanyr1s€% ˜/¨CÑ/Ð/rcó—t|ŽdzS)Nú?rrs r Úmayber 2s€E 7˜O¨cÑ1Ð1rcó:‡—tˆfd„‰D¦«¦«S)Nc3ó†•K—|];}‰dzD]3}| ¦«| ¦«k¯,||zV—Œ4Œz _combinations..4s`øèè€ððØ ! e¡)ððØ¨q¯zªz©|¬|¸q¿zºz¹|¼|Ò/KÐ/KˆˆA‰Ð/KÐ/KÐ/KÐ/KÐ/Kððr)Úset)r&s`r Ú _combinationsr)3s;ø€ÝððððØðñôñôðrz[ \f\t]*z #[^\r\n]*z\\\r?\nz\w+z0[bB]_?[01]+(?:_[01]+)*z(0[xX]_?[\da-fA-F]+(?:_[\da-fA-F]+)*[lL]?z0[oO]?_?[0-7]+(?:_[0-7]+)*[lL]?z[1-9]\d*(?:_\d+)*[lL]?z0[lL]?z[eE][-+]?\d+(?:_\d+)*z\d+(?:_\d+)*\.(?:\d+(?:_\d+)*)?z\.\d+(?:_\d+)*z\d+(?:_\d+)*z\d+(?:_\d+)*[jJ]z[jJ]z[^'\\]*(?:\\.[^'\\]*)*'z[^"\\]*(?:\\.[^"\\]*)*"z%[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''z%[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""z'(?:[uUrRbBfF]|[rR][fFbB]|[fFbBuU][rR])?ú'''ú"""z'[^\n'\\]*(?:\\.[^\n'\\]*)*'z"[^\n"\\]*(?:\\.[^\n"\\]*)*"z\*\*=?z>>=?z<<=?z<>z!=z//=?z->z[+\-*/%&@|^=<>]=?ú~z[][(){}]z\r?\nz:=z[:;.,`@]z'[^\n'\\]*(?:\\.[^\n'\\]*)*ú'z"[^\n"\\]*(?:\\.[^\n"\\]*)*ú"ÚrÚRÚfÚFÚbÚB>ÚUÚuÚURÚUrÚuRÚur)r-r.r*r+có$—i|] }|›dt“ŒS©r*)Úsingle3prog©rÚprefixs r ú r@yó €ÐFÐFÐF¨v&ˆ~ˆ~ˆ~{ÐFÐFÐFrcó$—i|] }|›dt“ŒS©r+)Údouble3progr>s r r@r@zrArcó—i|]}|d“ŒS©Nr r>s r r@r@{s€Ð7Ð7Ð7 ˆvtÐ7Ð7Ð7rcó—h|]}|›d’ŒSr<r r>s r ú rHó€Ð/Ð/Ð/˜ˆ€^€^€^Ð/Ð/Ð/rcó—h|]}|›d’ŒSrCr r>s r rHrH€rIrcó—h|]}|›d’ŒS)r-r r>s r rHrH„ó€Ð-Ð-Ð-fˆ€\€\€\Ð-Ð-Ð-rcó—h|]}|›d’ŒS)r.r r>s r rHrH…rLrécó—eZdZdS)Ú TokenErrorN©Ú__name__Ú __module__Ú__qualname__r rr rPrPŠó€€€€€€€rrPcó—eZdZdS)ÚStopTokenizingNrQr rr rWrWŒrUrrWcóz—|\}}|\}}td||||t|t|¦«fz¦«dS)Nz%d,%d-%d,%d: %s %s)ÚprintÚtok_nameÚrepr) ÚtyperÚxxx_todo_changemeÚxxx_todo_changeme1ÚlineÚsrowÚscolÚerowÚecols r Ú printtokenrdŽsR€Ø$L€Tˆ4Ø%L€Tˆ4Ý Ð Ø ˆtT˜4¥¨$¤µ°e±´Ð=ñ>ñ?ô?ð?ð?ð?rcóJ— t||¦«dS#t$rYdSwxYw)a: The tokenize() function accepts two parameters: one representing the input stream, and one providing an output mechanism for tokenize(). The first parameter, readline, must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. The second parameter, tokeneater, must also be a callable object. It is called once for each token, with five arguments, corresponding to the tuples generated by generate_tokens(). N)Ú tokenize_looprW)ÚreadlineÚ tokeneaters r rr”s?€ð Ýh Ñ+Ô+Ð+Ð+Ð+øÝð ð ð Øˆˆð øøøs‚” "¡"có4—t|¦«D]}||ŽŒdSrF)r)rgrhÚ token_infos r rfrf§s3€Ý% hÑ/Ô/ð ð ˆ Øˆ JÐÐÐð ð rcó&—eZdZd„Zd„Zd„Zd„ZdS)ÚUntokenizercó0—g|_d|_d|_dS)Nrr)ÚtokensÚprev_rowÚprev_col)Úselfs r Ú__init__zUntokenizer.__init__s€ØˆŒØˆŒ ØˆŒ ˆ ˆ rcó€—|\}}||jksJ‚||jz }|r|j d|z¦«dSdS)Nú )rorprnÚappend)rqÚstartÚrowÚcolÚ col_offsets r Úadd_whitespacezUntokenizer.add_whitespace²s]€Ø‰ˆˆSØd”mÒ#Ð#Ð#Ð#Ø˜4œ=Ñ(ˆ Øð 1ØŒK×Ò˜s ZÑ/Ñ0Ô0Ð0Ð0Ð0ð 1ð 1rcóp—|D]š}t|¦«dkr| ||¦«nn|\}}}}}| |¦«|j |¦«|\|_|_|ttfvr|xjdz c_d|_Œ›d |j¦«S)Nérrr#) ÚlenÚcompatrzrnrurorpÚNEWLINEÚNLr)rqÚiterableÚtÚtok_typerrvÚendr_s r rzUntokenizer.untokenize¹s¼€Øð "ð "ˆAÝ1‰vŒv˜Š{ˆ{Ø—’˜A˜xÑ(Ô(Ð(ØØ01Ñ-ˆHe˜U C¨Ø×Ò Ñ&Ô&Ð&ØŒK×Ò˜uÑ%Ô%Ð%Ø+.Ñ(ˆDŒM˜4œ=ØG¥R˜=Ð(Ð(Ø ” Ñ" ” Ø !” øØwŠwt”{Ñ#Ô#Ð#rcóÐ—d}g}|jj}|\}}|ttfvr|dz }|tt fvrd}|D]¦}|dd…\}}|ttttfvr|dz }|tkr| |¦«ŒQ|tkr| ¦«Œq|tt fvrd}n|r|r||d¦«d}||¦«Œ§dS)NFrtTr|éÿÿÿÿ)rnruÚNAMEÚNUMBERrr€ÚASYNCÚAWAITÚINDENTÚDEDENTÚpop) rqrrÚ startlineÚindentsÚtoks_appendÚtoknumÚtokvalÚtoks r r~zUntokenizer.compatÇs€Øˆ ØˆØ”kÔ(ˆØ‰ˆØ•dF^Ð#Ð#Øc‰MˆFØ•gr]Ð"Ð"ØˆIØð ð ˆCØ ! œW‰NˆFFà$¥uÐ5Ð5Ð5Ø˜#‘ àÒÐØ—’˜vÑ&Ô&Ð&ØØ6Ò!Ð!Ø—’‘ ” ØØG¥R˜=Ð(Ð(Ø Øð "˜wð "Ø˜G BœKÑ(Ô(Ð(Ø! ØˆK˜ÑÔÐÐð# ð rN)rRrSrTrrrzrr~r rr rlrl«sP€€€€€ðððð 1ð1ð1ð$ð$ð$ð ð ð ð ð rrlz&^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)s^[ \t\f]*(?:[#\r\n]|$)cóÖ—|dd… ¦« dd¦«}|dks| d¦«rdS|dvs| d¦«rd S|S) z(Imitates get_normal_name in tokenizer.c.Nér ú-úutf-8zutf-8-)zlatin-1ú iso-8859-1ziso-latin-1)zlatin-1-ziso-8859-1-ziso-latin-1-r˜)ÚlowerÚreplaceÚ startswith)Úorig_encÚencs r Ú_get_normal_nameržæsv€ð3B3Œ-× Ò Ñ Ô × 'Ò '¨¨SÑ 1Ô 1€CØ ˆg‚~€~˜Ÿš¨Ñ1Ô1€~ØˆwØ Ð6Ð6Ð6Ø ‡~‚~ÐAÑBÔBð7àˆ|Ø€OrcóL‡‡—dŠd}d}ˆfd„}ˆfd„}|¦«}| t¦«rdŠ|dd…}d}|s|gfS||¦«}|r||gfSt |¦«s||gfS|¦«}|s||gfS||¦«}|r|||gfS|||gfS) a The detect_encoding() function is used to detect the encoding that should be used to decode a Python source file. It requires one argument, readline, in the same way as the tokenize() generator. It will call readline a maximum of twice, and return the encoding used (as a string) and a list of any lines (left as bytes) it has read in. It detects the encoding from the presence of a utf-8 bom or an encoding cookie as specified in pep-0263. If both a bom and a cookie are present, but disagree, a SyntaxError will be raised. If the encoding cookie is an invalid charset, raise a SyntaxError. Note that if a utf-8 bom is found, 'utf-8-sig' is returned. If no encoding is specified, then the default of 'utf-8' will be returned. FNr—cóV•— ‰¦«S#t$rt¦«cYSwxYwrF)Ú StopIterationÚbytes)rgs€r Úread_or_stopz%detect_encoding..read_or_stops<ø€ð Ø8‘:”:ÐøÝð ð ð Ý‘7”7ˆNˆNˆNð øøøsƒ (§(có|•— | d¦«}n#t$rYdSwxYwt |¦«}|sdSt | d¦«¦«} t |¦«}n #t$rtd|z¦«‚wxYw‰r|j dkrtd¦«‚|dz }|S)NÚasciirzunknown encoding: r—zencoding problem: utf-8z-sig) ÚdecodeÚUnicodeDecodeErrorÚ cookie_reÚmatchržrrÚLookupErrorÚSyntaxErrorÚname)r_Úline_stringr©ÚencodingÚcodecÚ bom_founds €r Úfind_cookiez$detect_encoding..find_cookiesêø€ð ØŸ+š+ gÑ.Ô.ˆKˆKøÝ!ð ð ð Ø44ð øøøå—’ Ñ,Ô,ˆØð Ø4Ý# E§K¢K°¡N¤NÑ3Ô3ˆð ?Ý˜8Ñ$Ô$ˆEˆEøÝð ?ð ?ð ?åÐ2°XÑ=Ñ>Ô>Ð>ð ?øøøðð ØŒz˜WÒ$Ð$å!Ð";Ñ<Ô<Ð<Ø˜ÑˆHØˆsƒ™ '¦'Á+A;Á;BTéz utf-8-sig)r›rÚblank_rer©)rgr®Údefaultr£r±ÚfirstÚsecondr°s` @r Údetect_encodingr·ñs-øø€ð$€IØ€HØ€Gððððððððððð, ˆL‰NŒN€EØ×ÒÑ!Ô!ðØˆ Øabb” ˆØˆØðØ˜ˆ{Ðàˆ{˜5Ñ!Ô!€HØð!Ø˜%˜Ð Ð Ý>Š>˜%Ñ Ô ð Ø˜˜ÐÐà ˆ\‰^Œ^€FØð Ø˜˜ÐÐàˆ{˜6Ñ"Ô"€HØð)Ø˜% ˜Ð(Ð(àU˜FOÐ#Ð#rcóH—t¦«}| |¦«S)a«Transform tokens back into Python source code. Each element returned by the iterable must be a token sequence with at least two elements, a token number and token value. If only two tokens are passed, the resulting output is poor. Round-trip invariant for full input: Untokenized source will match input source exactly Round-trip invariant for limited input: # Output text will tokenize the back to the input t1 = [tok[:2] for tok in generate_tokens(f.readline)] newcode = untokenize(t1) readline = iter(newcode.splitlines(1)).next t2 = [tok[:2] for tokin generate_tokens(readline)] assert t1 == t2 )rlr)rÚuts r rr:s€õ$ ‰Œ€BØ =Š=˜Ñ"Ô"Ð"rc#óÖK—dx}x}}d\}}d}dg}d}d} d} d} |¦«}n#t$rd}YnwxYw|dz}dt|¦«}} |rµ|std|¦«‚| |¦«}|r>| d¦«x} }t ||d|…z|||f||zfV—d\}}d}nZ|rA|dd…d kr3|d d…dkr%t||z||t|¦«f|fV—d}d}Œá||z}||z}Œì|dkrï|sì|snd}| |krO|| dkr|dz}n2|| d kr|tzdztz}n|| dkrd}nn| dz} | |k°O| |krn¼|r|V—d}|| dvrÅ|| dkry|| d… d¦«}| t|¦«z}t||| f|| t|¦«zf|fV—t||d…||f|t|¦«f|fV—n>ttf|| dk|| d…|| f|t|¦«f|fV—Œ0||dkr/| |¦«t|d| …|df|| f|fV—||dkrT||vrtdd|| |f¦«‚|dd…}| r| |dkrd} d}d} td|| f|| f|fV—||dk°T| r|r| |dkrd} d}d} n|std|df¦«‚d}| |krt || ¦«}|rÏ| d¦«\}}||f||f|} }}|||…||}}|t"jvs|dkr|dkrt&||||fV—n‘|dvr,t(}|dkrt}n| rd}|r|V—d}|||||fV—na|dkr*|jd¦«rJ‚|r|V—d}t||||fV—n1|t,vrpt.|}| || ¦«}|r9| d¦«} ||| …}|r|V—d}t |||| f|fV—nÊ||f}||d…}|}n¿|t0vs"|dd…t0vs|dd…t0vrk|ddkrG||f}t.|p%t.|dpt.|d}||d…d}}|}nA|r|V—d}t ||||fV—n"| ¦«r£|dvr| r|dkrt4nt6||||fV—Œ)t8||||f}|dkr|s|}ŒA|dvrW|rU|dt8krD|ddkr8|dkr d} |d} t4|d|d|d|dfV—d}|r|V—d}|V—nk|d kr|r|V—d}t|||| f|fV—d}nJ|d!vr|dz}n |d"vr|dz }|r|V—d}t:||||fV—n t|| || f|| dzf|fV—| dz} | |k°Œ|r|V—d}|dd…D]}td|df|dfdfV—Œt<d|df|dfdfV—dS)#a4 The generate_tokens() generator requires one argument, readline, which must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. Alternately, readline can be a callable function terminating with StopIteration: readline = open(myfile).next # Example of alternate readline The generator produces 5-tuples with these members: the token type; the token string; a 2-tuple (srow, scol) of ints specifying the row and column where the token begins in the source; a 2-tuple (erow, ecol) of ints specifying the row and column where the token ends in the source; and the line on which the token was found. The line passed is the physical line. r)r#rNFrr#zEOF in multi-line stringéþÿÿÿz\ éýÿÿÿz\ rtú úz# ú#z r†z3unindent does not match any outer indentation levelz zEOF in multi-line statementú.Tú r|r²)ÚasyncÚawaitrÂ)ÚdefÚforrÄéú\z([{z)]})r¡r}rPr©r„ÚSTRINGÚ ERRORTOKENÚtabsizeÚrstripÚCOMMENTr€rur‹ÚIndentationErrorrŒÚ pseudoprogÚspanÚstringÚdigitsrˆrÚendswithÚ triple_quotedÚendprogsÚ single_quotedÚisidentifierr‰rŠr‡ÚOPÚ ENDMARKER)rgÚlnumÚparenlevÚ continuedÚcontstrÚneedcontÚcontlinerÚstashedÚ async_defÚasync_def_indentÚasync_def_nlr_ÚposÚmaxÚstrstartÚendprogÚendmatchr„ÚcolumnÚ comment_tokenÚnl_posÚpseudomatchrvÚsposÚeposrÚinitialÚnewliner“Úindents r rrOsÞ èè€ð #$Ð#€DÐ#ˆ8iØÑ€GˆXØ€HØˆc€Gð€GØ€IØÐØ€Lð}ð Ø8‘:”:ˆDˆDøÝð ð ð ØˆDˆDˆDð øøøàa‰xˆØ•c˜$‘i”iˆSˆàðJ Øð GÝ Ð!;¸XÑFÔFÐFØ—}’} TÑ*Ô*ˆHØð Ø$ŸLšL¨™OœOÐ+cÝ˜w¨¨d¨s¨d¬Ñ3Ø $¨ ¨h¸©oð?ð?ð?ð?à$)Ñ!˜Ø‘Øð ˜d 2 3 3œi¨6Ò1Ð1°d¸2¸3¸3´iÀ8Ò6KÐ6KÝ! 7¨T¡>Ø# dC°©I¬IÐ%6¸ðBðBðBðBàØØà! D™.Ø# d™?Øà ˜Š]‰] 9‰]ØÐ™ØˆFØ˜’))Ø˜”9 Ò#Ð#¨f°q©j V VØ˜#”Y $Ò&Ð&°&½'±/ÀAÑ2EÅwÑ1N¨¨Ø˜#”Y $Ò&Ð&°¨¨ØØ˜A‘gð˜’))ðcŠzˆz™5àð Ø ØàCŒy˜GÐ#Ð#Ø˜”9 Ò#Ð#Ø$(¨¨¨¤J×$5Ò$5°fÑ$=Ô$=MØ ¥3 }Ñ#5Ô#5Ñ5FÝ" MØ #˜;¨¨sµS¸Ñ5GÔ5GÑ/GÐ(HÈ$ðPðPðPðPå˜t F G Gœ}Ø &˜>¨Dµ#°d±)´)Ð+<¸dðDðDðDðDðDõ¥˜=¨¨c¬°cÒ)9Ô:¸DÀÀÀ¼JØ #˜;¨s°4©y¬yÐ(9¸4ðAðAðAðAáà˜ œÒ#Ð#Ø—’˜vÑ&Ô&Ð&Ý˜t D S Dœz¨D°!¨9°t¸S°kÀ4ÐHÐHÐHÐHØ˜7 2œ;Ò&Ð&Ø Ð(Ð(Ý*ØMØ% t¨S°$Ð7ñ9ô9ð9ð" # 2 #œ,àð)Ð!1°W¸R´[Ò!@Ð!@Ø %IØ#(LØ'(Ð$å˜r D¨# ;°°s°¸TÐBÐBÐBÐBð˜7 2œ;Ò&Ð&ðð %˜\ð %Ð.>À'È"Ä+Ò.MÐ.MØ! Ø$Ø#$Ð øðð KÝ Ð!>ÀÀqÀ ÑJÔJÐJØˆIàCŠi‰iÝ$×*Ò*¨4°Ñ5Ô5ˆKØñg Ø(×-Ò-¨aÑ0Ô0‘ sØ#'¨ -°$¸°¸c˜CdØ!% e¨C i¤°$°u´+wàfœmÐ+Ð+Ø˜s’NN u°¢| |Ý! 5¨$°°dÐ;Ð;Ð;Ð;Ñ;Ø Ð&Ð&Ý%GØ !’||Ý"$˜˜Ø"ð,Ø'+˜Øð'Ø%˜ ˜ ˜ Ø"&˜Ø" E¨4°°tÐ<Ð<Ð<Ð<Ñ<à ’^^Ø-˜uœ~¨dÑ3Ô3Ð3Ð3Ð3Øð'Ø%˜ ˜ ˜ Ø"&˜Ý" E¨4°°tÐ<Ð<Ð<Ð<Ñ<ØmÐ+Ð+Ý& uœoGØ&Ÿ}š}¨T°3Ñ7Ô7HØðØ&Ÿlšl¨1™oœo˜Ø $ U¨3 Y¤˜Ø"ð+Ø")˜M˜M˜MØ&*˜GÝ% u¨d°T¸3°KÀÐFÐFÐFÐFÑFà$(¨% =˜Ø"& u v v¤,˜Ø#'˜ÙØ¥ Ð-Ð-Ø˜"˜1˜"”I¥Ð.Ð.Ø˜"˜1˜"”I¥Ð.Ð.Ø˜R”y DÒ(Ð(Ø$(¨% =˜Ý#+¨GÔ#4ð$6½ÀÀqÄÔ8Jð$6Ý#+¨E°!¬HÔ#5ð à,0°°°¬L¸! ˜Ø#'˜Ùà"ð+Ø")˜M˜M˜MØ&*˜GÝ% u¨d°D¸$Ð?Ð?Ð?Ð?Ñ?Ø×)Ò)Ñ+Ô+ð,8ØÐ 2Ð2Ð2Ø$ð%Ø,1°WÒ,<Ð,<¥5 5Å%Ø#(¨$°°dð#<ð<ð<ð<á$å ¨¨d°DÐ9CØ Ò'Ð'°Ð'Ø"%˜Ù à Ð.Ð.Ø#ð+Ø$+¨A¤Jµ$Ò$6Ð$6Ø$+¨A¤J°'Ò$9Ð$9à$¨š~˜~Ø,0 Ø3:¸2´;Ð 0å#(¨'°!¬*Ø#*¨1¤:¨w°q¬zØ#*¨1¤:ð#/ð/ð/ð/ð'+˜Gàð'Ø%˜ ˜ ˜ Ø"&˜àIIIIØ ’__àð'Ø%˜ ˜ ˜ Ø"&˜Ý˜u d¨T°3¨K¸Ð>Ð>Ð>Ð>Ø !IIà %Ð'Ð'°H¸q±L¨¨Ø EÐ)Ð)°hÀ±l¨8Øð'Ø%˜ ˜ ˜ Ø"&˜Ý˜u d¨D°$Ð7Ð7Ð7Ð7Ð7å! 4¨¤9Ø #˜;¨¨s°1©u¨ °tð=ð=ð=ð=à˜A‘gðSCŠi‰iñi}ð~ðØˆ ˆ ˆ Øˆà˜!˜"˜"”+ð5ð5ˆÝr˜D !˜9 t¨Q i°Ð4Ð4Ð4Ð4Ð4Ýb˜4 ˜) d¨A Y°Ð 3Ð3Ð3Ð3Ð3Ð3s (¨7¶7Ú__main__)SÚ__doc__Ú __author__Ú__credits__rÐÚreÚcodecsrrÚlib2to3.pgen2.tokenr#rÚdirÚ__all__r¢Ú NameErrorÚstrrrr r)Ú WhitespaceÚCommentÚIgnoreÚNameÚ BinnumberÚ HexnumberÚ OctnumberÚ DecnumberÚ IntnumberÚExponentÚ PointfloatÚExpfloatÚFloatnumberÚ ImagnumberÚNumberÚSingleÚDoubleÚSingle3ÚDouble3Ú _litprefixÚTripleÚStringÚOperatorÚBracketÚSpecialÚFunnyÚ PlainTokenÚTokenÚContStrÚPseudoExtrasÚPseudoTokenÚmapÚcompileÚ tokenprogrÎr=rDÚ_strprefixesrÔrÓrÕrÊÚ ExceptionrPrWrdrrfrlÚASCIIr¨r³ržr·rrrRÚsysr}ÚargvÚopenrgÚstdinr rr úr%s÷ðð#ð#ð0*€ àFððÐÐÐÐÐÐÐØ#Ð#Ð#Ð#Ð#Ð#Ð#Ð#Ø!Ð!Ð!Ð!àÐÐÐÐÐØ 0Ð 0cc˜%‘j”jÐ 0Ñ 0Ô 0ð4,ð4,ð4,ñ,€à ðØ €E€EøØðððð €E€E€Eðøøøð :Ð9Ð9Ø/Ð/Ð/Ø1Ð1Ð1ðððð € Ø €Ø cc˜* zÑ1Ñ2Ô2Ñ 2°U°U¸7±^´^Ñ C€Ø €à&€ Ø7€ Ø.€ ØˆEÐ+¨XÑ6Ô6€ ØˆE)˜Y¨ °9Ñ=Ô=€ Ø#€Ø ˆUÐ5Ð7HÑ IÔ IÈEÈEÐRZÉOÌOÑ [€ Ø˜XÑ%€ØˆeJ Ñ)Ô)€Ø ˆUÐ&¨°gÑ(=Ñ >Ô >€ Ø ˆˆz˜;¨ Ñ 2Ô 2€ð $€à #€à 2€à 2€Ø 7€ Ø ˆˆz˜EÑ! :°Ñ#5Ñ 6Ô 6€à ˆˆzÐ;Ñ;ØÐ;Ñ;ñ =ô =€ðˆ5˜G W¨e°UØ˜%Ø%Øñô€ð €Ø ˆ%˜% Ñ -Ô -€Ø ˆˆh˜ Ñ)Ô)€à ˆU6˜5 &¨$Ñ /Ô /€ ØÑ€ðˆ% Ð;Ñ;Øc˜:Ñ&Ô&ñ'àÐ;Ñ;Øc˜:Ñ&Ô&ñ'ñ(ô(€ðˆuZ ¨&Ñ1Ô1€Ø˜5˜5 ¨v°u¸gÀtÑLÔLÑL€à25°#Ø„J˜ W¨gÐ6ñ38ô38Ñ/€ ˆ:{ Kð€M#s˜C Ñ%Ô%Ø€M#s˜C Ñ%Ô%ñ&à&Ð&Ð&ñ'ð ð”˜FÑ#Ô#¨*¨"¬*°VÑ*<Ô*<Ø {ð9ð9àFÐF¸ÐFÑFÔFð9ðGÐF¸ÐFÑFÔFð9ð8Ð7¨,Ð7Ñ7Ô7ð 9€ðˆE€NØ/Ð/ ,Ð/Ñ/Ô/ñ0à/Ð/ ,Ð/Ñ/Ô/ñ0ðð ˆ#€JØ-Ð- Ð-Ñ-Ô-ñ.à-Ð- Ð-Ñ-Ô-ñ.ðð€à!Ð!Ð!Ð!Ð!Ñ!Ô!Ð!à%Ð%Ð%Ð%Ð%YÑ%Ô%Ð%ð?ð?ð?ð#-ð ð ð ð ð& ð ð ð6 ð6 ð6 ð6 ð6 ñ6 ô6 ð6 ðp ˆBŒJÐ@À"Ä(ÑKÔK€ Øˆ2Œ:Ð0°"´(Ñ;Ô;€ð ð ð ðG$ðG$ðG$ðR#ð#ð#ð*`4ð`4ð`4ðDˆzÒÐØ€J€J€JØ €sˆ3Œ8}„}qÒÐ˜(˜( 4 4¨¬°¬Ñ#4Ô#4Ô#=Ñ>Ô>Ð>Ð>Ð>Ø ˆ(3”9Ô%Ñ &Ô &Ð &Ð &Ð &ðÐs½AÁA Á A PKhP3]OÍnll(__pycache__/driver.cpython-311.opt-2.pycnu„[µü¤§ àÀfQãóì— dZddgZddlZddlZddlZddlZddlZddlmZm Z m Z mZmZGd„de ¦«Zd„Z dd„Zd „Zd„Zd„Zedkr$ejee¦«¦«¦«dSdS)z#Guido van Rossum ÚDriverÚload_grammaréNé)ÚgrammarÚparseÚtokenÚtokenizeÚpgencó>—eZdZd d„Zd d„Zd d„Zd d„Zdd„Zd d„ZdS)rNcóZ—||_|€tj¦«}||_||_dS©N)rÚloggingÚ getLoggerÚloggerÚconvert)Úselfrrrs ú;/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/driver.pyÚ__init__zDriver.__init__s.€ØˆŒØˆ>ÝÔ&Ñ(Ô(ˆFØˆŒØˆŒˆˆóFcó.— tj|j|j¦«}| ¦«d}d}dx}x}x}x} } d}|D].}|\}}}} } |||fkr/|\} }|| kr|d| |z zz }| }d}||kr|| ||…z }|}|t jt jfvr'||z }| \}}| d¦«r|dz }d}Œƒ|tj krtj|}|r-|j dtj|||¦«| ||||f¦«r|r|j d¦«n>d}| \}}| d¦«r|dz }d}Œ0tjd||||f¦«‚|jS)NrrÚú z%s %r (prefix=%r)zStop.zincomplete input)rÚParserrrÚsetupr ÚCOMMENTÚNLÚendswithrÚOPÚopmaprÚdebugÚtok_nameÚaddtokenÚ ParseErrorÚrootnode)rÚtokensr ÚpÚlinenoÚcolumnÚtypeÚvalueÚstartÚendÚ line_textÚprefixÚ quintupleÚs_linenoÚs_columns rÚparse_tokenszDriver.parse_tokens&s€ØBåŒL˜œ t¤|Ñ4Ô4ˆØ Š‰ Œ ˆ ØˆØˆØ15Ð5ˆÐ5ˆuÐ5uÐ5˜s YØˆØð$ Añ$ AˆIØ1:Ñ.ˆD%˜ YØ˜ Ð(Ò(Ð(à%*Ñ"˜(Ø˜HÒ$Ð$Ø˜d h°Ñ&7Ñ8Ñ8FØ%FØFØ˜HÒ$Ð$Ø˜i¨¨x¨Ô8Ñ8FØ%FØÔ((¬+Ð6Ð6Ð6Ø˜%‘Ø!$‘˜Ø—>’> $Ñ'Ô'ðØ˜a‘KFØFØØ•u”xÒÐÝ”} UÔ+Øð GØ”×!Ò!Ð"5Ý"'¤.°Ô"6¸¸vñGôGðGàzŠz˜$ ¨° Ñ7Ô7ð Øð/Ø”K×%Ò% gÑ.Ô.Ð.ØØˆFØ ‰NˆFFØ~Š~˜dÑ#Ô#ð Ø˜!‘ØùõÔ"Ð#5Ø#'¨°¸°ñAôAð AàŒzÐrcób— tj|j¦«}| ||¦«Sr )r Úgenerate_tokensÚreadliner2)rÚstreamr r%s rÚparse_stream_rawzDriver.parse_stream_rawVs-€Ø8ÝÔ)¨&¬/Ñ:Ô:ˆØ× Ò ¨Ñ/Ô/Ð/rcó0— | ||¦«Sr )r7)rr6r s rÚparse_streamzDriver.parse_stream[s€Ø8Ø×$Ò$ V¨UÑ3Ô3Ð3rcó’— tj|d|¬¦«5}| ||¦«cddd¦«S#1swxYwYdS)NÚr)Úencoding)ÚioÚopenr9)rÚfilenamer<r r6s rÚ parse_filezDriver.parse_file_s€Ø6Ý ŒWX˜s¨XÐ 6Ñ 6Ô 6ð 4¸&Ø×$Ò$ V¨UÑ3Ô3ð 4ð 4ð 4ð 4ñ 4ô 4ð 4ð 4ð 4ð 4ð 4ð 4øøøð 4ð 4ð 4ð 4ð 4ð 4s™<¼AÁAcó†— tjtj|¦«j¦«}| ||¦«Sr )r r4r=ÚStringIOr5r2)rÚtextr r%s rÚparse_stringzDriver.parse_stringds8€Ø8ÝÔ)"¬+°dÑ*;Ô*;Ô*DÑEÔEˆØ× Ò ¨Ñ/Ô/Ð/r)NN)F)NF) Ú__name__Ú __module__Ú__qualname__rr2r7r9r@rD©rrrrs€€€€€ððððð.ð.ð.ð.ð`0ð0ð0ð0ð 4ð4ð4ð4ð4ð4ð4ð4ð 0ð0ð0ð0ð0ð0rcóÌ—tj |¦«\}}|dkrd}||zd t t tj¦«¦«zdzS)Nz.txtrú.z.pickle)ÚosÚpathÚsplitextÚjoinÚmapÚstrÚsysÚversion_info)ÚgtÚheadÚtails rÚ_generate_pickle_namerVjsV€Ý”×!Ò! "Ñ%Ô%J€Dˆ$Øˆv‚~€~ØˆØ$‰;˜Ÿš¥#¥c3Ô+;Ñ"<Ô"<Ñ=Ô=Ñ=À ÑIÐIrúGrammar.txtTFcóÚ— |€tj¦«}|€t|¦«n|}|st||¦«s‡| d|¦«tj|¦«}|rZ| d|¦« | |¦«nV#t$r }| d|¦«Yd}~n1d}~wwxYwn(tj ¦«}| |¦«|S)Nz!Generating grammar tables from %szWriting grammar tables to %szWriting failed: %s)rrrVÚ_newerÚinfor Úgenerate_grammarÚdumpÚOSErrorrÚGrammarÚload)rSÚgpÚsaveÚforcerÚgÚes rrrqs €à1Ø €~ÝÔ"Ñ$Ô$ˆØ&( jÕ ˜rÑ "Ô "Ð "°b€BØð•F˜2˜r‘N”NðØŠÐ7¸Ñ<Ô<Ð<ÝÔ! "Ñ%Ô%ˆØð 5ØKŠKÐ6¸Ñ;Ô;Ð;ð 5Ø—’r‘ ” øÝð 5ð 5ð 5Ø—’Ð0°!Ñ4Ô4Ð4Ð4Ð4Ð4Ð4Ð4øøøøð 5øøøð 5õ ŒOÑÔˆØ Šˆr‰ Œ ˆ Ø€HsÁ?BÂ B?ÂB:Â:B?có— tj |¦«sdStj |¦«sdStj |¦«tj |¦«kS)NFT)rKrLÚexistsÚgetmtime)ÚaÚbs rrYrY†sf€Ø:Ý Œ7>Š>˜!ÑÔðØˆuÝ Œ7>Š>˜!ÑÔðØˆtÝ Œ7×Ò˜AÑÔ¥"¤'×"2Ò"2°1Ñ"5Ô"5Ò5Ð5rcó6— tj |¦«rt|¦«St tj |¦«¦«}t j||¦«}tj ¦«}| |¦«|Sr )rKrLÚisfilerrVÚbasenameÚpkgutilÚget_datarr^Úloads)ÚpackageÚgrammar_sourceÚpickled_nameÚdatarcs rÚload_packaged_grammarrts}€ð õ „w‡~‚~nÑ%Ô%ð,Ý˜NÑ+Ô+Ð+Ý(¬×)9Ò)9¸.Ñ)IÔ)IÑJÔJ€LÝÔ˜G \Ñ2Ô2€DÝŒÑÔ€AØ‡G‚GˆDM„M€MØ€Hrcó¸— |stjdd…}tjtjtjd¬¦«|D]}t |dd¬¦«ŒdS)Nrz%(message)s)Úlevelr6ÚformatT)rarb)rQÚargvrÚbasicConfigÚINFOÚstdoutr)ÚargsrSs rÚmainr}£sq€ðððÝŒx˜˜˜Œ|ˆÝÔgœlµ3´:Ø,ð.ñ.ô.ð.àð0ð0ˆÝR˜d¨$Ð/Ñ/Ô/Ð/Ð/Øˆ4rÚ__main__)rWNTFN)Ú __author__Ú__all__r=rKrrmrQrrrrr r ÚobjectrrVrrYrtr}rEÚexitÚintrHrrúr„sAððð3€ à^Ð $€ð € € € Ø € € € Ø€€€Ø€€€Ø € € € ð4Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3ðJ0ðJ0ðJ0ðJ0ðJ0ˆVñJ0ôJ0ðJ0ðZJðJðJð'+Ø04ð ð ð ð ð*6ð6ð6ð ð ð ð(ðððˆzÒÐØ€C„HˆSˆSTT‘V”V‰_Œ_ÑÔÐÐÐðÐrPKhP3]°Í£™E+E+&__pycache__/conv.cpython-311.opt-1.pycnu„[µü¤§ àÀfª%ãóH—dZddlZddlmZmZGd„dej¦«ZdS)aýConvert graminit.[ch] spit out by pgen to Python code. Pgen is the Python parser generator. It is useful to quickly create a parser from a grammar file in Python's grammar notation. But I don't want my parsers to be written in C (yet), so I'm translating the parsing tables to Python data structures and writing a Python parse engine. Note that the token numbers are constants determined by the standard Python tokenizer. The standard token module defines these numbers and their names (the names are not used much). The token numbers are hardcoded into the Python tokenizer and into pgen. A Python implementation of the Python tokenizer is also available, in the standard tokenize module. On the other hand, symbol numbers (representing the grammar's non-terminals) are assigned by pgen based on the actual grammar input. Note: this module is pretty much obsolete; the pgen module generates equivalent grammar tables directly from the Grammar.txt input file without having to invoke the Python pgen C program. éN)ÚgrammarÚtokencó*—eZdZdZd„Zd„Zd„Zd„ZdS)Ú Convertera2Grammar subclass that reads classic pgen output files. The run() method reads the tables as produced by the pgen parser generator, typically contained in two C files, graminit.h and graminit.c. The other methods are for internal use only. See the base class for more documentation. có‚—| |¦«| |¦«| ¦«dS)z| ¦«r*t|›d|›d | ¦«›¦«Œ\| ¦«\}}t|¦«}||j|<||j|<Œ—d S)zðParse the .h file written by pgen. (Internal) This file is a sequence of #define statements defining the nonterminals of the grammar as numbers. We build two tables mapping the numbers to names and back. úCan't open ú: NFréz^#define\s+(\w+)\s+(\d+)$ú(z): can't parse T) ÚopenÚOSErrorÚprintÚ symbol2numberÚ number2symbolÚreÚmatchÚstripÚgroupsÚint) rÚfilenameÚfÚerrÚlinenoÚlineÚmoÚsymbolÚnumbers rrzConverter.parse_graminit_h5s/€ð ÝX‘”ˆAˆAøÝð ð ð ÝˆE¨¨¨°3°3Ð7Ñ8Ô8Ð8Ø55555øøøøð øøøð ˆÔØˆÔØˆØð 4ð 4ˆDØa‰KˆFÝ”Ð6¸Ñ=Ô=ˆBØð 4˜$Ÿ*š*™,œ,ð 4Ý°(°(°(¸F¸F¸FØ26·*²*±,´,°,ð@ñAôAðAðAð"$§¢¡¤‘˜Ý˜V™œð.4Ô" 6Ñ*Ø-3Ô" 6Ñ*Ð*Øˆts‚’ <œ7·_[] = { {, }, ... }; - followed by a state array, of the form: static state states_[] = { {, arcs__}, ... }; rrNFrrzstatic arc z)static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$z\s+{(\d+), (\d+)},$z'static state states_(\d+)\[(\d+)\] = {$z\s+{(\d+), arcs_(\d+)_(\d+)},$zstatic dfa dfas\[(\d+)\] = {$z0\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$ééééz\s+("(?:\\\d\d\d)*")},$éz!static label labels\[(\d+)\] = {$z\s+{(\d+), (0|"\w+")},$Ú0z \s+(\d+),$z\s+{(\d+), labels},$z \s+(\d+)$)rrrÚnextÚ startswithrrÚlistÚmaprrÚrangeÚappendÚstatesÚgroupÚevalÚ enumerateÚordÚdfasÚlabelsÚstartÚ StopIteration)!rr r!r"r#r$Úallarcsr5r%ÚnÚmÚkÚarcsÚ_ÚiÚjÚsÚtÚstater:Úndfasr&r'ÚxÚyÚzÚfirstÚ rawbitsetÚcÚbyter;Únlabelsr<s! rr zConverter.parse_graminit_cTsŒ€ð8 ÝX‘”ˆAˆAøÝð ð ð ÝˆE¨¨¨°3°3Ð7Ñ8Ô8Ð8Ø55555øøøøð øøøðˆð˜a‘x¥ a¡¤ˆà˜a‘x¥ a¡¤ˆð˜a‘x¥ a¡¤ˆØˆØˆØoŠo˜mÑ,Ô,ñ! -Ø—/’/ -Ñ0Ô0ñ 1Ý”XÐJØ"ñ$ô$õs¥3¨¯ ª ©¬Ñ4Ô4Ñ5Ô5‘1aØÝ˜q™œð(ð(AØ#)¨!¡8T°!©W¬W˜DFÝœÐ"8¸$Ñ?Ô?Bå¥¥C¨¯ª©¬Ñ 5Ô 5Ñ6Ô6‘DAqØ—K’K A Ñ'Ô'Ð'Ð'Ø% a™x¨a©¬˜à"&˜˜A˜‘Ø% a™x¨a©¬˜ð—/’/ -Ñ0Ô0ñ 1õ ”ÐDÀdÑKÔKˆBåC §¢¡¤Ñ-Ô-Ñ.Ô.‰DˆAˆqàˆEÝ˜1‘X”Xð #ð #Ø% a™x¨a©¬˜Ý”XÐ?ÀÑFÔFås¥3¨¯ ª ©¬Ñ4Ô4Ñ5Ô5‘1aØ˜q !˜t”}à—’˜TÑ"Ô"Ð"Ð"ØMŠM˜%Ñ Ô Ð Ø! !™8¥T¨!¡W¤WDˆFà! !™8¥T¨!¡W¤WDˆFðCoŠo˜mÑ,Ô,ñ! -ðDˆŒðˆÝ ŒXÐ6¸Ñ =Ô =ˆåB—H’H˜Q‘K”KÑ Ô ˆÝu‘”ð *ñ *ˆAØ! !™8¥T¨!¡W¤WDˆFÝ”ÐMØñ ô ˆBð—X’X˜a‘[”[ˆFÝ"¥3¥s¨B¯HªH°Q¸¸1¸aÑ,@Ô,@Ñ#AÔ#AÑBÔB‰OˆFAq˜!ð˜1”IˆEà! !™8¥T¨!¡W¤WDˆFÝ”Ð4°dÑ;Ô;ˆBàˆEÝ˜RŸXšX a™[œ[Ñ)Ô)ˆIÝ! )Ñ,Ô,ð +ð +‘1Ý˜1‘v”vÝ˜q™œð+ð+AØ˜q !™t‘}ð+Ø)*˜˜a ™c A™g™øð+ð" 5˜>ˆD‰L‰LØ˜a‘x¥ a¡¤ˆàˆŒ ðˆØ˜a‘x¥ a¡¤ˆÝ ŒXÐ:¸DÑ AÔ Aˆåb—h’h˜q‘k”kÑ"Ô"ˆÝw‘”ð "ð "ˆAØ! !™8¥T¨!¡W¤WDˆFÝ”Ð4°dÑ;Ô;ˆBà—9’9‘;”;‰DˆAˆqÝA‘”ˆAØCŠxˆxØå˜‘G”GØMŠM˜1˜a˜&Ñ!Ô!Ð!Ð!Ø˜a‘x¥ a¡¤ˆàˆŒð˜a‘x¥ a¡¤ˆà˜a‘x¥ a¡¤ˆÝ ŒXm TÑ *Ô *ˆåB—H’H˜Q‘K”KÑ Ô ˆà˜a‘x¥ a¡¤ˆà˜a‘x¥ a¡¤ˆÝ ŒXÐ-¨tÑ 4Ô 4ˆåb—h’h˜q‘k”kÑ"Ô"ˆà˜a‘x¥ a¡¤ˆÝ ŒXl DÑ )Ô )ˆåB—H’H˜Q‘K”KÑ Ô ˆàˆŒ Ø˜a‘x¥ a¡¤ˆð %Ø! !™8¥T¨!¡W¤WDˆFˆFˆFøÝð ð ð ØˆDˆDð øøøs"‚’ <œ7·<Ú)Z?Ú? [ Û[ có®—i|_i|_t|j¦«D]1\}\}}|tjkr |||j|<Œ%|€ ||j|<Œ2dS)z1Create additional useful structures. (Internal).N)ÚkeywordsÚtokensr8r;rÚNAME)rÚilabelÚtypeÚvalues rr zConverter.finish_offùso€àˆŒ ØˆŒÝ%.¨t¬{Ñ%;Ô%;ð +ð +Ñ!ˆF‘MT˜5Ø•u”zÒ!Ð! eÐ&7Ø'-” ˜eÑ$Ð$ØØ$*”˜DÑ!øð +ð +rN)Ú__name__Ú __module__Ú__qualname__Ú__doc__rrr r ©rrrr$s^€€€€€ððððððððð>c%ðc%ðc%ðJ+ð+ð+ð+ð+rr)r\rÚpgen2rrÚGrammarrr]rrúr`stðððð4 € € € ð!Ð Ð Ð Ð Ð Ð Ð ð]+ð]+ð]+ð]+ð]+”ñ]+ô]+ð]+ð]+ð]+rPKhP3]‰÷Ù©!©!&__pycache__/conv.cpython-311.opt-2.pycnu„[µü¤§ àÀfª%ãóF— ddlZddlmZmZGd„dej¦«ZdS)éN)ÚgrammarÚtokencó(—eZdZ d„Zd„Zd„Zd„ZdS)Ú Convertercó„— | |¦«| |¦«| ¦«dS©N)Úparse_graminit_hÚparse_graminit_cÚ finish_off)ÚselfÚ graminit_hÚ graminit_cs ú9/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/conv.pyÚrunz Converter.run/sC€ØJØ×Ò˜jÑ)Ô)Ð)Ø×Ò˜jÑ)Ô)Ð)ØŠÑÔÐÐÐóc óÖ— t|¦«}n-#t$r }td|›d|›¦«Yd}~dSd}~wwxYwi|_i|_d}|D]–}|dz }tjd|¦«}|s>| ¦«r*t|›d|›d| ¦«›¦«Œ\| ¦«\}}t|¦«}||j|<||j|<Œ—d S) NúCan't open ú: Fréz^#define\s+(\w+)\s+(\d+)$ú(z): can't parse T) ÚopenÚOSErrorÚprintÚ symbol2numberÚ number2symbolÚreÚmatchÚstripÚgroupsÚint) rÚfilenameÚfÚerrÚlinenoÚlineÚmoÚsymbolÚnumbers rr zConverter.parse_graminit_h5s4€ð ð ÝX‘”ˆAˆAøÝð ð ð ÝˆE¨¨¨°3°3Ð7Ñ8Ô8Ð8Ø55555øøøøð øøøð ˆÔØˆÔØˆØð 4ð 4ˆDØa‰KˆFÝ”Ð6¸Ñ=Ô=ˆBØð 4˜$Ÿ*š*™,œ,ð 4Ý°(°(°(¸F¸F¸FØ26·*²*±,´,°,ð@ñAôAðAðAð"$§¢¡¤‘˜Ý˜V™œð.4Ô" 6Ñ*Ø-3Ô" 6Ñ*Ð*Øˆtsƒ“ =8¸=có¢ — t|¦«}n-#t$r }td|›d|›¦«Yd}~dSd}~wwxYwd}|dzt|¦«}}|dzt|¦«}}|dzt|¦«}}i}g}| d¦«rf| d¦«rtjd|¦«}ttt| ¦«¦«¦«\} } }g}t|¦«D]y} |dzt|¦«}}tjd|¦«}ttt| ¦«¦«¦«\}}| ||f¦«Œz|dzt|¦«}}||| | f<|dzt|¦«}}| d¦«°tjd |¦«}ttt| ¦«¦«¦«\}}g}t|¦«D]‚} |dzt|¦«}}tjd |¦«}ttt| ¦«¦«¦«\}} } || | f}| |¦«Œƒ| |¦«|dzt|¦«}}|dzt|¦«}}| d¦«°f||_ i}tjd|¦«}t| d¦«¦«}t|¦«D]#}|dzt|¦«}}tjd|¦«}| d ¦«}ttt| dddd¦«¦«¦«\}}}}||}|dzt|¦«}}tjd|¦«}i}t| d¦«¦«}t!|¦«D]9\}}t#|¦«}td¦«D]}|d|zzrd||dz|z<ŒŒ:||f||<Œ%|dzt|¦«}}||_g}|dzt|¦«}}tjd|¦«}t| d¦«¦«}t|¦«D]€}|dzt|¦«}}tjd|¦«}| ¦«\}}t|¦«}|dkrd}nt|¦«}| ||f¦«Œ|dzt|¦«}}||_|dzt|¦«}}|dzt|¦«}}tjd|¦«}t| d¦«¦«}|dzt|¦«}}|dzt|¦«}}tjd|¦«}t| d¦«¦«}|dzt|¦«}}tjd|¦«}t| d¦«¦«} | |_|dzt|¦«}} |dzt|¦«}}dS#t*$rYdSwxYw)NrrFrrzstatic arc z)static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$z\s+{(\d+), (\d+)},$z'static state states_(\d+)\[(\d+)\] = {$z\s+{(\d+), arcs_(\d+)_(\d+)},$zstatic dfa dfas\[(\d+)\] = {$z0\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$ééééz\s+("(?:\\\d\d\d)*")},$éz!static label labels\[(\d+)\] = {$z\s+{(\d+), (0|"\w+")},$Ú0z \s+(\d+),$z\s+{(\d+), labels},$z \s+(\d+)$)rrrÚnextÚ startswithrrÚlistÚmapr rÚrangeÚappendÚstatesÚgroupÚevalÚ enumerateÚordÚdfasÚlabelsÚstartÚ StopIteration)!rr!r"r#r$r%Úallarcsr6r&ÚnÚmÚkÚarcsÚ_ÚiÚjÚsÚtÚstater;Úndfasr'r(ÚxÚyÚzÚfirstÚ rawbitsetÚcÚbyter<Únlabelsr=s! rr zConverter.parse_graminit_cTs‘€ð ð6 ÝX‘”ˆAˆAøÝð ð ð ÝˆE¨¨¨°3°3Ð7Ñ8Ô8Ð8Ø55555øøøøð øøøðˆð˜a‘x¥ a¡¤ˆà˜a‘x¥ a¡¤ˆð˜a‘x¥ a¡¤ˆØˆØˆØoŠo˜mÑ,Ô,ñ! -Ø—/’/ -Ñ0Ô0ñ 1Ý”XÐJØ"ñ$ô$õs¥3¨¯ ª ©¬Ñ4Ô4Ñ5Ô5‘1aØÝ˜q™œð(ð(AØ#)¨!¡8T°!©W¬W˜DFÝœÐ"8¸$Ñ?Ô?Bå¥¥C¨¯ª©¬Ñ 5Ô 5Ñ6Ô6‘DAqØ—K’K A Ñ'Ô'Ð'Ð'Ø% a™x¨a©¬˜à"&˜˜A˜‘Ø% a™x¨a©¬˜ð—/’/ -Ñ0Ô0ñ 1õ ”ÐDÀdÑKÔKˆBåC §¢¡¤Ñ-Ô-Ñ.Ô.‰DˆAˆqàˆEÝ˜1‘X”Xð #ð #Ø% a™x¨a©¬˜Ý”XÐ?ÀÑFÔFås¥3¨¯ ª ©¬Ñ4Ô4Ñ5Ô5‘1aØ˜q !˜t”}à—’˜TÑ"Ô"Ð"Ð"ØMŠM˜%Ñ Ô Ð Ø! !™8¥T¨!¡W¤WDˆFà! !™8¥T¨!¡W¤WDˆFðCoŠo˜mÑ,Ô,ñ! -ðDˆŒðˆÝ ŒXÐ6¸Ñ =Ô =ˆåB—H’H˜Q‘K”KÑ Ô ˆÝu‘”ð *ñ *ˆAØ! !™8¥T¨!¡W¤WDˆFÝ”ÐMØñ ô ˆBð—X’X˜a‘[”[ˆFÝ"¥3¥s¨B¯HªH°Q¸¸1¸aÑ,@Ô,@Ñ#AÔ#AÑBÔB‰OˆFAq˜!ð˜1”IˆEà! !™8¥T¨!¡W¤WDˆFÝ”Ð4°dÑ;Ô;ˆBàˆEÝ˜RŸXšX a™[œ[Ñ)Ô)ˆIÝ! )Ñ,Ô,ð +ð +‘1Ý˜1‘v”vÝ˜q™œð+ð+AØ˜q !™t‘}ð+Ø)*˜˜a ™c A™g™øð+ð" 5˜>ˆD‰L‰LØ˜a‘x¥ a¡¤ˆàˆŒ ðˆØ˜a‘x¥ a¡¤ˆÝ ŒXÐ:¸DÑ AÔ Aˆåb—h’h˜q‘k”kÑ"Ô"ˆÝw‘”ð "ð "ˆAØ! !™8¥T¨!¡W¤WDˆFÝ”Ð4°dÑ;Ô;ˆBà—9’9‘;”;‰DˆAˆqÝA‘”ˆAØCŠxˆxØå˜‘G”GØMŠM˜1˜a˜&Ñ!Ô!Ð!Ð!Ø˜a‘x¥ a¡¤ˆàˆŒð˜a‘x¥ a¡¤ˆà˜a‘x¥ a¡¤ˆÝ ŒXm TÑ *Ô *ˆåB—H’H˜Q‘K”KÑ Ô ˆà˜a‘x¥ a¡¤ˆà˜a‘x¥ a¡¤ˆÝ ŒXÐ-¨tÑ 4Ô 4ˆåb—h’h˜q‘k”kÑ"Ô"ˆà˜a‘x¥ a¡¤ˆÝ ŒXl DÑ )Ô )ˆåB—H’H˜Q‘K”KÑ Ô ˆàˆŒ Ø˜a‘x¥ a¡¤ˆð %Ø! !™8¥T¨!¡W¤WDˆFˆFˆFøÝð ð ð ØˆDˆDð øøøs"ƒ“ =8¸=Ú*[Û [Û [có°— i|_i|_t|j¦«D]1\}\}}|tjkr |||j|<Œ%|€ ||j|<Œ2dSr)ÚkeywordsÚtokensr9r<rÚNAME)rÚilabelÚtypeÚvalues rrzConverter.finish_offùsr€Ø?ØˆŒ ØˆŒÝ%.¨t¬{Ñ%;Ô%;ð +ð +Ñ!ˆF‘MT˜5Ø•u”zÒ!Ð! eÐ&7Ø'-” ˜eÑ$Ð$ØØ$*”˜DÑ!øð +ð +rN)Ú__name__Ú __module__Ú__qualname__rr r r©rrrr$sY€€€€€ðððððððð>c%ðc%ðc%ðJ+ð+ð+ð+ð+rr)rÚpgen2rrÚGrammarrr]rrúr`soððð4 € € € ð!Ð Ð Ð Ð Ð Ð Ð ð]+ð]+ð]+ð]+ð]+”ñ]+ô]+ð]+ð]+ð]+rPKhP3]°}+»ÌÌ$__pycache__/__init__.cpython-311.pycnu„[µü¤§ àÀfãó —dZdS)zThe pgen2 package.N)Ú__doc__©óú=/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/__init__.pyúrsððÐÐÐrPKhP3]áª '__pycache__/token.cpython-311.opt-2.pycnu„[µü¤§ àÀf#ãó¢— dZdZdZdZdZdZdZdZdZd Z d Z dZdZd Z dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd Z d!Z!d"Z"d#Z#d$Z$d%Z%d&Z&d'Z'd(Z(d)Z)d*Z*d+Z+d,Z,d-Z-d.Z.d/Z/d0Z0d1Z1d2Z2d3Z3d4Z4d5Z5d6Z6d7Z7d8Z8d9Z9d:Z:d;Z;de?e@¦« A¦«¦«D] \ZBZCeDeC¦«eDd¦«ureBe>eC<Œ!d>„ZEd?„ZFd@„ZGdAS)Béééééééééé é ééé ééééééééééééééééééé é!é"é#é$é%é&é'é(é)é*é+é,é-é.é/é0é1é2é3é4é5é6é7é8é9é:é;é<écó—|tkS©N©Ú NT_OFFSET©Úxs ú:/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/token.pyÚ ISTERMINALrGOs€ØyŠ=Ðócó—|tkSrArBrDs rFÚ ISNONTERMINALrJRó€Ø• Š>ÐrHcó—|tkSrA)Ú ENDMARKERrDs rFÚISEOFrNUrKrHN)HrMÚNAMEÚNUMBERÚSTRINGÚNEWLINEÚINDENTÚDEDENTÚLPARÚRPARÚLSQBÚRSQBÚCOLONÚCOMMAÚSEMIÚPLUSÚMINUSÚSTARÚSLASHÚVBARÚAMPERÚLESSÚGREATERÚEQUALÚDOTÚPERCENTÚ BACKQUOTEÚLBRACEÚRBRACEÚEQEQUALÚNOTEQUALÚ LESSEQUALÚGREATEREQUALÚTILDEÚ CIRCUMFLEXÚ LEFTSHIFTÚ RIGHTSHIFTÚ DOUBLESTARÚ PLUSEQUALÚMINEQUALÚ STAREQUALÚ SLASHEQUALÚPERCENTEQUALÚ AMPEREQUALÚ VBAREQUALÚCIRCUMFLEXEQUALÚLEFTSHIFTEQUALÚRIGHTSHIFTEQUALÚDOUBLESTAREQUALÚDOUBLESLASHÚDOUBLESLASHEQUALÚATÚATEQUALÚOPÚCOMMENTÚNLÚRARROWÚAWAITÚASYNCÚ ERRORTOKENÚ COLONEQUALÚN_TOKENSrCÚtok_nameÚlistÚglobalsÚitemsÚ_nameÚ_valueÚtyperGrJrN©rHrFúr“sÔðð(ð € Ø€Ø €Ø €Ø €Ø €Ø €Ø€Ø€Ø€Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø €Ø€Ø €Ø€ Ø €Ø €Ø €Ø €Ø€ Ø€Ø €Ø € Ø€ Ø € Ø € Ø€ Ø €Ø€ Ø € Ø€Ø € Ø€ Ø€Ø€Ø€Ø€Ø€ØÐØ€Ø €Ø€Ø €Ø€Ø €Ø €Ø €Ø € Ø € Ø €Ø€ ð€ØT˜'˜'™)œ)Ÿ/š/Ñ+Ô+Ñ,Ô,ð!ð!M€Eˆ6Ø€tˆF|„|tt˜A‘w”wÐÐØ ˆÑøðððððððððððrHPKhP3]°}+»ÌÌ*__pycache__/__init__.cpython-311.opt-1.pycnu„[µü¤§ àÀfãó —dZdS)zThe pgen2 package.N)Ú__doc__©óú=/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/__init__.pyúrsððÐÐÐrPKhP3]Ìû:““)__pycache__/grammar.cpython-311.opt-1.pycnu„[µü¤§ àÀf°ãóÆ—dZddlZddlmZGd„de¦«ZdZiZe ¦«D]*Z e r&e ¦«\ZZe ee¦«ee<Œ+[ [[dS)a‡This module defines the data structures used to represent a grammar. These are a bit arcane because they are derived from the data structures used by Python's 'pgen' parser generator. There's also a table here mapping operators to their names in the token module; the Python tokenize module reports all operators as the fallback token code OP, but the parser needs the actual token code. éNé)Útokencó6—eZdZdZd„Zd„Zd„Zd„Zd„Zd„Z dS) ÚGrammara¶ Pgen parsing tables conversion class. Once initialized, this class supplies the grammar tables for the parsing engine implemented by parse.py. The parsing engine accesses the instance variables directly. The class here does not provide initialization of the tables; several subclasses exist to do this (see the conv and pgen modules). The load() method reads the tables from a pickle file, which is much faster than the other ways offered by subclasses. The pickle file is written by calling dump() (after loading the grammar tables using a subclass). The report() method prints a readable representation of the tables to stdout, for debugging. The instance variables are as follows: symbol2number -- a dict mapping symbol names to numbers. Symbol numbers are always 256 or higher, to distinguish them from token numbers, which are between 0 and 255 (inclusive). number2symbol -- a dict mapping numbers to symbol names; these two are each other's inverse. states -- a list of DFAs, where each DFA is a list of states, each state is a list of arcs, and each arc is a (i, j) pair where i is a label and j is a state number. The DFA number is the index into this list. (This name is slightly confusing.) Final states are represented by a special arc of the form (0, j) where j is its own state number. dfas -- a dict mapping symbol numbers to (DFA, first) pairs, where DFA is an item from the states list above, and first is a set of tokens that can begin this grammar rule (represented by a dict whose values are always 1). labels -- a list of (x, y) pairs where x is either a token number or a symbol number, and y is either None or a string; the strings are keywords. The label number is the index in this list; label numbers are used to mark state transitions (arcs) in the DFAs. start -- the number of the grammar's start symbol. keywords -- a dict mapping keyword strings to arc labels. tokens -- a dict mapping token numbers to arc labels. có†—i|_i|_g|_i|_dg|_i|_i|_i|_d|_dS)N)rÚEMPTYé) Ú symbol2numberÚ number2symbolÚstatesÚdfasÚlabelsÚkeywordsÚtokensÚsymbol2labelÚstart)Úselfs ú GREATER = EQUAL . DOT % PERCENT ` BACKQUOTE { LBRACE } RBRACE @ AT @= ATEQUAL == EQEQUAL != NOTEQUAL <> NOTEQUAL <= LESSEQUAL >= GREATEREQUAL ~ TILDE ^ CIRCUMFLEX << LEFTSHIFT >> RIGHTSHIFT ** DOUBLESTAR += PLUSEQUAL -= MINEQUAL *= STAREQUAL /= SLASHEQUAL %= PERCENTEQUAL &= AMPEREQUAL |= VBAREQUAL ^= CIRCUMFLEXEQUAL <<= LEFTSHIFTEQUAL >>= RIGHTSHIFTEQUAL **= DOUBLESTAREQUAL // DOUBLESLASH //= DOUBLESLASHEQUAL -> RARROW := COLONEQUAL )r8rÚrÚobjectrÚ opmap_rawÚopmapÚ splitlinesÚlineÚsplitÚopÚnamer+r9rrúrCsÅðð ð ð€ € € ðÐÐÐÐÐðj#ðj#ðj#ðj#ðj#ˆfñj#ôj#ðj#ð^1 € ðf €Ø× Ò Ñ"Ô"ð)ð)€DØð)Ø—:’:‘<”<‰ˆˆDØG˜E 4Ñ(Ô(ˆˆb‰ øØˆ"ˆdˆdˆdrPKhP3]u‘MU-O-O __pycache__/pgen.cpython-311.pycnu„[µü¤§ àÀf6ãóœ—ddlmZmZmZGd„dej¦«ZGd„de¦«ZGd„de¦«ZGd„d e¦«Z d d„Z dS)é)ÚgrammarÚtokenÚtokenizecó—eZdZdS)ÚPgenGrammarN)Ú__name__Ú __module__Ú__qualname__©óú9/opt/alt/python311/lib64/python3.11/lib2to3/pgen2/pgen.pyrrs€€€€€Ø€Drrcó~—eZdZdd„Zd„Zd„Zd„Zd„Zd„Zd„Z d „Z d „Zd„Zd„Z d „Zd„Zd„Zd„Zdd„Zd„Zd„ZdS)ÚParserGeneratorNcóN—d}|€t|d¬¦«}|j}||_||_t j|j¦«|_| ¦«| ¦«\|_ |_| |¦«i|_| ¦«dS)Nzutf-8)Úencoding)ÚopenÚcloseÚfilenameÚstreamrÚgenerate_tokensÚreadlineÚ generatorÚgettokenÚparseÚdfasÚstartsymbolÚfirstÚaddfirstsets)ÚselfrrÚclose_streams r Ú__init__zParserGenerator.__init__s›€ØˆØˆ>Ý˜(¨WÐ5Ñ5Ô5ˆFØ!œ<ˆLØ ˆŒ ØˆŒÝ!Ô1°&´/ÑBÔBˆŒØ Š ‰ŒˆØ&*§j¢j¡l¤lÑ#ˆŒ 4Ô#ØÐ#ØˆL‰NŒNˆNØˆŒ Ø×ÒÑÔÐÐÐrc ó²—t¦«}t|j ¦«¦«}| ¦«| |j¦«| d|j¦«|D]-}dt|j ¦«z}||j |<||j |<Œ.|D]}|j|}g}|D]´}g}t|j ¦«¦«D]C\} } | | || ¦«| | ¦«f¦«ŒD|jr*| d| |¦«f¦«| |¦«Œµ|j |¦«|| ||¦«f|j|j |<Œ|j |j|_|S)Néé)rÚlistrÚkeysÚsortÚremoverÚinsertÚlenÚ symbol2numberÚ number2symbolÚsortedÚarcsÚitemsÚappendÚ make_labelÚindexÚisfinalÚstatesÚ make_firstÚstart)rÚcÚnamesÚnameÚiÚdfar4Ústater.ÚlabelÚnexts r Úmake_grammarzParserGenerator.make_grammarsÂ€Ý‰MŒMˆÝT”Y—^’^Ñ%Ô%Ñ&Ô&ˆØ Š ‰ŒˆØ ŠTÔ%Ñ&Ô&Ð&Ø ŠQ˜Ô(Ñ)Ô)Ð)Øð &ð &ˆDØ•c˜!œ/Ñ*Ô*Ñ*ˆAØ$%ˆAŒO˜DÑ!Ø!%ˆAŒO˜AÑÐØð Oñ OˆDØ”)˜D”/ˆCØˆFØð $ð $ØÝ#)¨%¬*×*:Ò*:Ñ*<Ô*<Ñ#=Ô#=ðNðN‘KE˜4Ø—K’K §¢°°EÑ!:Ô!:¸C¿IºIÀd¹O¼OÐ LÑMÔMÐMÐMØ”=ð7Ø—K’K C§I¢I¨eÑ$4Ô$4Ð 5Ñ6Ô6Ð6Ø— ’ ˜dÑ#Ô#Ð#Ð#Ø ŒHOŠO˜FÑ#Ô#Ð#Ø-3°T·_²_ÀQÈÑ5MÔ5MÐ,NˆAŒF1”? 4Ô(Ñ)Ñ)Ø”/ $Ô"2Ô3ˆŒØˆrcó~—|j|}i}t|¦«D]}| ||¦«}d||<Œ|S©Nr)rr-r1)rr7r9Úrawfirstrr=Úilabels r r5zParserGenerator.make_first4sM€Ø”:˜dÔ#ˆØˆÝ˜HÑ%Ô%ð ð ˆEØ—_’_ Q¨Ñ.Ô.ˆFàˆE&‰MˆMØˆrcóÂ—t|j¦«}|d ¦«rÝ||jvrI||jvr |j|S|j |j|df¦«||j|<|St t|d¦«}t|t¦«s J|¦«‚|tj vs J|¦«‚||jvr |j|S|j |df¦«||j|<|S|ddvs J|¦«‚t|¦«}|d ¦«rH||j vr |j |S|j tj|f¦«||j |<|Stj|}||jvr |j|S|j |df¦«||j|<|S)Nr#)ú"ú')r*ÚlabelsÚisalphar+Úsymbol2labelr0ÚgetattrrÚ isinstanceÚintÚtok_nameÚtokensÚevalÚkeywordsÚNAMErÚopmap)rr7r=rCÚitokenÚvalues r r1zParserGenerator.make_label=sç€åQ”X‘”ˆØŒ8×ÒÑÔð) "à˜œÐ'Ð'à˜AœNÐ*Ð*Øœ>¨%Ô0Ð0à”H—O’O Q¤_°UÔ%;¸TÐ$BÑCÔCÐCØ,2A”N 5Ñ)Ø!Mõ!¥¨¨tÑ4Ô4Ý! &#Ñ.Ô.Ð5Ð5°Ñ5Ô5Ð.Ø¥¤Ð/Ð/Ð/°Ñ/Ô/Ð/Ø˜QœXÐ%Ð%Øœ8 FÔ+Ð+à”H—O’O V¨T NÑ3Ô3Ð3Ø'-A”H˜VÑ$Ø!Mð˜”8˜zÐ)Ð)Ð)¨5Ñ)Ô)Ð)Ý˜‘K”KˆEØQŒx×ÒÑ!Ô!ð "à˜AœJÐ&Ð&Øœ: eÔ,Ð,à”H—O’O¥U¤Z°Ð$7Ñ8Ô8Ð8Ø(.A”J˜uÑ%Ø!Mõ!œ uÔ-Ø˜QœXÐ%Ð%Øœ8 FÔ+Ð+à”H—O’O V¨T NÑ3Ô3Ð3Ø'-A”H˜VÑ$Ø!MrcóÀ—t|j ¦«¦«}| ¦«|D] }||jvr| |¦«Œ!dS©N)r%rr&r'rÚ calcfirst)rr8r9s r rzParserGenerator.addfirstsetsksa€ÝT”Y—^’^Ñ%Ô%Ñ&Ô&ˆØ Š ‰ŒˆØð %ð %ˆDØ˜4œ:Ð%Ð%Ø—’˜tÑ$Ô$Ð$øð %ð %rc ó.—|j|}d|j|<|d}i}i}|j ¦«D]‚\}}||jvrh||jvr"|j|}|€t d|z¦«‚n"| |¦«|j|}| |¦«|||<Œvd||<|di||<Œƒi} | ¦«D]4\}} | D],}|| vr!t d|›d|›d|›d| |›¦«‚|| |<Œ-Œ5||j|<dS)Nr#zrecursion for rule %rrzrule z is ambiguous; z is in the first sets of z as well as )rrr.r/Ú ValueErrorrWÚupdate)rr9r;r<ÚtotalsetÚoverlapcheckr=r>ÚfsetÚinverseÚitsfirstÚsymbols r rWzParserGenerator.calcfirstss†€ØŒi˜ŒoˆØˆŒ 4ÑØA”ˆØˆØˆØ œ:×+Ò+Ñ-Ô-ð 1ð 1‰KˆE4Ø˜œ Ð!Ð!Ø˜DœJÐ&Ð&Øœ: eÔ,DØ|Ý(Ð)@À4Ñ)GÑHÔHÐHð$ð—N’N 5Ñ)Ô)Ð)Øœ: eÔ,DØ—’ Ñ%Ô%Ð%Ø&*˜UÑ#Ð#à"#˜‘Ø',¨a j˜UÑ#Ð#ØˆØ+×1Ò1Ñ3Ô3ð (ð (‰OˆE8Ø"ð (ð (Ø˜WÐ$Ð$Ý$˜*à&* d d¨F¨F¨F°E°E°E¸7À6¼?¸?ð&LñMôMðMð#(˜‘ð (ð$ˆŒ 4ÑÐÐrcót—i}d}|jtjkr|jtjkr)| ¦«|jtjk°)| tj¦«}| tjd¦«| ¦«\}}| tj¦«| ||¦«}t|¦«}| |¦«t|¦«}|||<|€|}|jtjk°||fS)Nú:)ÚtyperÚ ENDMARKERÚNEWLINErÚexpectrQÚOPÚ parse_rhsÚmake_dfar*Úsimplify_dfa) rrrr9ÚaÚzr;ÚoldlenÚnewlens r rzParserGenerator.parse‘s €ØˆØˆàŒi5œ?Ò*Ñ*Ø”)uœ}Ò,Ð,Ø— ’ ‘”ð”)uœ}Ò,Ð,ð—;’;uœzÑ*Ô*ˆDØKŠKœ #Ñ&Ô&Ð&Ø—>’>Ñ#Ô#‰DˆAˆqØKŠKœ Ñ&Ô&Ð&à—-’- 1Ñ%Ô%ˆCå˜‘X”XˆFØ×Ò˜cÑ"Ô"Ð"Ý˜‘X”XˆFØˆD‰JàÐ"Ø"ð#Œi5œ?Ò*Ñ*ð$[Ð Ð rc ó‡—t|t¦«sJ‚t|t¦«sJ‚ˆfd„}ˆfd„Št||¦«|¦«g}|D]±}i}|jD]1}|jD]'\}} | ‰| | |i¦«¦«Œ(Œ2t | ¦«¦«D]R\}} |D]}|j| krn&Œt| |¦«}| |¦«| ||¦«ŒSŒ²|S)Ncó$•—i}‰||¦«|SrVr)r<ÚbaseÚ addclosures €r Úclosurez)ParserGenerator.make_dfa..closure°sø€ØˆDØˆJu˜dÑ#Ô#Ð#ØˆKrcó‚•—t|t¦«sJ‚||vrdSd||<|jD]\}}|€‰||¦«ŒdSrA)rKÚNFAStater.)r<rqr=r>rrs €r rrz,ParserGenerator.make_dfa..addclosure´sgø€Ý˜e¥XÑ.Ô.Ð.Ð.Ð.Ø˜ˆ}ˆ}ØØˆD‰KØ$œzð +ð +‘tØ=ØJ˜t TÑ*Ô*Ð*øð +ð +r) rKruÚDFAStateÚnfasetr.Ú setdefaultr-r/r0Úaddarc) rr6Úfinishrsr4r<r.Únfastater=r>rwÚstrrs @r rizParserGenerator.make_dfa©s{ø€õ ˜%¥Ñ*Ô*Ð*Ð*Ð*Ý˜&¥(Ñ+Ô+Ð+Ð+Ð+ð ð ð ð ð ð +ð +ð +ð +ð +õ˜7˜7 5™>œ>¨6Ñ2Ô2Ð3ˆØð (ð (ˆEØˆDØ!œLð Eð EØ#+¤=ðEðE‘KE˜4ØÐ(Ø"˜ 4¨¯ª¸ÀÑ)CÔ)CÑDÔDÐDøðEõ"(¨¯ ª ©¬Ñ!5Ô!5ð (ð (‘ vØ ð&ð&BØ”y FÒ*Ð*Ø˜ð+õ" &¨&Ñ1Ô1BØ—M’M "Ñ%Ô%Ð%Ø—’˜R Ñ'Ô'Ð'Ð'ð (ðˆ rcól—td|¦«|g}t|¦«D]\}}td|||urdpd¦«|jD]l\}}||vr| |¦«} n$t |¦«} | |¦«|€td| z¦«ŒXtd|| fz¦«ŒmŒ‘dS)NzDump of NFA forú Stateú(final)Úz -> %dú %s -> %d)ÚprintÚ enumerater.r2r*r0) rr9r6rzÚtodor:r<r=r>Újs r Údump_nfazParserGenerator.dump_nfaÍsä€Ý Ð Ñ&Ô&Ð&ØˆwˆÝ! $™œð 7ð 7‰HˆAˆuÝ)˜Q ¨ Ð =°IÐ CÀÑDÔDÐDØ$œzð 7ð 7‘tØ˜4<<ØŸ š 4Ñ(Ô(AAå˜D™ œ AØ—K’K Ñ%Ô%Ð%Ø=Ý˜+¨™/Ñ*Ô*Ð*Ð*å˜.¨E°1¨:Ñ5Ñ6Ô6Ð6Ð6ð 7ð 7ð 7rc ó*—td|¦«t|¦«D]r\}}td||jrdpd¦«t|j ¦«¦«D],\}}td|| |¦«fz¦«Œ-ŒsdS)NzDump of DFA forr~rr€r)r‚rƒr3r-r.r/r2)rr9r;r:r<r=r>s r Údump_dfazParserGenerator.dump_dfaÝs®€Ý Ð Ñ&Ô&Ð&Ý! #™œð Að A‰HˆAˆuÝ)˜Q ¤ Ð ;°)Ð A¸rÑBÔBÐBÝ% e¤j×&6Ò&6Ñ&8Ô&8Ñ9Ô9ð Að A‘tÝn¨¨s¯yªy¸©¬Ð'?Ñ?Ñ@Ô@Ð@Ð@ð Að Að Arcóê—d}|rnd}t|¦«D]X\}}t|dzt|¦«¦«D]2}||}||kr"||=|D]}| ||¦«Œd}nŒ3ŒY|°ldSdS)NTFr)rƒÚranger*Ú unifystate)rr;Úchangesr:Ústate_ir…Ústate_jr<s r rjzParserGenerator.simplify_dfaäsÃ€ðˆØð ØˆGÝ'¨™nœnð ð ‘ 7Ý˜q ™s¥C¨¡H¤HÑ-Ô-ððAØ! !œfGØ 'Ò)Ð)à ˜FØ%(ð?ð?˜EØ!×,Ò,¨W°gÑ>Ô>Ð>Ð>Ø"&˜Ø˜ð *øðð ð ð ð ð rcó¸—| ¦«\}}|jdkr||fSt¦«}t¦«}| |¦«| |¦«|jdkr`| ¦«| ¦«\}}| |¦«| |¦«|jdk°`||fS)Nú|)Ú parse_altrTruryr)rrkrlÚaaÚzzs r rhzParserGenerator.parse_rhsùsÀ€à~Š~ÑÔ‰ˆˆ1ØŒ:˜ÒÐØa4ˆKå‘”ˆBÝ‘”ˆBØIŠIa‰LŒLˆLØ HŠHR‰LŒLˆLØ”* Ò#Ð#Ø— ’ ‘”Ø—~’~Ñ'Ô'‘1Ø— ’ ˜!‘”Ø—’˜‘”ð ”* Ò#Ð#ð r6ˆMrcó4—| ¦«\}}|jdvs|jtjtjfvrV| ¦«\}}| |¦«|}|jdv°7|jtjtjfv°V||fS)N)ú(ú[)Ú parse_itemrTrcrrQÚSTRINGry)rrkÚbr7Úds r r‘zParserGenerator.parse_alt s€àŠÑ Ô ‰ˆˆ1ØŒz˜ZÐ'Ð'ØŒyUœZ¬Ð6Ð6Ð6Ø—?’?Ñ$Ô$‰DˆAˆqØ HŠHQ‰KŒKˆKØˆAð Œz˜ZÐ'Ð'ØŒyUœZ¬Ð6Ð6Ð6ð!ˆtˆrcóš—|jdkrd| ¦«| ¦«\}}| tjd¦«| |¦«||fS| ¦«\}}|j}|dvr||fS| ¦«| |¦«|dkr||fS||fS)Nr–ú])ú+Ú*r)rTrrhrfrrgryÚ parse_atom)rrkrlrTs r r—zParserGenerator.parse_itemsÂ€àŒ:˜ÒÐØMŠM‰OŒOˆOØ—>’>Ñ#Ô#‰DˆAˆqØKŠKœ #Ñ&Ô&Ð&Ø HŠHQ‰KŒKˆKØa4ˆKà—?’?Ñ$Ô$‰DˆAˆqØ”JˆEØ˜JÐ&Ð&Ø˜!tØMŠM‰OŒOˆOØ HŠHQ‰KŒKˆKØ˜Š|ˆ|Ø˜!tà˜!trcóØ—|jdkrO| ¦«| ¦«\}}| tjd¦«||fS|jtjtjfvrOt¦«}t¦«}| ||j¦«| ¦«||fS| d|j|j¦«dS)Nr•ú)z+expected (...) or NAME or STRING, got %s/%s)rTrrhrfrrgrcrQr˜ruryÚraise_error)rrkrls r rŸzParserGenerator.parse_atom(sÐ€àŒ:˜ÒÐØMŠM‰OŒOˆOØ—>’>Ñ#Ô#‰DˆAˆqØKŠKœ #Ñ&Ô&Ð&Øa4ˆKØ ŒY5œ:¥u¤|Ð4Ð 4Ð 4Ý‘ ” ˆAÝ‘ ” ˆAØ HŠHQ˜œ Ñ#Ô#Ð#ØMŠM‰OŒOˆOØa4ˆKà×ÒÐJØ!œY¨¬ ñ 4ô 4ð 4ð 4ð 4rcó²—|j|ks |.|j|kr#| d|||j|j¦«|j}| ¦«|S)Nzexpected %s/%s, got %s/%s)rcrTr¢r)rrcrTs r rfzParserGenerator.expect9sd€ØŒ9˜ÒÐ Ð!2°t´zÀUÒ7JÐ7JØ×ÒÐ8Ø! 5¨$¬)°T´Zñ Aô Að Aà” ˆØ Š ‰ŒˆØˆrcó—t|j¦«}|dtjtjfvr4t|j¦«}|dtjtjfv°4|\|_|_|_|_|_ dS)Nr#) r>rrÚCOMMENTÚNLrcrTÚbeginÚendÚline)rÚtups r rzParserGenerator.gettokenAsr€Ý4”>Ñ"Ô"ˆØ!ŒfÔ)8¬;Ð7Ð7Ð7Ýt”~Ñ&Ô&ˆCð!ŒfÔ)8¬;Ð7Ð7Ð7àADÑ>ˆŒ 4”:˜tœz¨4¬8°T´Y°Y°Yrc óü—|rG ||z}n@#d |gttt|¦«¦«z¦«}YnxYwt ||j|jd|jd|jf¦«‚)Nú r#r)Újoinr%ÚmapÚstrÚSyntaxErrorrr¨r©)rÚmsgÚargss r r¢zParserGenerator.raise_errorHs€Øð =ð =Ø˜D‘jøð =Ø—h’h ˜u¥tCµ°T©N¬NÑ';Ô';Ñ;Ñ<Ô<øøøÝ˜# ¤ ¨t¬x¸¬{Ø $¤¨¤¨T¬Yð 8ñ9ô9ð 9s „ Š;ArV)rr r r!r?r5r1rrWrrir†rˆrjrhr‘r—rŸrfrr¢rrr rr s4€€€€€ð ð ð ð ðððð2ððð,"ð,"ð,"ð\%ð%ð%ð$ð$ð$ð<!ð!ð!ð0"ð"ð"ðH7ð7ð7ð AðAðAðððð*ððð"ðððððð(4ð4ð4ð"ððððEðEðEð9ð9ð9ð9ð9rrcó—eZdZd„Zdd„ZdS)rucó—g|_dSrV)r.)rs r r!zNFAState.__init__Ss €ØˆŒ ˆ ˆ rNcóž—|t|t¦«sJ‚t|t¦«sJ‚|j ||f¦«dSrV)rKr¯rur.r0©rr>r=s r ryzNFAState.addarcVsP€Øˆ}¥ ¨5µ#Ñ 6Ô 6ˆ}ˆ}Ð6Ý˜$¥Ñ)Ô)Ð)Ð)Ð)ØŒ ×Ò˜% ˜Ñ'Ô'Ð'Ð'Ð'rrV)rr r r!ryrrr ruruQs7€€€€€ðððð(ð(ð(ð(ð(ð(rrucó*—eZdZd„Zd„Zd„Zd„ZdZdS)rvcóò—t|t¦«sJ‚ttt|¦«¦«t¦«sJ‚t|t¦«sJ‚||_||v|_i|_dSrV)rKÚdictr>Úiterrurwr3r.)rrwÚfinals r r!zDFAState.__init__]so€Ý˜&¥$Ñ'Ô'Ð'Ð'Ð'Ý$t F™|œ|Ñ,Ô,hÑ7Ô7Ð7Ð7Ð7Ý˜%¥Ñ*Ô*Ð*Ð*Ð*ØˆŒØ ˆŒØˆŒ ˆ ˆ rcóŒ—t|t¦«sJ‚||jvsJ‚t|t¦«sJ‚||j|<dSrV)rKr¯r.rvr¶s r ryzDFAState.addarcesS€Ý˜%¥Ñ%Ô%Ð%Ð%Ð%Ø˜DœIÐ%Ð%Ð%Ð%Ý˜$¥Ñ)Ô)Ð)Ð)Ð)ØˆŒ %ÑÐÐrcó`—|j ¦«D]\}}||ur ||j|<ŒdSrV)r.r/)rÚoldÚnewr=r>s r r‹zDFAState.unifystateksA€Øœ9Ÿ?š?Ñ,Ô,ð 'ð '‰KˆE4Øsˆ{ˆ{Ø#&” ˜%Ñ øð 'ð 'rcó,—t|t¦«sJ‚|j|jkrdSt|j¦«t|j¦«krdS|j ¦«D]$\}}||j |¦«urdSŒ%dS)NFT)rKrvr3r*r.r/Úget)rÚotherr=r>s r Ú__eq__zDFAState.__eq__ps—€å˜%¥Ñ*Ô*Ð*Ð*Ð*ØŒ<˜5œ=Ò(Ð(Ø5õˆtŒy‰>Œ>S ¤™_œ_Ò,Ð,Ø5Øœ9Ÿ?š?Ñ,Ô,ð ð ‰KˆE4Ø˜5œ:Ÿ>š>¨%Ñ0Ô0Ð0Ð0Øuuð1àˆtrN)rr r r!ryr‹rÃÚ__hash__rrr rvrv[sQ€€€€€ðððð ð ð ð'ð'ð'ð ððð€H€H€HrrvúGrammar.txtcóH—t|¦«}| ¦«SrV)rr?)rÚps r Úgenerate_grammarrÈ€s€Ý˜Ñ!Ô!€AØ>Š>ÑÔÐrN)rÅ)r€rrrÚGrammarrÚobjectrrurvrÈrrr úrËs÷ðð 'Ð&Ð&Ð&Ð&Ð&Ð&Ð&Ð&Ð&ð ð ð ð ð '”/ñ ô ð ðE9ðE9ðE9ðE9ðE9fñE9ôE9ðE9ðN (ð(ð(ð(ð(ˆvñ(ô(ð(ð#ð#ð#ð#ð#ˆvñ#ô#ð#ðJðððððrPKhP3]¾„ûX]])__pycache__/grammar.cpython-311.opt-2.pycnu„[µü¤§ àÀf°ãóÄ— ddlZddlmZGd„de¦«ZdZiZe ¦«D]*Zer&e ¦«\Z Zeee¦«ee <Œ+[[ [dS)éNé)Útokencó4—eZdZ d„Zd„Zd„Zd„Zd„Zd„ZdS)ÚGrammarcó†—i|_i|_g|_i|_dg|_i|_i|_i|_d|_dS)N)rÚEMPTYé) Ú symbol2numberÚ number2symbolÚstatesÚdfasÚlabelsÚkeywordsÚtokensÚsymbol2labelÚstart)Úselfs ú GREATER = EQUAL . DOT % PERCENT ` BACKQUOTE { LBRACE } RBRACE @ AT @= ATEQUAL == EQEQUAL != NOTEQUAL <> NOTEQUAL <= LESSEQUAL >= GREATEREQUAL ~ TILDE ^ CIRCUMFLEX << LEFTSHIFT >> RIGHTSHIFT ** DOUBLESTAR += PLUSEQUAL -= MINEQUAL *= STAREQUAL /= SLASHEQUAL %= PERCENTEQUAL &= AMPEREQUAL |= VBAREQUAL ^= CIRCUMFLEXEQUAL <<= LEFTSHIFTEQUAL >>= RIGHTSHIFTEQUAL **= DOUBLESTAREQUAL // DOUBLESLASH //= DOUBLESLASHEQUAL -> RARROW := COLONEQUAL ) rÚrÚobjectrÚ opmap_rawÚopmapÚ splitlinesÚlineÚsplitÚopÚnamer+r8rrúrBsÀðð ð€ € € ðÐÐÐÐÐðj#ðj#ðj#ðj#ðj#ˆfñj#ôj#ðj#ð^1 € ðf €Ø× Ò Ñ"Ô"ð)ð)€DØð)Ø—:’:‘<”<‰ˆˆDØG˜E 4Ñ(Ô(ˆˆb‰ øØˆ"ˆdˆdˆdrPKw4]¤&ï*úúliterals.pyonu„[µü¤ó {fc@s“dZddlZi dd6dd6dd6d d 6dd6d d6dd6dd6dd6dd6Zd„Zd„Zd„ZedkreƒndS(s<Safely evaluate Python string literals without using eval().iÿÿÿÿNstastbstfs tns trs ttstvt't"s\cCsð|jddƒ\}}tj|ƒ}|dk r7|S|jdƒr¯|d}t|ƒdkrutd|ƒ‚nyt|dƒ}Wqætk r«td|ƒ‚qæXn7yt|dƒ}Wn!tk råtd|ƒ‚nXt|ƒS( Niitxis!invalid hex string escape ('\%s')iis#invalid octal string escape ('\%s')( tgrouptsimple_escapestgettNonet startswithtlent ValueErrortinttchr(tmtallttailtescthexesti((s./usr/lib64/python2.7/lib2to3/pgen2/literals.pytescapes" cCsX|d}|d |dkr+|d}n|t|ƒt|ƒ!}tjdt|ƒS(Niis)\\(\'|\"|\\|[abfnrtv]|x.{0,2}|[0-7]{1,3})(RtretsubR(tstq((s./usr/lib64/python2.7/lib2to3/pgen2/literals.pyt evalString(s cCs_xXtdƒD]J}t|ƒ}t|ƒ}t|ƒ}||kr |G|G|G|GHq q WdS(Ni(trangeRtreprR(RtcRte((s./usr/lib64/python2.7/lib2to3/pgen2/literals.pyttest2st__main__(t__doc__RRRRR#t__name__(((s./usr/lib64/python2.7/lib2to3/pgen2/literals.pyts PKw4]qCÎ/Î/pgen.pycnu„[µü¤ó {fc@s‡ddlmZmZmZdejfd„ƒYZdefd„ƒYZdefd„ƒYZdefd „ƒYZ d d„Z dS( i(tgrammarttokenttokenizetPgenGrammarcBseZRS((t__name__t __module__(((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRstParserGeneratorcBs°eZdd„Zd„Zd„Zd„Zd„Zd„Zd„Z d„Z d„Zd „Zd „Z d„Zd„Zd „Zd„Zdd„Zd„Zd„ZRS(cCs d}|dkr*t|ƒ}|j}n||_||_tj|jƒ|_|j ƒ|j ƒ\|_|_|dk r‰|ƒni|_ |jƒdS(N(tNonetopentclosetfilenametstreamRtgenerate_tokenstreadlinet generatortgettokentparsetdfaststartsymboltfirsttaddfirstsets(tselfR Rtclose_stream((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyt__init__s cCsŽtƒ}|jjƒ}|jƒ|j|jƒ|jd|jƒx;|D]3}dt|jƒ}||j|<||j | %ds %s -> %d(t enumerateR R$RR"R( RR+R(RdttodoR,R.R/R0tj((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pytdump_nfaÍs cCs„dG|GHxtt|ƒD]f\}}dG|G|jr9dp<dGHx;t|jjƒƒD]$\}}d||j|ƒfGHqTWqWdS(NsDump of DFA fors States(final)Rgs %s -> %d(RhR%RR R!R$(RR+R-R,R.R/R0((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pytdump_dfaÝs "cCs¦t}x™|r¡t}x†t|ƒD]x\}}xit|dt|ƒƒD]N}||}||krH||=x|D]}|j||ƒqrWt}PqHqHWq"Wq WdS(Ni(tTruetFalseRhtrangeRt unifystate(RR-tchangesR,tstate_iRjtstate_jR.((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRWäs cCs±|jƒ\}}|jdkr+||fStƒ}tƒ}|j|ƒ|j|ƒxI|jdkr¢|jƒ|jƒ\}}|j|ƒ|j|ƒqZW||fSdS(Nt|(t parse_altRER_RcR(RRXRYtaatzz((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRUùs cCsr|jƒ\}}xS|jdks?|jtjtjfkrg|jƒ\}}|j|ƒ|}qW||fS(Nt(t[(RxRy(t parse_itemRERPRRBtSTRINGRc(RRXtbR)td((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRu s cCsÁ|jdkrU|jƒ|jƒ\}}|jtjdƒ|j|ƒ||fS|jƒ\}}|j}|dkr†||fS|jƒ|j|ƒ|dkr³||fS||fSdS(NRyt]t+t*(RR€(RERRURSRRTRct parse_atom(RRXRYRE((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRzs cCs¹|jdkrH|jƒ|jƒ\}}|jtjdƒ||fS|jtjtjfkrœt ƒ}t ƒ}|j ||jƒ|jƒ||fS|jd|j|jƒdS(NRxt)s+expected (...) or NAME or STRING, got %s/%s(RERRURSRRTRPRBR{R_Rctraise_error(RRXRY((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyR(s cCsc|j|ks*|dk rL|j|krL|jd|||j|jƒn|j}|jƒ|S(Nsexpected %s/%s, got %s/%s(RPRRERƒR(RRPRE((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRS9s* cCsi|jjƒ}x/|dtjtjfkr@|jjƒ}qW|\|_|_|_|_|_ dS(Ni( RR0RtCOMMENTtNLRPREtbegintendtline(Rttup((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRAscGss|r@y||}Wq@dj|gtt|ƒƒ}q@Xnt||j|jd|jd|jfƒ‚dS(Nt ii(tjointmaptstrtSyntaxErrorR R‡Rˆ(Rtmsgtargs((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRƒHs&N(RRRRR1R'R#RRFRRVRkRlRWRURuRzRRSRRƒ(((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyR s$ . $ R_cBseZd„Zdd„ZRS(cCs g|_dS(N(R (R((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRSscCsP|dks!t|tƒs!t‚t|tƒs6t‚|jj||fƒdS(N(RR:RR=R_R R"(RR0R/((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRcVs!N(RRRRRc(((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyR_Qs R`cBs2eZd„Zd„Zd„Zd„ZdZRS(cCspt|tƒst‚tt|ƒjƒtƒs6t‚t|tƒsKt‚||_||k|_i|_dS(N( R:tdictR=titerR0R_RaR%R (RRatfinal((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyR]s! cCsPt|tƒst‚||jks*t‚t|tƒs?t‚||j|sÿH %PKw4]C›Ëi-i-pgen.pyonu„[µü¤ó {fc@s‡ddlmZmZmZdejfd„ƒYZdefd„ƒYZdefd„ƒYZdefd „ƒYZ d d„Z dS( i(tgrammarttokenttokenizetPgenGrammarcBseZRS((t__name__t __module__(((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRstParserGeneratorcBs°eZdd„Zd„Zd„Zd„Zd„Zd„Zd„Z d„Z d„Zd „Zd „Z d„Zd„Zd „Zd„Zdd„Zd„Zd„ZRS(cCs d}|dkr*t|ƒ}|j}n||_||_tj|jƒ|_|j ƒ|j ƒ\|_|_|dk r‰|ƒni|_ |jƒdS(N(tNonetopentclosetfilenametstreamRtgenerate_tokenstreadlinet generatortgettokentparsetdfaststartsymboltfirsttaddfirstsets(tselfR Rtclose_stream((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyt__init__s cCsŽtƒ}|jjƒ}|jƒ|j|jƒ|jd|jƒx;|D]3}dt|jƒ}||j|<||j | %ds %s -> %d(t enumerateR R$RR"R( RR+R(R\ttodoR,R.R/R0tj((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pytdump_nfaÍs cCs„dG|GHxtt|ƒD]f\}}dG|G|jr9dp<dGHx;t|jjƒƒD]$\}}d||j|ƒfGHqTWqWdS(NsDump of DFA fors States(final)R_s %s -> %d(R`R%RR R!R$(RR+R-R,R.R/R0((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pytdump_dfaÝs "cCs¦t}x™|r¡t}x†t|ƒD]x\}}xit|dt|ƒƒD]N}||}||krH||=x|D]}|j||ƒqrWt}PqHqHWq"Wq WdS(Ni(tTruetFalseR`trangeRt unifystate(RR-tchangesR,tstate_iRbtstate_jR.((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRPäs cCs±|jƒ\}}|jdkr+||fStƒ}tƒ}|j|ƒ|j|ƒxI|jdkr¢|jƒ|jƒ\}}|j|ƒ|j|ƒqZW||fSdS(Nt|(t parse_altR>tNFAStateR[R(RRQRRtaatzz((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRNùs cCsr|jƒ\}}xS|jdks?|jtjtjfkrg|jƒ\}}|j|ƒ|}qW||fS(Nt(t[(RqRr(t parse_itemR>RIRR;tSTRINGR[(RRQtbR)td((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRm s cCsÁ|jdkrU|jƒ|jƒ\}}|jtjdƒ|j|ƒ||fS|jƒ\}}|j}|dkr†||fS|jƒ|j|ƒ|dkr³||fS||fSdS(NRrt]t+t*(RxRy(R>RRNRLRRMR[t parse_atom(RRQRRR>((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRss cCs¹|jdkrH|jƒ|jƒ\}}|jtjdƒ||fS|jtjtjfkrœt ƒ}t ƒ}|j ||jƒ|jƒ||fS|jd|j|jƒdS(NRqt)s+expected (...) or NAME or STRING, got %s/%s(R>RRNRLRRMRIR;RtRnR[traise_error(RRQRR((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRz(s cCsc|j|ks*|dk rL|j|krL|jd|||j|jƒn|j}|jƒ|S(Nsexpected %s/%s, got %s/%s(RIRR>R|R(RRIR>((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRL9s* cCsi|jjƒ}x/|dtjtjfkr@|jjƒ}qW|\|_|_|_|_|_ dS(Ni( RR0RtCOMMENTtNLRIR>tbegintendtline(Rttup((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRAscGss|r@y||}Wq@dj|gtt|ƒƒ}q@Xnt||j|jd|jd|jfƒ‚dS(Nt ii(tjointmaptstrtSyntaxErrorR R€R(Rtmsgtargs((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyR|Hs&N(RRRRR1R'R#RR?RRORcRdRPRNRmRsRzRLRR|(((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyR s$ . $ RncBseZd„Zdd„ZRS(cCs g|_dS(N(R (R((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRSscCs|jj||fƒdS(N(R R"(RR0R/((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyR[VsN(RRRRR[(((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyRnQs RXcBs2eZd„Zd„Zd„Zd„ZdZRS(cCs%||_||k|_i|_dS(N(RYR%R (RRYtfinal((s*/usr/lib64/python2.7/lib2to3/pgen2/pgen.pyR]s cCs||j|sÿH %PKw4]ãÿ?? driver.pycnu„[µü¤ó {fc@sdZdZddgZddlZddlZddlZddlZddlZddlZddl m Z mZmZm Z mZdefd„ƒYZd „Zd deedd„Zd„Zd „Zd„ZedkrejeeƒƒƒndS(sZParser driver. This provides a high-level interface to parse a file into a syntax tree. s#Guido van Rossum tDrivertload_grammariÿÿÿÿNi(tgrammartparsettokenttokenizetpgencBsVeZddd„Zed„Zed„Zed„Zded„Zed„Z RS(cCs:||_|dkr$tjƒ}n||_||_dS(N(RtNonetloggingt getLoggertloggertconvert(tselfRRR ((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyt__init__ s cCs=tj|j|jƒ}|jƒd}d}d }}}} } d}xé|D]Ã}|\}}}} } |||fkr ||f|ks¨t||f|fƒ‚|\} }|| krá|d| |7}| }d}n||kr || ||!7}|}q n|tjtj fkr`||7}| \}}|j dƒrQ|d7}d}qQqQn|tjkrtj |}n|r¨|jjdtj|||ƒn|j||||fƒrà|rÜ|jjdƒnPnd}| \}}|j dƒrQ|d7}d}qQqQWtjd||||fƒ‚|jS( s4Parse a series of tokens and return the syntax tree.iius s%s %r (prefix=%r)sStop.tsincomplete inputN(RtParserRRtsetupRtAssertionErrorRtCOMMENTtNLtendswithRtOPtopmapR tdebugttok_nametaddtokent ParseErrortrootnode(RttokensRtptlinenotcolumnttypetvaluetstarttendt line_texttprefixt quintuplets_linenots_column((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pytparse_tokens'sT * cCs"tj|jƒ}|j||ƒS(s*Parse a stream and return the syntax tree.(Rtgenerate_tokenstreadlineR)(RtstreamRR((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pytparse_stream_rawWscCs|j||ƒS(s*Parse a stream and return the syntax tree.(R-(RR,R((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pytparse_stream\scCs;tj|d|ƒ}z|j||ƒSWd|jƒXdS(s(Parse a file and return the syntax tree.trN(tcodecstopenR.tclose(RtfilenametencodingRR,((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyt parse_file`scCs+tjtj|ƒjƒ}|j||ƒS(s*Parse a string and return the syntax tree.(RR*tStringIOR+R)(RttextRR((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pytparse_stringhsN( t__name__t __module__RR tFalseR)R-R.R5R8(((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyRs0cCsRtjj|ƒ\}}|dkr-d}n||djtttjƒƒdS(Ns.txtRt.s.pickle(tostpathtsplitexttjointmaptstrtsystversion_info(tgttheadttail((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyt_generate_pickle_namens sGrammar.txtcCsÞ|dkrtjƒ}n|dkr3t|ƒn|}|sOt||ƒrÁ|jd|ƒtj|ƒ}|rÚ|jd|ƒy|j|ƒWq¾t k rº}|jd|ƒq¾XqÚnt jƒ}|j|ƒ|S(s'Load the grammar (maybe from a pickle).s!Generating grammar tables from %ssWriting grammar tables to %ssWriting failed: %sN( RRR RHt_newertinfoRtgenerate_grammartdumptIOErrorRtGrammartload(REtgptsavetforceR tgte((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyRus cCsNtjj|ƒstStjj|ƒs,tStjj|ƒtjj|ƒkS(s0Inquire whether file a was written since file b.(R=R>texistsR;tTruetgetmtime(tatb((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyRIŠs cCsctjj|ƒrt|ƒSttjj|ƒƒ}tj||ƒ}tj ƒ}|j |ƒ|S(sÙNormally, loads a pickled grammar by doing pkgutil.get_data(package, pickled_grammar) where *pickled_grammar* is computed from *grammar_source* by adding the Python version and using a ``.pickle`` extension. However, if *grammar_source* is an extant file, load_grammar(grammar_source) is called instead. This facilitates using a packaged grammar file when needed but preserves load_grammar's automatic regeneration behavior when possible. (R=R>tisfileRRHtbasenametpkgutiltget_dataRRNtloads(tpackagetgrammar_sourcetpickled_nametdataRS((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pytload_packaged_grammar“s cGsc|stjd}ntjdtjdtjddƒx$|D]}t|dtdtƒq?WtS(sMain program, when run as a script: produce grammar pickle files. Calls load_grammar for each argument, a path to a grammar text file. itlevelR,tformats%(message)sRQRR(RCtargvRtbasicConfigtINFOtstdoutRRV(targsRE((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pytmain§s t__main__(t__doc__t __author__t__all__R0R=RR\R6RCRRRRRRtobjectRRHRRVR;RRIRcRkR9texittint(((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyts$(P PKw4]Íã(ÿÿ token.pyonu„[µü¤ó {fc@sÒdZdZdZdZdZdZdZdZdZd Z d Z dZdZd Z dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd Z d!Z!d"Z"d#Z#d$Z$d%Z%d&Z&d'Z'd(Z(d)Z)d*Z*d+Z+d,Z,d-Z-d.Z.d/Z/d0Z0d1Z1d2Z2d3Z3d4Z4d5Z5d6Z6d7Z7d8Z8d9Z9d:Z:d;Z;iZ<xBe=ƒj>ƒD]1\Z?Z@eAe@ƒeAdƒkr~e?e<e@„ZDd?S(@s!Token constants (from "token.h").iiiiiiiiii i iii iiiiiiiiiiiiiiiiiii i!i"i#i$i%i&i'i(i)i*i+i,i-i.i/i0i1i2i3i4i5i6i7i8i9icCs |tkS(N(t NT_OFFSET(tx((s+/usr/lib64/python2.7/lib2to3/pgen2/token.pyt ISTERMINALLscCs |tkS(N(R(R((s+/usr/lib64/python2.7/lib2to3/pgen2/token.pyt ISNONTERMINALOscCs |tkS(N(t ENDMARKER(R((s+/usr/lib64/python2.7/lib2to3/pgen2/token.pytISEOFRsN(Et__doc__RtNAMEtNUMBERtSTRINGtNEWLINEtINDENTtDEDENTtLPARtRPARtLSQBtRSQBtCOLONtCOMMAtSEMItPLUStMINUStSTARtSLASHtVBARtAMPERtLESStGREATERtEQUALtDOTtPERCENTt BACKQUOTEtLBRACEtRBRACEtEQEQUALtNOTEQUALt LESSEQUALtGREATEREQUALtTILDEt CIRCUMFLEXt LEFTSHIFTt RIGHTSHIFTt DOUBLESTARt PLUSEQUALtMINEQUALt STAREQUALt SLASHEQUALtPERCENTEQUALt AMPEREQUALt VBAREQUALtCIRCUMFLEXEQUALtLEFTSHIFTEQUALtRIGHTSHIFTEQUALtDOUBLESTAREQUALtDOUBLESLASHtDOUBLESLASHEQUALtATtATEQUALtOPtCOMMENTtNLtRARROWt ERRORTOKENtN_TOKENSRttok_nametglobalstitemst_namet_valuettypeRRR(((s+/usr/lib64/python2.7/lib2to3/pgen2/token.pyts„ PKw4]Å‰ÃÓýýconv.pycnu„[µü¤ó {fc@sEdZddlZddlmZmZdejfd„ƒYZdS(sýConvert graminit.[ch] spit out by pgen to Python code. Pgen is the Python parser generator. It is useful to quickly create a parser from a grammar file in Python's grammar notation. But I don't want my parsers to be written in C (yet), so I'm translating the parsing tables to Python data structures and writing a Python parse engine. Note that the token numbers are constants determined by the standard Python tokenizer. The standard token module defines these numbers and their names (the names are not used much). The token numbers are hardcoded into the Python tokenizer and into pgen. A Python implementation of the Python tokenizer is also available, in the standard tokenize module. On the other hand, symbol numbers (representing the grammar's non-terminals) are assigned by pgen based on the actual grammar input. Note: this module is pretty much obsolete; the pgen module generates equivalent grammar tables directly from the Grammar.txt input file without having to invoke the Python pgen C program. iÿÿÿÿN(tgrammarttokent ConvertercBs2eZdZd„Zd„Zd„Zd„ZRS(s2Grammar subclass that reads classic pgen output files. The run() method reads the tables as produced by the pgen parser generator, typically contained in two C files, graminit.h and graminit.c. The other methods are for internal use only. See the base class for more documentation. cCs(|j|ƒ|j|ƒ|jƒdS(s<Load the grammar tables from the text files written by pgen.N(tparse_graminit_htparse_graminit_ct finish_off(tselft graminit_ht graminit_c((s*/usr/lib64/python2.7/lib2to3/pgen2/conv.pytrun/s c Csyt|ƒ}Wn#tk r5}d||fGHtSXi|_i|_d}xº|D]²}|d7}tjd|ƒ}|r¥|jƒr¥d|||jƒfGHqU|jƒ\}}t |ƒ}||jksØt ‚||jksít ‚||j|<||j|@r¦d||d|_[] = { {, }, ... }; - followed by a state array, of the form: static state states_[] = { {, arcs__}, ... }; sCan't open %s: %siis#include "pgenheaders.h" s#include "grammar.h" sstatic arc s)static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$s\s+{(\d+), (\d+)},$s}; s'static state states_(\d+)\[(\d+)\] = {$s\s+{(\d+), arcs_(\d+)_(\d+)},$sstatic dfa dfas\[(\d+)\] = {$s0\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$iiiis\s+("(?:\\\d\d\d)*")},$is!static label labels\[(\d+)\] = {$s\s+{(\d+), (0|"\w+")},$t0sgrammar _PyParser_Grammar = { s \s+(\d+),$s dfas, s\s+{(\d+), labels},$s \s+(\d+)$N(R RRtnextRt startswithRRtmapRRtrangetappendtlentstatestgroupR Rtevalt enumeratetordtdfastNonetlabelststartt StopIteration(!RRRRRRtallarcsR%Rtntmtktarcst_titjtstttstateR*tndfasRRtxtytztfirstt rawbitsettctbyteR,tnlabelsR-((s*/usr/lib64/python2.7/lib2to3/pgen2/conv.pyRTsö $$ -%% $ '! cCsƒi|_i|_xjt|jƒD]Y\}\}}|tjkr_|dk r_||j|sPKw4]ùKÅ%®®__init__.pycnu„[µü¤ó {fc@s dZdS(sThe pgen2 package.N(t__doc__(((s./usr/lib64/python2.7/lib2to3/pgen2/__init__.pyttPKw4]¼UØgrammar.pycnu„[µü¤ó {fc@s¨dZddlZddlZddlmZmZdefd„ƒYZd„ZdZ iZ xBe jƒD]4Zerlej ƒ\ZZeeeƒe et|dƒ)}t|jƒ}tj||dƒWdQXdS(s½Dump the grammar tables to a pickle file. dump() recursively changes all dict to OrderedDict, so the pickled file is not exactly the same as what was passed in to dump(). load() uses the pickled file to create the tables, but only changes OrderedDict to dict at the top level; it does not recursively change OrderedDict to dict. So, the loaded tables are different from the original tables that were passed to load() in that some of the OrderedDict (from the pickled file) are not changed back to dict. For parsing, this has no effect on performance because OrderedDict uses dict's __getitem__ with nothing in between. twbiN(topent_make_deterministict__dict__tpickletdump(R tfilenametftd((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyRXs cCs<t|dƒ}tj|ƒ}|jƒ|jj|ƒdS(s+Load the grammar tables from a pickle file.trbN(RRtloadtcloseRtupdate(R RRR((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyRis cCs|jjtj|ƒƒdS(s3Load the grammar tables from a pickle bytes object.N(RRRtloads(R tpkl((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyRpscCsf|jƒ}x-dD]%}t||t||ƒjƒƒqW|j|_|j|_|j|_|S(s# Copy the grammar. RRRR R R(RRRR R R(t __class__tsetattrtgetattrtcopyRRR(R tnewt dict_attr((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyR!ts # cCszddlm}dGH||jƒdGH||jƒdGH||jƒdGH||jƒdGH||jƒdG|jGHd S( s:Dump the grammar tables to standard output, for debugging.iÿÿÿÿ(tpprintts2ntn2sRRRRN(R$RRRRRR(R R$((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pytreports ( t__name__t __module__t__doc__RRRRR!R'(((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyRs4 cCs…t|tƒr2tjtd„|jƒDƒƒƒSt|tƒr^g|D]}t|ƒ^qHSt|tƒrtd„|DƒƒS|S(Ncss'|]\}}|t|ƒfVqdS(N(R(t.0tktv((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pys ”scss|]}t|ƒVqdS(N(R(R+te((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pys ˜s( t isinstancetdicttcollectionstOrderedDicttsortedt iteritemstlistRttuple(ttopR.((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyR‘ss ( LPAR ) RPAR [ LSQB ] RSQB : COLON , COMMA ; SEMI + PLUS - MINUS * STAR / SLASH | VBAR & AMPER < LESS > GREATER = EQUAL . DOT % PERCENT ` BACKQUOTE { LBRACE } RBRACE @ AT @= ATEQUAL == EQEQUAL != NOTEQUAL <> NOTEQUAL <= LESSEQUAL >= GREATEREQUAL ~ TILDE ^ CIRCUMFLEX << LEFTSHIFT >> RIGHTSHIFT ** DOUBLESTAR += PLUSEQUAL -= MINEQUAL *= STAREQUAL /= SLASHEQUAL %= PERCENTEQUAL &= AMPEREQUAL |= VBAREQUAL ^= CIRCUMFLEXEQUAL <<= LEFTSHIFTEQUAL >>= RIGHTSHIFTEQUAL **= DOUBLESTAREQUAL // DOUBLESLASH //= DOUBLESLASHEQUAL -> RARROW (R*R1RtRRtobjectRRt opmap_rawtopmapt splitlinestlinetsplittoptnameR (((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyt sz =PKw4]A'He parse.pyonu„[µü¤ó {fc@sFdZddlmZdefd„ƒYZdefd„ƒYZdS(sÈParser engine for the grammar tables generated by pgen. The grammar table must be loaded first. See Parser/parser.c in the Python distribution for additional info on how this parsing engine works. i(ttokent ParseErrorcBseZdZd„ZRS(s(Exception to signal the parser is stuck.cCsHtj|d||||fƒ||_||_||_||_dS(Ns!%s: type=%r, value=%r, context=%r(t Exceptiont__init__tmsgttypetvaluetcontext(tselfRRRR((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pyRs (t__name__t __module__t__doc__R(((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pyRstParsercBsSeZdZdd„Zdd„Zd„Zd„Zd„Zd„Z d„Z RS( s5Parser engine. The proper usage sequence is: p = Parser(grammar, [converter]) # create instance p.setup([start]) # prepare for parsing : if p.addtoken(...): # parse a token; may raise ParseError break root = p.rootnode # root of abstract syntax tree A Parser instance may be reused by calling setup() repeatedly. A Parser instance contains state pertaining to the current token sequence, and should not be used concurrently by different threads to parse separate token sequences. See driver.py for how to get input tokens by tokenizing a file or string. Parsing is complete when addtoken() returns True; the root of the abstract syntax tree can then be retrieved from the rootnode instance variable. When a syntax error occurs, addtoken() raises the ParseError exception. There is no error recovery; the parser cannot be used after a syntax error was reported (but it can be reinitialized by calling setup()). cCs||_|pd„|_dS(sÚConstructor. The grammar argument is a grammar.Grammar instance; see the grammar module for more information. The parser is not ready yet for parsing; you must call the setup() method to get it started. The optional convert argument is a function mapping concrete syntax tree nodes to abstract syntax tree nodes. If not given, no conversion is done and the syntax tree produced is the concrete syntax tree. If given, it must be a function of two arguments, the first being the grammar (a grammar.Grammar instance), and the second being the concrete syntax tree node to be converted. The syntax tree is converted from the bottom up. A concrete syntax tree node is a (type, value, context, nodes) tuple, where type is the node type (a token or symbol number), value is None for symbols and a string for tokens, context is None or an opaque value used for error reporting (typically a (lineno, offset) pair), and nodes is a list of children for symbols, and None for tokens. An abstract syntax tree node may be anything; this is entirely up to the converter function. cSs|S(N((tgrammartnode((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pytWtN(R tconvert(RR R((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pyR9s cCsk|dkr|jj}n|ddgf}|jj|d|f}|g|_d|_tƒ|_dS(s›Prepare for parsing. This *must* be called before starting to parse. The optional argument is an alternative start symbol; it defaults to the grammar's start symbol. You can use a Parser instance to parse any number of programs; each time you call setup() the parser is reset to an initial state determined by the (implicit or explicit) start symbol. iN(tNoneR tstarttdfaststacktrootnodetsett used_names(RRtnewnodet stackentry((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pytsetupYs cCs´|j|||ƒ}x˜tr¯|jd\}}}|\}} ||} x_| D]\}}|jj|\} }||krø|j||||ƒ|}xV||d|fgkró|jƒ|jsÎtS|jd\}}}|\}} qžWtS| dkrQ|jj| }|\}}||krS|j | |jj| ||ƒPqSqQqQWd|f| kr—|jƒ|js¬t d|||ƒ‚q¬qt d|||ƒ‚qWdS(s<Add a token; return True iff this is the end of the program.iÿÿÿÿiistoo much inputs bad inputN(tclassifytTrueRR tlabelstshifttpoptFalseRtpushR(RRRRtilabeltdfatstateRtstatestfirsttarcstitnewstatetttvtitsdfat itsstatestitsfirst((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pytaddtokenqs: cCs„|tjkrG|jj|ƒ|jjj|ƒ}|dk rG|Sn|jjj|ƒ}|dkr€t d|||ƒ‚n|S(s&Turn a token into a label. (Internal)s bad tokenN( RtNAMERtaddR tkeywordstgetRttokensR(RRRRR#((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pyR¡sc Csw|jd\}}}|||df}|j|j|ƒ}|dk r]|dj|ƒn|||f|jdsPKw4]6çpæDD parse.pycnu„[µü¤ó {fc@sFdZddlmZdefd„ƒYZdefd„ƒYZdS(sÈParser engine for the grammar tables generated by pgen. The grammar table must be loaded first. See Parser/parser.c in the Python distribution for additional info on how this parsing engine works. i(ttokent ParseErrorcBseZdZd„ZRS(s(Exception to signal the parser is stuck.cCsHtj|d||||fƒ||_||_||_||_dS(Ns!%s: type=%r, value=%r, context=%r(t Exceptiont__init__tmsgttypetvaluetcontext(tselfRRRR((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pyRs (t__name__t __module__t__doc__R(((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pyRstParsercBsSeZdZdd„Zdd„Zd„Zd„Zd„Zd„Z d„Z RS( s5Parser engine. The proper usage sequence is: p = Parser(grammar, [converter]) # create instance p.setup([start]) # prepare for parsing : if p.addtoken(...): # parse a token; may raise ParseError break root = p.rootnode # root of abstract syntax tree A Parser instance may be reused by calling setup() repeatedly. A Parser instance contains state pertaining to the current token sequence, and should not be used concurrently by different threads to parse separate token sequences. See driver.py for how to get input tokens by tokenizing a file or string. Parsing is complete when addtoken() returns True; the root of the abstract syntax tree can then be retrieved from the rootnode instance variable. When a syntax error occurs, addtoken() raises the ParseError exception. There is no error recovery; the parser cannot be used after a syntax error was reported (but it can be reinitialized by calling setup()). cCs||_|pd„|_dS(sÚConstructor. The grammar argument is a grammar.Grammar instance; see the grammar module for more information. The parser is not ready yet for parsing; you must call the setup() method to get it started. The optional convert argument is a function mapping concrete syntax tree nodes to abstract syntax tree nodes. If not given, no conversion is done and the syntax tree produced is the concrete syntax tree. If given, it must be a function of two arguments, the first being the grammar (a grammar.Grammar instance), and the second being the concrete syntax tree node to be converted. The syntax tree is converted from the bottom up. A concrete syntax tree node is a (type, value, context, nodes) tuple, where type is the node type (a token or symbol number), value is None for symbols and a string for tokens, context is None or an opaque value used for error reporting (typically a (lineno, offset) pair), and nodes is a list of children for symbols, and None for tokens. An abstract syntax tree node may be anything; this is entirely up to the converter function. cSs|S(N((tgrammartnode((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pytWtN(R tconvert(RR R((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pyR9s cCsk|dkr|jj}n|ddgf}|jj|d|f}|g|_d|_tƒ|_dS(s›Prepare for parsing. This *must* be called before starting to parse. The optional argument is an alternative start symbol; it defaults to the grammar's start symbol. You can use a Parser instance to parse any number of programs; each time you call setup() the parser is reset to an initial state determined by the (implicit or explicit) start symbol. iN(tNoneR tstarttdfaststacktrootnodetsett used_names(RRtnewnodet stackentry((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pytsetupYs cCsÆ|j|||ƒ}xªtrÁ|jd\}}}|\}} ||} xq| D]\}}|jj|\} }||kr | dks‘t‚|j||||ƒ|}xV||d|fgkr|jƒ|jsàtS|jd\}}}|\}} q°WtS| dkrQ|jj | }|\}}||kre|j | |jj | ||ƒPqeqQqQWd|f| kr©|jƒ|js¾td|||ƒ‚q¾qtd|||ƒ‚qWdS(s<Add a token; return True iff this is the end of the program.iÿÿÿÿiistoo much inputs bad inputN(tclassifytTrueRR tlabelstAssertionErrortshifttpoptFalseRtpushR(RRRRtilabeltdfatstateRtstatestfirsttarcstitnewstatetttvtitsdfat itsstatestitsfirst((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pytaddtokenqs< cCs„|tjkrG|jj|ƒ|jjj|ƒ}|dk rG|Sn|jjj|ƒ}|dkr€t d|||ƒ‚n|S(s&Turn a token into a label. (Internal)s bad tokenN( RtNAMERtaddR tkeywordstgetRttokensR(RRRRR$((s+/usr/lib64/python2.7/lib2to3/pgen2/parse.pyR¡sc Csw|jd\}}}|||df}|j|j|ƒ}|dk r]|dj|ƒn|||f|jdsPKw4]ùKÅ%®®__init__.pyonu„[µü¤ó {fc@s dZdS(sThe pgen2 package.N(t__doc__(((s./usr/lib64/python2.7/lib2to3/pgen2/__init__.pyttPKw4]Íã(ÿÿ token.pycnu„[µü¤ó {fc@sÒdZdZdZdZdZdZdZdZdZd Z d Z dZdZd Z dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd Z d!Z!d"Z"d#Z#d$Z$d%Z%d&Z&d'Z'd(Z(d)Z)d*Z*d+Z+d,Z,d-Z-d.Z.d/Z/d0Z0d1Z1d2Z2d3Z3d4Z4d5Z5d6Z6d7Z7d8Z8d9Z9d:Z:d;Z;iZ<xBe=ƒj>ƒD]1\Z?Z@eAe@ƒeAdƒkr~e?e<e@„ZDd?S(@s!Token constants (from "token.h").iiiiiiiiii i iii iiiiiiiiiiiiiiiiiii i!i"i#i$i%i&i'i(i)i*i+i,i-i.i/i0i1i2i3i4i5i6i7i8i9icCs |tkS(N(t NT_OFFSET(tx((s+/usr/lib64/python2.7/lib2to3/pgen2/token.pyt ISTERMINALLscCs |tkS(N(R(R((s+/usr/lib64/python2.7/lib2to3/pgen2/token.pyt ISNONTERMINALOscCs |tkS(N(t ENDMARKER(R((s+/usr/lib64/python2.7/lib2to3/pgen2/token.pytISEOFRsN(Et__doc__RtNAMEtNUMBERtSTRINGtNEWLINEtINDENTtDEDENTtLPARtRPARtLSQBtRSQBtCOLONtCOMMAtSEMItPLUStMINUStSTARtSLASHtVBARtAMPERtLESStGREATERtEQUALtDOTtPERCENTt BACKQUOTEtLBRACEtRBRACEtEQEQUALtNOTEQUALt LESSEQUALtGREATEREQUALtTILDEt CIRCUMFLEXt LEFTSHIFTt RIGHTSHIFTt DOUBLESTARt PLUSEQUALtMINEQUALt STAREQUALt SLASHEQUALtPERCENTEQUALt AMPEREQUALt VBAREQUALtCIRCUMFLEXEQUALtLEFTSHIFTEQUALtRIGHTSHIFTEQUALtDOUBLESTAREQUALtDOUBLESLASHtDOUBLESLASHEQUALtATtATEQUALtOPtCOMMENTtNLtRARROWt ERRORTOKENtN_TOKENSRttok_nametglobalstitemst_namet_valuettypeRRR(((s+/usr/lib64/python2.7/lib2to3/pgen2/token.pyts„ PKw4]¼UØgrammar.pyonu„[µü¤ó {fc@s¨dZddlZddlZddlmZmZdefd„ƒYZd„ZdZ iZ xBe jƒD]4Zerlej ƒ\ZZeeeƒe et|dƒ)}t|jƒ}tj||dƒWdQXdS(s½Dump the grammar tables to a pickle file. dump() recursively changes all dict to OrderedDict, so the pickled file is not exactly the same as what was passed in to dump(). load() uses the pickled file to create the tables, but only changes OrderedDict to dict at the top level; it does not recursively change OrderedDict to dict. So, the loaded tables are different from the original tables that were passed to load() in that some of the OrderedDict (from the pickled file) are not changed back to dict. For parsing, this has no effect on performance because OrderedDict uses dict's __getitem__ with nothing in between. twbiN(topent_make_deterministict__dict__tpickletdump(R tfilenametftd((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyRXs cCs<t|dƒ}tj|ƒ}|jƒ|jj|ƒdS(s+Load the grammar tables from a pickle file.trbN(RRtloadtcloseRtupdate(R RRR((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyRis cCs|jjtj|ƒƒdS(s3Load the grammar tables from a pickle bytes object.N(RRRtloads(R tpkl((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyRpscCsf|jƒ}x-dD]%}t||t||ƒjƒƒqW|j|_|j|_|j|_|S(s# Copy the grammar. RRRR R R(RRRR R R(t __class__tsetattrtgetattrtcopyRRR(R tnewt dict_attr((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyR!ts # cCszddlm}dGH||jƒdGH||jƒdGH||jƒdGH||jƒdGH||jƒdG|jGHd S( s:Dump the grammar tables to standard output, for debugging.iÿÿÿÿ(tpprintts2ntn2sRRRRN(R$RRRRRR(R R$((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pytreports ( t__name__t __module__t__doc__RRRRR!R'(((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyRs4 cCs…t|tƒr2tjtd„|jƒDƒƒƒSt|tƒr^g|D]}t|ƒ^qHSt|tƒrtd„|DƒƒS|S(Ncss'|]\}}|t|ƒfVqdS(N(R(t.0tktv((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pys ”scss|]}t|ƒVqdS(N(R(R+te((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pys ˜s( t isinstancetdicttcollectionstOrderedDicttsortedt iteritemstlistRttuple(ttopR.((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyR‘ss ( LPAR ) RPAR [ LSQB ] RSQB : COLON , COMMA ; SEMI + PLUS - MINUS * STAR / SLASH | VBAR & AMPER < LESS > GREATER = EQUAL . DOT % PERCENT ` BACKQUOTE { LBRACE } RBRACE @ AT @= ATEQUAL == EQEQUAL != NOTEQUAL <> NOTEQUAL <= LESSEQUAL >= GREATEREQUAL ~ TILDE ^ CIRCUMFLEX << LEFTSHIFT >> RIGHTSHIFT ** DOUBLESTAR += PLUSEQUAL -= MINEQUAL *= STAREQUAL /= SLASHEQUAL %= PERCENTEQUAL &= AMPEREQUAL |= VBAREQUAL ^= CIRCUMFLEXEQUAL <<= LEFTSHIFTEQUAL >>= RIGHTSHIFTEQUAL **= DOUBLESTAREQUAL // DOUBLESLASH //= DOUBLESLASHEQUAL -> RARROW (R*R1RtRRtobjectRRt opmap_rawtopmapt splitlinestlinetsplittoptnameR (((s-/usr/lib64/python2.7/lib2to3/pgen2/grammar.pyt sz =PKw4]fwc}}conv.pyonu„[µü¤ó {fc@sEdZddlZddlmZmZdejfd„ƒYZdS(sýConvert graminit.[ch] spit out by pgen to Python code. Pgen is the Python parser generator. It is useful to quickly create a parser from a grammar file in Python's grammar notation. But I don't want my parsers to be written in C (yet), so I'm translating the parsing tables to Python data structures and writing a Python parse engine. Note that the token numbers are constants determined by the standard Python tokenizer. The standard token module defines these numbers and their names (the names are not used much). The token numbers are hardcoded into the Python tokenizer and into pgen. A Python implementation of the Python tokenizer is also available, in the standard tokenize module. On the other hand, symbol numbers (representing the grammar's non-terminals) are assigned by pgen based on the actual grammar input. Note: this module is pretty much obsolete; the pgen module generates equivalent grammar tables directly from the Grammar.txt input file without having to invoke the Python pgen C program. iÿÿÿÿN(tgrammarttokent ConvertercBs2eZdZd„Zd„Zd„Zd„ZRS(s2Grammar subclass that reads classic pgen output files. The run() method reads the tables as produced by the pgen parser generator, typically contained in two C files, graminit.h and graminit.c. The other methods are for internal use only. See the base class for more documentation. cCs(|j|ƒ|j|ƒ|jƒdS(s<Load the grammar tables from the text files written by pgen.N(tparse_graminit_htparse_graminit_ct finish_off(tselft graminit_ht graminit_c((s*/usr/lib64/python2.7/lib2to3/pgen2/conv.pytrun/s c Csåyt|ƒ}Wn#tk r5}d||fGHtSXi|_i|_d}x|D]ˆ}|d7}tjd|ƒ}|r¥|jƒr¥d|||jƒfGHqU|jƒ\}}t |ƒ}||j|<||j|@r²d||d|_[] = { {, }, ... }; - followed by a state array, of the form: static state states_[] = { {, arcs__}, ... }; sCan't open %s: %siisstatic arc s)static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$s\s+{(\d+), (\d+)},$s'static state states_(\d+)\[(\d+)\] = {$s\s+{(\d+), arcs_(\d+)_(\d+)},$sstatic dfa dfas\[(\d+)\] = {$s0\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$iiiis\s+("(?:\\\d\d\d)*")},$is!static label labels\[(\d+)\] = {$s\s+{(\d+), (0|"\w+")},$t0s \s+(\d+),$s\s+{(\d+), labels},$s \s+(\d+)$N(R RRtnextt startswithRRtmapRRtrangetappendtstatestgrouptevalt enumeratetordtdfastNonetlabelststartt StopIteration(!RRRRRRtallarcsR#Rtntmtktarcst_titjtstttstateR(tndfasRRtxtytztfirstt rawbitsettctbyteR*tnlabelsR+((s*/usr/lib64/python2.7/lib2to3/pgen2/conv.pyRTsº - cCsƒi|_i|_xjt|jƒD]Y\}\}}|tjkr_|dk r_||j|sPKw4] ÿââliterals.pycnu„[µü¤ó {fc@s“dZddlZi dd6dd6dd6d d 6dd6d d6dd6dd6dd6dd6Zd„Zd„Zd„ZedkreƒndS(s<Safely evaluate Python string literals without using eval().iÿÿÿÿNstastbstfs tns trs ttstvt't"s\cCs|jddƒ\}}|jdƒs-t‚tj|ƒ}|dk rL|S|jdƒrÄ|d}t|ƒdkrŠtd|ƒ‚nyt|dƒ}Wqûtk rÀtd|ƒ‚qûXn7yt|dƒ}Wn!tk rútd |ƒ‚nXt |ƒS( Niis\txis!invalid hex string escape ('\%s')iis#invalid octal string escape ('\%s')( tgroupt startswithtAssertionErrortsimple_escapestgettNonetlent ValueErrortinttchr(tmtallttailtescthexesti((s./usr/lib64/python2.7/lib2to3/pgen2/literals.pytescapes$ cCsÚ|jdƒs4|jdƒs4tt|d ƒƒ‚|d}|d |dkr_|d}n|j|ƒs‹tt|t|ƒƒƒ‚t|ƒdt|ƒkst‚|t|ƒt|ƒ!}tjdt|ƒS(NRRiiiis)\\(\'|\"|\\|[abfnrtv]|x.{0,2}|[0-7]{1,3})(RRtreprtendswithRtretsubR(tstq((s./usr/lib64/python2.7/lib2to3/pgen2/literals.pyt evalString(s4 ,"cCs_xXtdƒD]J}t|ƒ}t|ƒ}t|ƒ}||kr |G|G|G|GHq q WdS(Ni(trangeRRR!(RtcRte((s./usr/lib64/python2.7/lib2to3/pgen2/literals.pyttest2st__main__(t__doc__RR RR!R%t__name__(((s./usr/lib64/python2.7/lib2to3/pgen2/literals.pyts PKw4]ÝÑ„• driver.pyonu„[µü¤ó {fc@sdZdZddgZddlZddlZddlZddlZddlZddlZddl m Z mZmZm Z mZdefd„ƒYZd „Zd deedd„Zd„Zd „Zd„ZedkrejeeƒƒƒndS(sZParser driver. This provides a high-level interface to parse a file into a syntax tree. s#Guido van Rossum tDrivertload_grammariÿÿÿÿNi(tgrammartparsettokenttokenizetpgencBsVeZddd„Zed„Zed„Zed„Zded„Zed„Z RS(cCs:||_|dkr$tjƒ}n||_||_dS(N(RtNonetloggingt getLoggertloggertconvert(tselfRRR ((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyt__init__ s cCstj|j|jƒ}|jƒd}d}d }}}} } d}x¿|D]™}|\}}}} } |||fkrà|\} }|| kr·|d| |7}| }d}n||krà|| ||!7}|}qàn|tjtjfkr6||7}| \}}|j dƒrQ|d7}d}qQqQn|t jkrUtj|}n|r~|j jdt j|||ƒn|j||||fƒr¶|r²|j jdƒnPnd}| \}}|j dƒrQ|d7}d}qQqQWtjd||||fƒ‚|jS( s4Parse a series of tokens and return the syntax tree.iius s%s %r (prefix=%r)sStop.tsincomplete inputN(RtParserRRtsetupRRtCOMMENTtNLtendswithRtOPtopmapR tdebugttok_nametaddtokent ParseErrortrootnode(RttokensRtptlinenotcolumnttypetvaluetstarttendt line_texttprefixt quintuplets_linenots_column((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pytparse_tokens'sR cCs"tj|jƒ}|j||ƒS(s*Parse a stream and return the syntax tree.(Rtgenerate_tokenstreadlineR((RtstreamRR((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pytparse_stream_rawWscCs|j||ƒS(s*Parse a stream and return the syntax tree.(R,(RR+R((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pytparse_stream\scCs;tj|d|ƒ}z|j||ƒSWd|jƒXdS(s(Parse a file and return the syntax tree.trN(tcodecstopenR-tclose(RtfilenametencodingRR+((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyt parse_file`scCs+tjtj|ƒjƒ}|j||ƒS(s*Parse a string and return the syntax tree.(RR)tStringIOR*R((RttextRR((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pytparse_stringhsN( t__name__t __module__RR tFalseR(R,R-R4R7(((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyRs0cCsRtjj|ƒ\}}|dkr-d}n||djtttjƒƒdS(Ns.txtRt.s.pickle(tostpathtsplitexttjointmaptstrtsystversion_info(tgttheadttail((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyt_generate_pickle_namens sGrammar.txtcCsÞ|dkrtjƒ}n|dkr3t|ƒn|}|sOt||ƒrÁ|jd|ƒtj|ƒ}|rÚ|jd|ƒy|j|ƒWq¾t k rº}|jd|ƒq¾XqÚnt jƒ}|j|ƒ|S(s'Load the grammar (maybe from a pickle).s!Generating grammar tables from %ssWriting grammar tables to %ssWriting failed: %sN( RRR RGt_newertinfoRtgenerate_grammartdumptIOErrorRtGrammartload(RDtgptsavetforceR tgte((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyRus cCsNtjj|ƒstStjj|ƒs,tStjj|ƒtjj|ƒkS(s0Inquire whether file a was written since file b.(R<R=texistsR:tTruetgetmtime(tatb((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyRHŠs cCsctjj|ƒrt|ƒSttjj|ƒƒ}tj||ƒ}tj ƒ}|j |ƒ|S(sÙNormally, loads a pickled grammar by doing pkgutil.get_data(package, pickled_grammar) where *pickled_grammar* is computed from *grammar_source* by adding the Python version and using a ``.pickle`` extension. However, if *grammar_source* is an extant file, load_grammar(grammar_source) is called instead. This facilitates using a packaged grammar file when needed but preserves load_grammar's automatic regeneration behavior when possible. (R<R=tisfileRRGtbasenametpkgutiltget_dataRRMtloads(tpackagetgrammar_sourcetpickled_nametdataRR((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pytload_packaged_grammar“s cGsc|stjd}ntjdtjdtjddƒx$|D]}t|dtdtƒq?WtS(sMain program, when run as a script: produce grammar pickle files. Calls load_grammar for each argument, a path to a grammar text file. itlevelR+tformats%(message)sRPRQ(RBtargvRtbasicConfigtINFOtstdoutRRU(targsRD((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pytmain§s t__main__(t__doc__t __author__t__all__R/R<RR[R5RBRRRRRRtobjectRRGRRUR:RRHRbRjR8texittint(((s,/usr/lib64/python2.7/lib2to3/pgen2/driver.pyts$(P PKw4]>ÜF‹òAòAtokenize.pyonu„[µü¤ó {fc@sdZdZdZddlZddlZddlmZmZddlTddl m Z gee ƒD]Zed d krge^qgddd gZ [ yeWnek rºeZnXd„Zd„Zd„ZdZdZeedeƒeeƒZdZdZdZdZdZeeeeeƒZdZeddƒeeƒZdeZeeeƒZ ede dƒZ!ee!e eƒZ"dZ#d Z$d!Z%d"Z&ed#d$ƒZ'ed%d&ƒZ(ed'd(d)d*d+d,d-d.d/ƒ Z)d0Z*ed1d2ƒZ+ee)e*e+ƒZ,ee"e,e(eƒZ-ee-Z.ed3ed4dƒd5ed6dƒƒZ/edee'ƒZ0eee0e"e,e/eƒZ1e2ej3e.e1e%e&fƒ\Z4Z5Z6Z7i&ej3e#ƒd46ej3e$ƒd66e6d76e7d86e6d96e7d:6e6d;6e7d<6e6d=6e7d>6e6d?6e7d@6e6dA6e7dB6e6dC6e7dD6e6dE6e7dF6e6dG6e7dH6e6dI6e7dJ6e6dK6e7dL6e6dM6e7dN6e6dO6e7dP6e6dQ6e7dR6e6dS6e7dT6ddU6ddV6ddW6ddX6ddY6ddZ6Z9iZ:xdˆD]Z;e;e:e;fdy„ƒYZ?dze>fd{„ƒYZ@d|„ZAeAd}„ZBd~„ZCddŠd€„ƒYZDej3dƒZEej3d‚ƒZFdƒ„ZGd„„ZHd…„ZId†„ZJeKd‡krddlLZLeMeLjNƒdkreBeOeLjNdƒjPƒqeBeLjQjPƒndS(‹sÀTokenization help for Python programs. generate_tokens(readline) is a generator that breaks a stream of text into Python tokens. It accepts a readline-like method which is called repeatedly to get the next line of input (or "" for EOF). It generates 5-tuples with these members: the token type (see token.py) the token (a string) the starting (row, column) indices of the token (a 2-tuple of ints) the ending (row, column) indices of the token (a 2-tuple of ints) the original line (string) It is designed to match the working of the Python tokenizer exactly, except that it produces COMMENT tokens for comments and gives type OP for all operators Older entry points tokenize_loop(readline, tokeneater) tokenize(readline, tokeneater=printtoken) are the same, except instead of generating tokens, tokeneater is a callback function to which the 5 fields described above are passed as 5 arguments, each time a new token is found.sKa-Ping Yee s@GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, Skip MontanaroiÿÿÿÿN(tBOM_UTF8tlookup(t*i(ttokenit_ttokenizetgenerate_tokenst untokenizecGsddj|ƒdS(Nt(t|t)(tjoin(tchoices((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytgroup0tcGst|ŒdS(NR(R (R((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytany1RcGst|ŒdS(Nt?(R (R((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytmaybe2Rs[ \f\t]*s #[^\r\n]*s\\\r?\ns[a-zA-Z_]\w*s 0[bB][01]*s0[xX][\da-fA-F]*[lL]?s0[oO]?[0-7]*[lL]?s [1-9]\d*[lL]?s[eE][-+]?\d+s\d+\.\d*s\.\d+s\d+s\d+[jJ]s[jJ]s[^'\\]*(?:\\.[^'\\]*)*'s[^"\\]*(?:\\.[^"\\]*)*"s%[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''s%[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""s[ubUB]?[rR]?'''s[ubUB]?[rR]?"""s&[uU]?[rR]?'[^\n'\\]*(?:\\.[^\n'\\]*)*'s&[uU]?[rR]?"[^\n"\\]*(?:\\.[^\n"\\]*)*"s\*\*=?s>>=?s<<=?s<>s!=s//=?s->s[+\-*/%&@|^=<>]=?t~s[][(){}]s\r?\ns[:;.,`@]s'[uUbB]?[rR]?'[^\n'\\]*(?:\\.[^\n'\\]*)*t's'[uUbB]?[rR]?"[^\n"\\]*(?:\\.[^\n"\\]*)*t"s'''s"""sr'''sr"""su'''su"""sb'''sb"""sur'''sur"""sbr'''sbr"""sR'''sR"""sU'''sU"""sB'''sB"""suR'''suR"""sUr'''sUr"""sUR'''sUR"""sbR'''sbR"""sBr'''sBr"""sBR'''sBR"""trtRtutUtbtBsr'sr"sR'sR"su'su"sU'sU"sb'sb"sB'sB"sur'sur"sUr'sUr"suR'suR"sUR'sUR"sbr'sbr"sBr'sBr"sbR'sbR"sBR'sBR"it TokenErrorcBseZRS((t__name__t __module__(((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR–stStopTokenizingcBseZRS((RR(((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR˜sc CsA|\}}|\}}d||||t|t|ƒfGHdS(Ns%d,%d-%d,%d: %s %s(ttok_nametrepr( ttypeRtstarttendtlinetsrowtscolterowtecol((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyt printtokenšscCs)yt||ƒWntk r$nXdS(s: The tokenize() function accepts two parameters: one representing the input stream, and one providing an output mechanism for tokenize(). The first parameter, readline, must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. The second parameter, tokeneater, must also be a callable object. It is called once for each token, with five arguments, corresponding to the tuples generated by generate_tokens(). N(t tokenize_loopR(treadlinet tokeneater((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR s cCs%xt|ƒD]}||Œq WdS(N(R(R+R,t token_info((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR*³stUntokenizercBs,eZd„Zd„Zd„Zd„ZRS(cCsg|_d|_d|_dS(Nii(ttokenstprev_rowtprev_col(tself((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyt__init__¹s cCs:|\}}||j}|r6|jjd|ƒndS(Nt (R1R/tappend(R2R"trowtcolt col_offset((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytadd_whitespace¾s cCs¸x¥|D]}t|ƒdkr3|j||ƒPn|\}}}}}|j|ƒ|jj|ƒ|\|_|_|ttfkr|jd7_d|_qqWdj |jƒS(NiiiR( tlentcompatR9R/R5R0R1tNEWLINEtNLR(R2titerablettttok_typeRR"R#R$((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyRÅs c Cs%t}g}|jj}|\}}|ttfkrC|d7}n|ttfkr^t}nxÀ|D]¸}|d \}}|ttfkrš|d7}n|tkr¹|j|ƒqenZ|t krÕ|j ƒqen>|ttfkrðt}n#|r|r||dƒt}n||ƒqeWdS(NR4iiÿÿÿÿ(tFalseR/R5tNAMEtNUMBERR<R=tTruetINDENTtDEDENTtpop( R2RR>t startlinetindentsttoks_appendttoknumttokvalttok((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR;Ós0 (RRR3R9RR;(((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR.·s s&^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)s^[ \t\f]*(?:[#\r\n]|$)cCs^|d jƒjddƒ}|dks7|jdƒr;dS|dksV|jd ƒrZdS|S(s(Imitates get_normal_name in tokenizer.c.iRt-sutf-8sutf-8-slatin-1s iso-8859-1siso-latin-1slatin-1-siso-8859-1-siso-latin-1-(slatin-1s iso-8859-1siso-latin-1(slatin-1-siso-8859-1-siso-latin-1-(tlowertreplacet startswith(torig_enctenc((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyt_get_normal_nameòscsút‰d}d}‡fd†}‡fd†}|ƒ}|jtƒrat‰|d}d}n|sq|gfS||ƒ}|r||gfStj|ƒs¬||gfS|ƒ}|sÈ||gfS||ƒ}|rê|||gfS|||gfS(s The detect_encoding() function is used to detect the encoding that should be used to decode a Python source file. It requires one argument, readline, in the same way as the tokenize() generator. It will call readline a maximum of twice, and return the encoding used (as a string) and a list of any lines (left as bytes) it has read in. It detects the encoding from the presence of a utf-8 bom or an encoding cookie as specified in pep-0263. If both a bom and a cookie are present, but disagree, a SyntaxError will be raised. If the encoding cookie is an invalid charset, raise a SyntaxError. Note that if a utf-8 bom is found, 'utf-8-sig' is returned. If no encoding is specified, then the default of 'utf-8' will be returned. sutf-8cs'yˆƒSWntk r"tƒSXdS(N(t StopIterationtbytes((R+(s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytread_or_stops cs¿y|jdƒ}Wntk r'dSXtj|ƒ}|sAdSt|jdƒƒ}yt|ƒ}Wn!tk r‰t d|ƒ‚nXˆr»|j dkr®t dƒ‚n|d7}n|S(Ntasciiisunknown encoding: sutf-8sencoding problem: utf-8s-sig(tdecodetUnicodeDecodeErrortNonet cookie_retmatchRTR RtLookupErrortSyntaxErrortname(R$tline_stringR]tencodingtcodec(t bom_found(s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytfind_cookies" is utf-8-sigN(RAR[RQRRDtblank_reR](R+RbtdefaultRWRetfirsttsecond((RdR+s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytdetect_encodingýs0 cCstƒ}|j|ƒS(s¬Transform tokens back into Python source code. Each element returned by the iterable must be a token sequence with at least two elements, a token number and token value. If only two tokens are passed, the resulting output is poor. Round-trip invariant for full input: Untokenized source will match input source exactly Round-trip invariant for limited intput: # Output text will tokenize the back to the input t1 = [tok[:2] for tok in generate_tokens(f.readline)] newcode = untokenize(t1) readline = iter(newcode.splitlines(1)).next t2 = [tok[:2] for tokin generate_tokens(readline)] assert t1 == t2 (R.R(R>tut((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyRFs ccs@d}}}tjdd}}d\}}d}dg} x§y |ƒ} Wntk rfd} nX|d}dt| ƒ}}|r{| s¢td| f‚n|j| ƒ}|r|jdƒ}}t|| | | ||f|| fVd\}}d}qÛ|ra| ddkra| d d krat || | |t| ƒf|fVd}d}q@qÛ|| }|| }q@n`|dkr·|r·| s˜Pnd}xv||kr| |dkrÊ|d}n?| |dkrï|t dt }n| |d krd}nP|d}q¡W||kr'Pn| |dkr| |dkrÁ| |jdƒ}|t|ƒ}t|||f||t|ƒf| fVt | |||f|t| ƒf| fVq@t tf| |dk| |||f|t| ƒf| fVq@n|| dkrI| j|ƒt| | |df||f| fVnx|| dkr³|| kr†tdd||| fƒ‚n| d } td||f||f| fVqLWn$| sÕtd|dff‚nd}x||krâtj| |ƒ}|r|jdƒ\}}||f||f|}}}| ||!| |}}||kss|dkrŠ|dkrŠt|||| fVqß|dkrÈt}|dkr±t }n||||| fVqß|dkrët|||| fVqß|tkrrt|}|j| |ƒ}|rR|jdƒ}| ||!}t||||f| fVqª||f} | |}| }Pqß|tksž|d tksž|d tkr|ddkrû||f} t|pÝt|dpÝt|d}| |d}}| }Pqªt|||| fVqß||kr5t|||| fVqß|dkrdt ||||f| fVd}qß|dkr}|d}n|dkr–|d}nt|||| fVqÞt | |||f||df| fV|d}qÞWq@Wx2| dD]&}td|df|dfdfVqòWtd|df|dfdfVdS(sT The generate_tokens() generator requires one argument, readline, which must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. Alternately, readline can be a callable function terminating with StopIteration: readline = open(myfile).next # Example of alternate readline The generator produces 5-tuples with these members: the token type; the token string; a 2-tuple (srow, scol) of ints specifying the row and column where the token begins in the source; a 2-tuple (erow, ecol) of ints specifying the row and column where the token ends in the source; and the line on which the token was found. The line passed is the logical line; continuation lines are included. iRt 0123456789RisEOF in multi-line stringiþÿÿÿs\ iýÿÿÿs\ R4s ss# t#s iÿÿÿÿs3unindent does not match any outer indentation levels sEOF in multi-line statementt.iis s\s([{s)]}N(Ri(Ri(tstringt ascii_lettersR[RUR:RR]R#tSTRINGt ERRORTOKENttabsizetrstriptCOMMENTR=R5REtIndentationErrorRFt pseudoprogtspanRCR<t triple_quotedtendprogst single_quotedRBtOPt ENDMARKER(R+tlnumtparenlevt continuedt namecharstnumcharstcontstrtneedconttcontlineRIR$tpostmaxtstrstarttendprogtendmatchR#tcolumnt comment_tokentnl_postpseudomatchR"tsposteposRtinitialtnewlinetindent((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR[sø & $ # ' ' $t__main__(s'''s"""sr'''sr"""sR'''sR"""su'''su"""sU'''sU"""sb'''sb"""sB'''sB"""sur'''sur"""sUr'''sUr"""suR'''suR"""sUR'''sUR"""sbr'''sbr"""sBr'''sBr"""sbR'''sbR"""sBR'''sBR"""(RRsr'sr"sR'sR"su'su"sU'sU"sb'sb"sB'sB"sur'sur"sUr'sUr"suR'suR"sUR'sUR"sbr'sbr"sBr'sBr"sbR'sbR"sBR'sBR"((Rt__doc__t __author__t__credits__RotretcodecsRRtlib2to3.pgen2.tokenRRtdirtxt__all__RVt NameErrortstrR RRt WhitespacetCommenttIgnoretNamet Binnumbert Hexnumbert Octnumbert Decnumbert IntnumbertExponentt PointfloattExpfloattFloatnumbert ImagnumbertNumbertSingletDoubletSingle3tDouble3tTripletStringtOperatortBrackettSpecialtFunnyt PlainTokentTokentContStrtPseudoExtrastPseudoTokentmaptcompilet tokenprogRwtsingle3progtdouble3progR[RzRyR?R{Rst ExceptionRRR)RR*R.R\RfRTRjRRRtsysR:targvtopenR+tstdin(((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytsà / '# 8 I ˜PKw4]fÌuôKBKBtokenize.pycnu„[µü¤ó {fc@sdZdZdZddlZddlZddlmZmZddlTddl m Z gee ƒD]Zed d krge^qgddd gZ [ yeWnek rºeZnXd„Zd„Zd„ZdZdZeedeƒeeƒZdZdZdZdZdZeeeeeƒZdZeddƒeeƒZdeZeeeƒZ ede dƒZ!ee!e eƒZ"dZ#d Z$d!Z%d"Z&ed#d$ƒZ'ed%d&ƒZ(ed'd(d)d*d+d,d-d.d/ƒ Z)d0Z*ed1d2ƒZ+ee)e*e+ƒZ,ee"e,e(eƒZ-ee-Z.ed3ed4dƒd5ed6dƒƒZ/edee'ƒZ0eee0e"e,e/eƒZ1e2ej3e.e1e%e&fƒ\Z4Z5Z6Z7i&ej3e#ƒd46ej3e$ƒd66e6d76e7d86e6d96e7d:6e6d;6e7d<6e6d=6e7d>6e6d?6e7d@6e6dA6e7dB6e6dC6e7dD6e6dE6e7dF6e6dG6e7dH6e6dI6e7dJ6e6dK6e7dL6e6dM6e7dN6e6dO6e7dP6e6dQ6e7dR6e6dS6e7dT6ddU6ddV6ddW6ddX6ddY6ddZ6Z9iZ:xdˆD]Z;e;e:e;fdy„ƒYZ?dze>fd{„ƒYZ@d|„ZAeAd}„ZBd~„ZCddŠd€„ƒYZDej3dƒZEej3d‚ƒZFdƒ„ZGd„„ZHd…„ZId†„ZJeKd‡krddlLZLeMeLjNƒdkreBeOeLjNdƒjPƒqeBeLjQjPƒndS(‹sÀTokenization help for Python programs. generate_tokens(readline) is a generator that breaks a stream of text into Python tokens. It accepts a readline-like method which is called repeatedly to get the next line of input (or "" for EOF). It generates 5-tuples with these members: the token type (see token.py) the token (a string) the starting (row, column) indices of the token (a 2-tuple of ints) the ending (row, column) indices of the token (a 2-tuple of ints) the original line (string) It is designed to match the working of the Python tokenizer exactly, except that it produces COMMENT tokens for comments and gives type OP for all operators Older entry points tokenize_loop(readline, tokeneater) tokenize(readline, tokeneater=printtoken) are the same, except instead of generating tokens, tokeneater is a callback function to which the 5 fields described above are passed as 5 arguments, each time a new token is found.sKa-Ping Yee s@GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, Skip MontanaroiÿÿÿÿN(tBOM_UTF8tlookup(t*i(ttokenit_ttokenizetgenerate_tokenst untokenizecGsddj|ƒdS(Nt(t|t)(tjoin(tchoices((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytgroup0tcGst|ŒdS(NR(R (R((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytany1RcGst|ŒdS(Nt?(R (R((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytmaybe2Rs[ \f\t]*s #[^\r\n]*s\\\r?\ns[a-zA-Z_]\w*s 0[bB][01]*s0[xX][\da-fA-F]*[lL]?s0[oO]?[0-7]*[lL]?s [1-9]\d*[lL]?s[eE][-+]?\d+s\d+\.\d*s\.\d+s\d+s\d+[jJ]s[jJ]s[^'\\]*(?:\\.[^'\\]*)*'s[^"\\]*(?:\\.[^"\\]*)*"s%[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''s%[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""s[ubUB]?[rR]?'''s[ubUB]?[rR]?"""s&[uU]?[rR]?'[^\n'\\]*(?:\\.[^\n'\\]*)*'s&[uU]?[rR]?"[^\n"\\]*(?:\\.[^\n"\\]*)*"s\*\*=?s>>=?s<<=?s<>s!=s//=?s->s[+\-*/%&@|^=<>]=?t~s[][(){}]s\r?\ns[:;.,`@]s'[uUbB]?[rR]?'[^\n'\\]*(?:\\.[^\n'\\]*)*t's'[uUbB]?[rR]?"[^\n"\\]*(?:\\.[^\n"\\]*)*t"s'''s"""sr'''sr"""su'''su"""sb'''sb"""sur'''sur"""sbr'''sbr"""sR'''sR"""sU'''sU"""sB'''sB"""suR'''suR"""sUr'''sUr"""sUR'''sUR"""sbR'''sbR"""sBr'''sBr"""sBR'''sBR"""trtRtutUtbtBsr'sr"sR'sR"su'su"sU'sU"sb'sb"sB'sB"sur'sur"sUr'sUr"suR'suR"sUR'sUR"sbr'sbr"sBr'sBr"sbR'sbR"sBR'sBR"it TokenErrorcBseZRS((t__name__t __module__(((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR–stStopTokenizingcBseZRS((RR(((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR˜sc CsA|\}}|\}}d||||t|t|ƒfGHdS(Ns%d,%d-%d,%d: %s %s(ttok_nametrepr( ttypeRtstarttendtlinetsrowtscolterowtecol((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyt printtokenšscCs)yt||ƒWntk r$nXdS(s: The tokenize() function accepts two parameters: one representing the input stream, and one providing an output mechanism for tokenize(). The first parameter, readline, must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. The second parameter, tokeneater, must also be a callable object. It is called once for each token, with five arguments, corresponding to the tuples generated by generate_tokens(). N(t tokenize_loopR(treadlinet tokeneater((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR s cCs%xt|ƒD]}||Œq WdS(N(R(R+R,t token_info((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR*³stUntokenizercBs,eZd„Zd„Zd„Zd„ZRS(cCsg|_d|_d|_dS(Nii(ttokenstprev_rowtprev_col(tself((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyt__init__¹s cCsO|\}}||jks!t‚||j}|rK|jjd|ƒndS(Nt (R0tAssertionErrorR1R/tappend(R2R"trowtcolt col_offset((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytadd_whitespace¾s cCs¸x¥|D]}t|ƒdkr3|j||ƒPn|\}}}}}|j|ƒ|jj|ƒ|\|_|_|ttfkr|jd7_d|_qqWdj |jƒS(NiiiR( tlentcompatR:R/R6R0R1tNEWLINEtNLR(R2titerablettttok_typeRR"R#R$((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyRÅs c Cs%t}g}|jj}|\}}|ttfkrC|d7}n|ttfkr^t}nxÀ|D]¸}|d \}}|ttfkrš|d7}n|tkr¹|j|ƒqenZ|t krÕ|j ƒqen>|ttfkrðt}n#|r|r||dƒt}n||ƒqeWdS(NR4iiÿÿÿÿ(tFalseR/R6tNAMEtNUMBERR=R>tTruetINDENTtDEDENTtpop( R2RR?t startlinetindentsttoks_appendttoknumttokvalttok((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR<Ós0 (RRR3R:RR<(((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR.·s s&^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)s^[ \t\f]*(?:[#\r\n]|$)cCs^|d jƒjddƒ}|dks7|jdƒr;dS|dksV|jd ƒrZdS|S(s(Imitates get_normal_name in tokenizer.c.iRt-sutf-8sutf-8-slatin-1s iso-8859-1siso-latin-1slatin-1-siso-8859-1-siso-latin-1-(slatin-1s iso-8859-1siso-latin-1(slatin-1-siso-8859-1-siso-latin-1-(tlowertreplacet startswith(torig_enctenc((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyt_get_normal_nameòscsút‰d}d}‡fd†}‡fd†}|ƒ}|jtƒrat‰|d}d}n|sq|gfS||ƒ}|r||gfStj|ƒs¬||gfS|ƒ}|sÈ||gfS||ƒ}|rê|||gfS|||gfS(s The detect_encoding() function is used to detect the encoding that should be used to decode a Python source file. It requires one argument, readline, in the same way as the tokenize() generator. It will call readline a maximum of twice, and return the encoding used (as a string) and a list of any lines (left as bytes) it has read in. It detects the encoding from the presence of a utf-8 bom or an encoding cookie as specified in pep-0263. If both a bom and a cookie are present, but disagree, a SyntaxError will be raised. If the encoding cookie is an invalid charset, raise a SyntaxError. Note that if a utf-8 bom is found, 'utf-8-sig' is returned. If no encoding is specified, then the default of 'utf-8' will be returned. sutf-8cs'yˆƒSWntk r"tƒSXdS(N(t StopIterationtbytes((R+(s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytread_or_stops cs¿y|jdƒ}Wntk r'dSXtj|ƒ}|sAdSt|jdƒƒ}yt|ƒ}Wn!tk r‰t d|ƒ‚nXˆr»|j dkr®t dƒ‚n|d7}n|S(Ntasciiisunknown encoding: sutf-8sencoding problem: utf-8s-sig(tdecodetUnicodeDecodeErrortNonet cookie_retmatchRUR RtLookupErrortSyntaxErrortname(R$tline_stringR^tencodingtcodec(t bom_found(s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytfind_cookies" is utf-8-sigN(RBR\RRRREtblank_reR^(R+RctdefaultRXRftfirsttsecond((ReR+s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytdetect_encodingýs0 cCstƒ}|j|ƒS(s¬Transform tokens back into Python source code. Each element returned by the iterable must be a token sequence with at least two elements, a token number and token value. If only two tokens are passed, the resulting output is poor. Round-trip invariant for full input: Untokenized source will match input source exactly Round-trip invariant for limited intput: # Output text will tokenize the back to the input t1 = [tok[:2] for tok in generate_tokens(f.readline)] newcode = untokenize(t1) readline = iter(newcode.splitlines(1)).next t2 = [tok[:2] for tokin generate_tokens(readline)] assert t1 == t2 (R.R(R?tut((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyRFs ccsVd}}}tjdd}}d\}}d}dg} x½y |ƒ} Wntk rfd} nX|d}dt| ƒ}}|r{| s¢td| f‚n|j| ƒ}|r|jdƒ}}t|| | | ||f|| fVd\}}d}qÛ|ra| ddkra| d d krat || | |t| ƒf|fVd}d}q@qÛ|| }|| }q@n`|dkr·|r·| s˜Pnd}xv||kr| |dkrÊ|d}n?| |dkrï|t dt }n| |d krd}nP|d}q¡W||kr'Pn| |dkr| |dkrÁ| |jdƒ}|t|ƒ}t|||f||t|ƒf| fVt | |||f|t| ƒf| fVq@t tf| |dk| |||f|t| ƒf| fVq@n|| dkrI| j|ƒt| | |df||f| fVnx|| dkr³|| kr†tdd||| fƒ‚n| d } td||f||f| fVqLWn$| sÕtd|dff‚nd}x||krøtj| |ƒ}|rÃ|jdƒ\}}||f||f|}}}| ||!| |}}||kss|dkrŠ|dkrŠt|||| fVqõ|dkrÈt}|dkr±t }n||||| fVqõ|dkr|jdƒsêt‚t|||| fVqõ|tkrˆt|}|j| |ƒ}|rh|jdƒ}| ||!}t||||f| fVqÀ||f} | |}| }Pqõ|tks´|d tks´|d tkr(|ddkr||f} t|pót|dpót|d}| |d}}| }PqÀt|||| fVqõ||krKt|||| fVqõ|dkrzt ||||f| fVd}qõ|dkr“|d}n|dkr¬|d}nt|||| fVqÞt | |||f||df| fV|d}qÞWq@Wx2| dD]&}td|df|dfdfVqWtd|df|dfdfVdS(sT The generate_tokens() generator requires one argument, readline, which must be a callable object which provides the same interface as the readline() method of built-in file objects. Each call to the function should return one line of input as a string. Alternately, readline can be a callable function terminating with StopIteration: readline = open(myfile).next # Example of alternate readline The generator produces 5-tuples with these members: the token type; the token string; a 2-tuple (srow, scol) of ints specifying the row and column where the token begins in the source; a 2-tuple (erow, ecol) of ints specifying the row and column where the token ends in the source; and the line on which the token was found. The line passed is the logical line; continuation lines are included. iRt 0123456789RisEOF in multi-line stringiþÿÿÿs\ iýÿÿÿs\ R4s ss# t#s iÿÿÿÿs3unindent does not match any outer indentation levels sEOF in multi-line statementt.s iis\s([{s)]}N(Ri(Ri(tstringt ascii_lettersR\RVR;RR^R#tSTRINGt ERRORTOKENttabsizetrstriptCOMMENTR>R6RFtIndentationErrorRGt pseudoprogtspanRDR=tendswithR5t triple_quotedtendprogst single_quotedRCtOPt ENDMARKER(R+tlnumtparenlevt continuedt namecharstnumcharstcontstrtneedconttcontlineRJR$tpostmaxtstrstarttendprogtendmatchR#tcolumnt comment_tokentnl_postpseudomatchR"tsposteposRtinitialtnewlinetindent((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pyR[sú & $ # ' ' $t__main__(s'''s"""sr'''sr"""sR'''sR"""su'''su"""sU'''sU"""sb'''sb"""sB'''sB"""sur'''sur"""sUr'''sUr"""suR'''suR"""sUR'''sUR"""sbr'''sbr"""sBr'''sBr"""sbR'''sbR"""sBR'''sBR"""(RRsr'sr"sR'sR"su'su"sU'sU"sb'sb"sB'sB"sur'sur"sUr'sUr"suR'suR"sUR'sUR"sbr'sbr"sBr'sBr"sbR'sbR"sBR'sBR"((Rt__doc__t __author__t__credits__RptretcodecsRRtlib2to3.pgen2.tokenRRtdirtxt__all__RWt NameErrortstrR RRt WhitespacetCommenttIgnoretNamet Binnumbert Hexnumbert Octnumbert Decnumbert IntnumbertExponentt PointfloattExpfloattFloatnumbert ImagnumbertNumbertSingletDoubletSingle3tDouble3tTripletStringtOperatortBrackettSpecialtFunnyt PlainTokentTokentContStrtPseudoExtrastPseudoTokentmaptcompilet tokenprogRxtsingle3progtdouble3progR\R|R{R@R}Rtt ExceptionRRR)RR*R.R]RgRURkRRRtsysR;targvtopenR+tstdin(((s./usr/lib64/python2.7/lib2to3/pgen2/tokenize.pytsà / '# 8 I ˜PKb31]²íLDNNliterals.pynu„[µü¤PKb31]Ôä8BB)‰__pycache__/literals.cpython-36.opt-1.pycnu„[µü¤PKb31]¬ØE¹¹ $__pycache__/parse.cpython-36.pycnu„[µü¤PKb31]‘’æ‘‘(-%__pycache__/grammar.cpython-36.opt-1.pycnu„[µü¤PKb31]–!>”ØØ'A__pycache__/driver.cpython-36.opt-1.pycnu„[µü¤PKb31](âþŽŸŸ)EU__pycache__/__init__.cpython-36.opt-1.pycnu„[µü¤PKb31]‚ÏSã<<&=V__pycache__/token.cpython-36.opt-1.pycnu„[µü¤PKb31]÷*†u$u$%Ï]__pycache__/pgen.cpython-36.opt-1.pycnu„[µü¤PKb31]±.ÒÒ9&9&™‚__pycache__/pgen.cpython-36.pycnu„[µü¤PKb31]mSóÃÃ'!©__pycache__/driver.cpython-36.opt-2.pycnu„[µü¤PKb31]qMˆé««(;¹__pycache__/grammar.cpython-36.opt-2.pycnu„[µü¤PKb31]ú¬”PP%>Æ__pycache__/conv.cpython-36.opt-2.pycnu„[µü¤PKb31] úÉ&ãÔ__pycache__/parse.cpython-36.opt-2.pycnu„[µü¤PKb31]™§&w,w,)?á__pycache__/tokenize.cpython-36.opt-2.pycnu„[µü¤PKb31]¬v]—Ò;Ò;)__pycache__/tokenize.cpython-36.opt-1.pycnu„[µü¤PKb31]_íÏ¨ &:J__pycache__/token.cpython-36.opt-2.pycnu„[µü¤PKb31]‚ÏSã<< šQ__pycache__/token.cpython-36.pycnu„[µü¤PKb31]5³f››&&Y__pycache__/parse.cpython-36.opt-1.pycnu„[µü¤PKb31]žz“ƒƒ)r__pycache__/__init__.cpython-36.opt-2.pycnu„[µü¤PKb31]’1äÆþþ#ór__pycache__/literals.cpython-36.pycnu„[µü¤PKb31]÷*†u$u$%Dy__pycache__/pgen.cpython-36.opt-2.pycnu„[µü¤PKb31]¡6Ã!%ž__pycache__/conv.cpython-36.opt-1.pycnu„[µü¤PKb31]&Ã{õõ)g¶__pycache__/literals.cpython-36.opt-2.pycnu„[µü¤PKb31]ÆF¨xxµ»__pycache__/conv.cpython-36.pycnu„[µü¤PKb31]‘’æ‘‘"|×__pycache__/grammar.cpython-36.pycnu„[µü¤PKb31](âþŽŸŸ#_ó__pycache__/__init__.cpython-36.pycnu„[µü¤PKb31]É[-!Qô__pycache__/driver.cpython-36.pycnu„[µü¤PKb31]ÕpŽ<<#ª__pycache__/tokenize.cpython-36.pycnu„[µü¤PKb31]sWP›uuEparse.pynu„[µü¤PKb31]’˜œ"ÂÂ Ädgrammar.pynu„[µü¤PKb31]ý—Š›%›%À~conv.pynu„[µü¤PKb31]token.pynuÈ¯ÝíPKhP3]N æ3$îC__pycache__/literals.cpython-311.pycnu„[µü¤PKhP3]»Ñ’kJkJ&TP__pycache__/pgen.cpython-311.opt-1.pycnu„[µü¤PKhP3]ù\ç<ÑNÑN*›__pycache__/tokenize.cpython-311.opt-2.pycnu„[µü¤PKhP3]ªýF;` ` *@ê__pycache__/literals.cpython-311.opt-2.pycnu„[µü¤PKhP3]H;±Ë¨¨*úó__pycache__/__init__.cpython-311.opt-2.pycnu„[µü¤PKhP3].•íËÍ3Í3 üô__pycache__/conv.cpython-311.pycnu„[µü¤PKhP3]»Ñ’kJkJ&)__pycache__/pgen.cpython-311.opt-2.pycnu„[µü¤PKhP3]Â«Ðv"v""Ús__pycache__/driver.cpython-311.pycnu„[µü¤PKhP3] æZV#V#!¢–__pycache__/parse.cpython-311.pycnu„[µü¤PKhP3]Ìû:““#Iº__pycache__/grammar.cpython-311.pycnu„[µü¤PKhP3]qD Ð;#;#'/Ø__pycache__/parse.cpython-311.opt-1.pycnu„[µü¤PKhP3]’`K K !Áû__pycache__/token.cpython-311.pycnu„[µü¤PKhP3]‹c """"(]__pycache__/driver.cpython-311.opt-1.pycnu„[µü¤PKhP3]O=Gž¬ ¬ *×'__pycache__/literals.cpython-311.opt-1.pycnu„[µü¤PKhP3]’`K K 'Ý1__pycache__/token.cpython-311.opt-1.pycnu„[µü¤PKhP3]Ç8)(ÈÈ';__pycache__/parse.cpython-311.opt-2.pycnu„[µü¤PKhP3]@{¢?ë]ë]*žR__pycache__/tokenize.cpython-311.opt-1.pycnu„[µü¤PKhP3]³“õ[c^c^$ã°__pycache__/tokenize.cpython-311.pycnu„[µü¤PKhP3]OÍnll(š__pycache__/driver.cpython-311.opt-2.pycnu„[µü¤PKhP3]°Í£™E+E+&^.__pycache__/conv.cpython-311.opt-1.pycnu„[µü¤PKhP3]‰÷Ù©!©!&ùY__pycache__/conv.cpython-311.opt-2.pycnu„[µü¤PKhP3]°}+»ÌÌ$ø{__pycache__/__init__.cpython-311.pycnu„[µü¤PKhP3]áª '}__pycache__/token.cpython-311.opt-2.pycnu„[µü¤PKhP3]°}+»ÌÌ*‰†__pycache__/__init__.cpython-311.opt-1.pycnu„[µü¤PKhP3]Ìû:““)¯‡__pycache__/grammar.cpython-311.opt-1.pycnu„[µü¤PKhP3]u‘MU-O-O ›¥__pycache__/pgen.cpython-311.pycnu„[µü¤PKhP3]¾„ûX]])õ__pycache__/grammar.cpython-311.opt-2.pycnu„[µü¤PKw4]¤&ï*úúÎliterals.pyonu„[µü¤PKw4]qCÎ/Î/pgen.pycnu„[µü¤PKw4]C›Ëi-i- >pgen.pyonu„[µü¤PKw4]ãÿ?? «kdriver.pycnu„[µü¤PKw4]Íã(ÿÿ $…token.pyonu„[µü¤PKw4]Å‰ÃÓýý\Žconv.pycnu„[µü¤PKw4]ùKÅ%®®‘®__init__.pycnu„[µü¤PKw4]¼UØ{¯grammar.pycnu„[µü¤PKw4]A'He ºÍparse.pyonu„[µü¤PKw4]6çpæDD êparse.pycnu„[µü¤PKw4]ùKÅ%®®__init__.pyonu„[µü¤PKw4]Íã(ÿÿ wtoken.pycnu„[µü¤PKw4]¼UØ¯grammar.pyonu„[µü¤PKw4]fwc}}î.conv.pyonu„[µü¤PKw4] ÿââ£Jliterals.pycnu„[µü¤PKw4]ÝÑ„• ÁRdriver.pyonu„[µü¤PKw4]>ÜF‹òAòAûktokenize.pyonu„[µü¤PKw4]fÌuôKBKB)®tokenize.pycnu„[µü¤PKQQ7°ð