Module Expr Str Import alias Import alias ImportFrom alias alias ImportFrom alias alias alias alias alias ImportFrom alias alias alias alias alias alias alias alias alias alias alias alias ImportFrom alias alias alias ImportFrom alias alias alias ClassDef bases NameLoad body Expr Str FunctionDef arguments args NameParam defaults body Assign AttributeStore NameLoad attr ListLoad Assign AttributeStore NameLoad attr NameLoad Assign AttributeStore NameLoad attr Num Assign AttributeStore NameLoad attr Num Assign AttributeStore NameLoad attr NameLoad Assign AttributeStore NameLoad attr Num Assign AttributeStore NameLoad attr NameLoad Assign AttributeStore NameLoad attr Num Assign AttributeStore NameLoad attr NameLoad Assign AttributeStore NameLoad attr NameLoad Assign AttributeStore NameLoad attr NameLoad Assign AttributeStore NameLoad attr NameLoad Assign AttributeStore NameLoad attr NameLoad decorator_list decorator_list ClassDef bases NameLoad body Expr Str Assign NameStore Num Assign NameStore Num Assign NameStore NameLoad Assign NameStore NameLoad Assign NameStore NameLoad Assign NameStore TupleLoad Num Num Num Num Assign NameStore Str FunctionDef arguments args NameParam NameParam defaults NameLoad body Assign AttributeStore NameLoad attr NameLoad If CompareIs NameLoad NameLoad body Assign NameStore Call NameLoad Assign AttributeStore NameLoad attr NameLoad If CompareGt AttributeLoad NameLoad attr NameLoad body Raise Call NameLoad BinOpMod Str TupleLoad AttributeLoad NameLoad attr NameLoad AttributeLoad NameLoad attr orelse If BoolOpAnd CompareLt AttributeLoad NameLoad attr TupleLoad Num Num Num Num CompareNotEq AttributeLoad NameLoad attr NameLoad body Raise Call NameLoad BinOpMod Str TupleLoad AttributeLoad NameLoad attr NameLoad AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam NameParam defaults body Assign AttributeStore NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str If CompareIs AttributeLoad NameLoad attr NameLoad body Return Assign AttributeStore AttributeLoad NameLoad attr attr ListLoad Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad Assign AttributeStore AttributeLoad NameLoad attr attr Num Assign AttributeStore AttributeLoad NameLoad attr attr Num Assign AttributeStore AttributeLoad NameLoad attr attr Num If CompareIsNot AttributeLoad AttributeLoad NameLoad attr attr NameLoad body Assign AttributeStore AttributeLoad NameLoad attr attr Dict decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam defaults body Expr Str Assign NameStore Call AttributeLoad NameLoad attr NameLoad If CompareEq Call AttributeLoad AttributeLoad NameLoad attr attr Num NameLoad body Expr Call AttributeLoad AttributeLoad NameLoad attr attr Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad Return NameLoad If CompareGt AttributeLoad AttributeLoad NameLoad attr attr Num body Raise NameLoad Assign NameStore Call AttributeLoad NameLoad attr NameLoad NameLoad NameLoad Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad Expr Call AttributeLoad AttributeLoad NameLoad attr attr decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Return CompareEq Call AttributeLoad NameLoad attr Num NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body If CompareIs NameLoad NameLoad body Return NameLoad If CompareIn NameLoad NameLoad body If CompareGt Call NameLoad AttributeLoad AttributeLoad NameLoad attr attr Num body Assign NameStore BinOpSub NameLoad Call NameLoad ListLoad NameLoad Assign NameStore Call AttributeLoad NameLoad attr Assign NameStore BinOpBitOr NameLoad NameLoad If BoolOpOr CompareIn Call AttributeLoad NameLoad attr Num NameLoad CompareIn NameLoad NameLoad body Return NameLoad Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam defaults body Expr Str If Call AttributeLoad NameLoad attr NameLoad NameLoad body Raise Call NameLoad NameLoad NameLoad orelse If Call AttributeLoad NameLoad attr NameLoad NameLoad body Raise Call NameLoad NameLoad NameLoad NameLoad Raise Call NameLoad NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str If AttributeLoad AttributeLoad NameLoad attr attr body Return AugAssignAdd AttributeStore AttributeLoad NameLoad attr attr Num Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad Expr Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Assign NameStore Call AttributeLoad NameLoad attr NameLoad Assign NameStore Call AttributeLoad NameLoad attr NameLoad NameLoad Expr Call AttributeLoad NameLoad attr BinOpAdd BinOpAdd NameLoad Str NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str If Call NameLoad NameLoad NameLoad body Assign NameStore Str If CompareEq AttributeLoad NameLoad attr NameLoad body Assign NameStore Str orelse Assign NameStore SubscriptLoad AttributeLoad NameLoad attr Index AttributeLoad NameLoad attr Assign NameStore BinOpMod Str TupleLoad Call AttributeLoad NameLoad attr Call AttributeLoad NameLoad attr NameLoad orelse If Call NameLoad NameLoad NameLoad body Assign NameStore Str If CompareEq AttributeLoad NameLoad attr NameLoad body Assign NameStore Str orelse Assign NameStore SubscriptLoad AttributeLoad NameLoad attr Index AttributeLoad NameLoad attr Assign NameStore BinOpMod Str TupleLoad NameLoad Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr orelse If Call NameLoad NameLoad NameLoad body Assign NameStore Str If CompareEq AttributeLoad NameLoad attr NameLoad body Assign NameStore Str orelse Assign NameStore SubscriptLoad AttributeLoad NameLoad attr Index AttributeLoad NameLoad attr Assign NameStore BinOpAdd BinOpAdd BinOpAdd Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr Str NameLoad orelse If Call NameLoad NameLoad NameLoad body Assign NameStore Str If CompareEq AttributeLoad NameLoad attr NameLoad body Assign NameStore Str orelse Assign NameStore SubscriptLoad AttributeLoad NameLoad attr Index AttributeLoad NameLoad attr Assign NameStore BinOpMod Str TupleLoad AttributeLoad NameLoad attr NameLoad orelse If Call NameLoad NameLoad NameLoad body Assign NameStore BinOpAdd Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr orelse If Call NameLoad NameLoad NameLoad body Assign NameStore BinOpAdd Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr orelse If Call NameLoad NameLoad NameLoad body Assign NameStore BinOpAdd BinOpAdd BinOpAdd Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr Str Call NameLoad AttributeLoad NameLoad attr orelse If Call NameLoad NameLoad NameLoad body Assign NameStore BinOpAdd BinOpAdd BinOpAdd Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr Str Call NameLoad AttributeLoad NameLoad attr orelse If Call NameLoad NameLoad NameLoad body Assign NameStore BinOpAdd BinOpAdd BinOpAdd BinOpAdd Str AttributeLoad NameLoad attr Str AttributeLoad NameLoad attr Str orelse Assign NameStore Call NameLoad NameLoad Return NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return AttributeLoad AttributeLoad NameLoad attr attr decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Return BinOpMod Str TupleLoad AttributeLoad NameLoad attr AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Assign NameStore AttributeLoad NameLoad attr If CompareIs NameLoad NameLoad body If CompareEq AttributeLoad NameLoad attr NameLoad body Assign NameStore Str orelse Assign NameStore BinOpAdd BinOpAdd Str AttributeLoad NameLoad attr Str Return Call NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Expr Call AttributeLoad AttributeLoad NameLoad attr attr BinOpAdd NameLoad Str decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str If CompareEq AttributeLoad AttributeLoad NameLoad attr attr Call AttributeLoad NameLoad attr body Expr Call AttributeLoad NameLoad attr Assign AttributeStore AttributeLoad NameLoad attr attr Call AttributeLoad NameLoad attr Assign NameStore Call AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr NameLoad NameLoad Expr Call AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam defaults body Expr Str Pass decorator_list FunctionDef arguments args NameParam defaults body Expr Str Pass decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Assign NameStore Call NameLoad For TupleStore NameStore NameStore Call NameLoad Call NameLoad Call NameLoad AttributeLoad AttributeLoad NameLoad attr attr body AugAssignBitOr NameStore NameLoad If NameLoad body If CompareIn NameLoad NameLoad body If CompareGt NameLoad Num body Expr Call AttributeLoad NameLoad attr NameLoad orelse Break Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam defaults body Expr Str Assign NameStore NameLoad If Call AttributeLoad NameLoad attr NameLoad NameLoad body Assign NameStore Call NameLoad NameLoad NameLoad Expr Call AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr NameLoad Assign NameStore Call AttributeLoad NameLoad attr NameLoad Expr Call AttributeLoad NameLoad attr Return NameLoad If Call AttributeLoad NameLoad attr NameLoad NameLoad body Assign NameStore Call AttributeLoad NameLoad attr NameLoad NameLoad NameLoad NameLoad Assign NameStore Call NameLoad NameLoad NameLoad NameLoad Expr Call AttributeLoad NameLoad attr NameLoad Return NameLoad Assign NameStore Call NameLoad NameLoad NameLoad Raise NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam defaults body Expr Str If Call AttributeLoad NameLoad attr NameLoad NameLoad body Expr Call AttributeLoad NameLoad attr NameLoad Return Call AttributeLoad NameLoad attr NameLoad NameLoad NameLoad NameLoad Raise NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str If UnaryOpNot Call NameLoad NameLoad TupleLoad NameLoad NameLoad body Assign NameStore Call NameLoad ListLoad NameLoad Assign NameStore Call AttributeLoad NameLoad attr Num While BoolOpAnd CompareNotEq NameLoad NameLoad CompareNotIn NameLoad NameLoad body Expr Call AttributeLoad NameLoad attr Assign NameStore Call AttributeLoad NameLoad attr Num decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Assign NameStore ListLoad For NameStore Call NameLoad Call AttributeLoad NameLoad attr body Assign NameStore AttributeLoad SubscriptLoad NameLoad Index Num attr Assign NameStore Call AttributeLoad NameLoad attr NameLoad If CompareIs NameLoad NameLoad body Continue If CompareNotEq AttributeLoad NameLoad attr NameLoad body Continue If CompareIn AttributeLoad NameLoad attr TupleLoad Str Str body Continue Expr Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr Return NameLoad decorator_list Assign NameStore Call NameLoad NameLoad FunctionDef arguments args NameParam defaults body Return AttributeLoad AttributeLoad NameLoad attr attr decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam defaults body Raise NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str If CompareIs NameLoad NameLoad body Return NameLoad Return ListComp AttributeLoad NameLoad attr comprehension NameStore NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str If CompareNotIn NameLoad AttributeLoad AttributeLoad NameLoad attr attr body Assign SubscriptStore AttributeLoad AttributeLoad NameLoad attr attr Index NameLoad Dict Return Call AttributeLoad SubscriptLoad AttributeLoad AttributeLoad NameLoad attr attr Index NameLoad attr NameLoad AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Str Assign NameStore Call AttributeLoad NameLoad attr NameLoad Call AttributeLoad NameLoad attr If CompareEq NameLoad AttributeLoad NameLoad attr body Return NameLoad If CompareEq NameLoad AttributeLoad NameLoad attr body Raise NameLoad orelse Expr Call AttributeLoad NameLoad attr BinOpAdd NameLoad Num Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam NameParam defaults body Expr Str If NameLoad body Assign NameStore BinOpSub Call AttributeLoad NameLoad attr Num orelse Assign NameStore AttributeLoad NameLoad attr If CompareIn NameLoad AttributeLoad AttributeLoad NameLoad attr attr body Assign SubscriptStore SubscriptLoad AttributeLoad AttributeLoad NameLoad attr attr Index NameLoad Index NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam defaults body Expr Call AttributeLoad AttributeLoad NameLoad attr attr BinOpMod Str TupleLoad NameLoad NameLoad If CompareGt AttributeLoad AttributeLoad NameLoad attr attr Num body Expr Call AttributeLoad AttributeLoad NameLoad attr attr BinOpMod Str AttributeLoad AttributeLoad NameLoad attr attr Expr Call AttributeLoad AttributeLoad NameLoad attr attr Str decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam defaults body Expr Call AttributeLoad AttributeLoad NameLoad attr attr BinOpMod Str TupleLoad NameLoad NameLoad If CompareGt AttributeLoad AttributeLoad NameLoad attr attr Num body Expr Call AttributeLoad AttributeLoad NameLoad attr attr BinOpMod Str AttributeLoad AttributeLoad NameLoad attr attr Expr Call AttributeLoad AttributeLoad NameLoad attr attr Str decorator_list decorator_list ClassDef bases NameLoad body Expr Str FunctionDef arguments args NameParam defaults body Expr Str Raise NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Assign NameStore Call AttributeLoad NameLoad attr If BoolOpOr CompareIs NameLoad NameLoad CompareEq AttributeLoad NameLoad attr NameLoad body Raise NameLoad Return NameLoad decorator_list decorator_list ClassDef bases NameLoad NameLoad body Expr Str FunctionDef arguments args NameParam NameParam NameParam defaults NameLoad body Expr Call AttributeLoad NameLoad attr NameLoad NameLoad Expr Call AttributeLoad NameLoad attr NameLoad Assign AttributeStore NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Call AttributeLoad NameLoad attr NameLoad If CompareIsNot AttributeLoad NameLoad attr NameLoad body Expr Call AttributeLoad AttributeLoad NameLoad attr attr Num If CompareIs AttributeLoad NameLoad attr NameLoad body Return Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad Assign AttributeStore AttributeLoad NameLoad attr attr Num Assign AttributeStore AttributeLoad NameLoad attr attr Num Assign AttributeStore AttributeLoad NameLoad attr attr Num Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str While Num body Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad Assign AttributeStore AttributeLoad NameLoad attr attr Call AttributeLoad AttributeLoad NameLoad attr attr Assign AttributeStore AttributeLoad NameLoad attr attr AttributeLoad AttributeLoad NameLoad attr attr Assign AttributeStore AttributeLoad NameLoad attr attr AttributeLoad AttributeLoad NameLoad attr attr Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad If CompareEq Call AttributeLoad AttributeLoad NameLoad attr attr Num NameLoad body Return NameLoad TryExcept body Expr Call AttributeLoad NameLoad attr If CompareIs AttributeLoad AttributeLoad NameLoad attr attr NameLoad body Expr Call AttributeLoad NameLoad attr orelse If CompareEq AttributeLoad AttributeLoad NameLoad attr attr NameLoad body Continue Return AttributeLoad AttributeLoad NameLoad attr attr handlers ExceptHandler type NameLoad name NameStore body Expr Call AttributeLoad NameLoad attr NameLoad Expr Call AttributeLoad NameLoad attr NameLoad ExceptHandler type NameLoad name NameStore body Expr Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Raise NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Assign AttributeStore NameLoad attr NameLoad Expr Call AttributeLoad NameLoad attr Assign AttributeStore NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Return Call AttributeLoad AttributeLoad NameLoad attr attr decorator_list FunctionDef arguments args NameParam NameParam defaults NameLoad body Expr Str If CompareIs NameLoad NameLoad body Assign NameStore Call NameLoad keyword AttributeLoad NameLoad attr keyword AttributeLoad AttributeLoad NameLoad attr attr keyword AttributeLoad AttributeLoad NameLoad attr attr keyword AttributeLoad AttributeLoad NameLoad attr attr keyword BinOpSub Call AttributeLoad NameLoad attr Num Assign AttributeStore NameLoad attr AttributeLoad AttributeLoad NameLoad attr attr Assign AttributeStore NameLoad attr AttributeLoad AttributeLoad NameLoad attr attr Assign AttributeStore NameLoad attr AttributeLoad AttributeLoad NameLoad attr attr Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body If Call NameLoad NameLoad NameLoad body For NameStore NameLoad body If CompareNotEq Call AttributeLoad AttributeLoad NameLoad attr attr Num Call NameLoad NameLoad body If CompareGt AttributeLoad AttributeLoad NameLoad attr attr Num body Raise NameLoad Assign NameStore Call NameLoad NameLoad AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr NameLoad Raise NameLoad Expr Call AttributeLoad AttributeLoad NameLoad attr attr orelse If CompareNotEq Call AttributeLoad AttributeLoad NameLoad attr attr Num NameLoad body If CompareGt AttributeLoad AttributeLoad NameLoad attr attr Num body Raise NameLoad Assign NameStore Call NameLoad Call NameLoad NameLoad AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr NameLoad Raise NameLoad Expr Call AttributeLoad AttributeLoad NameLoad attr attr decorator_list FunctionDef arguments args NameParam defaults body Expr Call AttributeLoad AttributeLoad NameLoad attr attr decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body If BoolOpOr CompareLt Call AttributeLoad AttributeLoad NameLoad attr attr Num NameLoad CompareGt Call AttributeLoad AttributeLoad NameLoad attr attr Num NameLoad body If CompareGt AttributeLoad AttributeLoad NameLoad attr attr Num body Raise NameLoad Assign NameStore Call NameLoad Call NameLoad NameLoad Call NameLoad NameLoad AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr NameLoad Raise NameLoad Expr Call AttributeLoad AttributeLoad NameLoad attr attr decorator_list FunctionDef arguments args NameParam defaults body Return AttributeLoad AttributeLoad NameLoad attr attr decorator_list FunctionDef arguments args NameParam defaults body Return AttributeLoad AttributeLoad NameLoad attr attr decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return Call AttributeLoad AttributeLoad NameLoad attr attr decorator_list FunctionDef arguments args NameParam defaults body Expr Str If CompareIsNot AttributeLoad AttributeLoad NameLoad attr attr NameLoad body Return AttributeLoad AttributeLoad NameLoad attr attr Return Call AttributeLoad AttributeLoad NameLoad attr attr AttributeLoad AttributeLoad NameLoad attr attr BinOpSub Call AttributeLoad NameLoad attr Num decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Assign AttributeStore AttributeLoad NameLoad attr attr NameLoad decorator_list Assign NameStore Call NameLoad NameLoad NameLoad FunctionDef arguments args NameParam NameParam defaults body Expr Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Assign NameStore NameLoad If Call NameLoad NameLoad NameLoad body Assign NameStore BinOpAdd BinOpAdd BinOpAdd Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr orelse If Call NameLoad NameLoad NameLoad body Assign NameStore BinOpAdd Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr orelse If Call NameLoad NameLoad NameLoad body Assign NameStore BinOpAdd Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr orelse If Call NameLoad NameLoad NameLoad body Assign NameStore BinOpAdd BinOpAdd BinOpAdd Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr Str Call NameLoad AttributeLoad NameLoad attr orelse If Call NameLoad NameLoad NameLoad body Assign NameStore BinOpAdd BinOpAdd BinOpAdd Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr Str Call NameLoad AttributeLoad NameLoad attr orelse If Call NameLoad NameLoad NameLoad body Assign NameStore BinOpAdd BinOpAdd BinOpAdd BinOpAdd BinOpAdd Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr Str Call AttributeLoad NameLoad attr AttributeLoad NameLoad attr orelse Assign NameStore Call AttributeLoad NameLoad attr NameLoad NameLoad NameLoad Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body If CompareEq NameLoad NameLoad body Assign NameStore Str Return Call NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Expr Call AttributeLoad AttributeLoad NameLoad attr attr decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Assign NameStore BinOpMod Str TupleLoad Call AttributeLoad AttributeLoad NameLoad attr attr Num Call AttributeLoad NameLoad attr Call AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr NameLoad NameLoad NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Assign NameStore BinOpMod Str TupleLoad Call AttributeLoad AttributeLoad NameLoad attr attr Num Call AttributeLoad NameLoad attr Call AttributeLoad NameLoad attr Expr Call AttributeLoad NameLoad attr NameLoad NameLoad NameLoad NameLoad decorator_list decorator_list ClassDef bases NameLoad body Expr Str FunctionDef arguments args NameParam NameParam NameParam defaults NameLoad body Expr Call AttributeLoad NameLoad attr NameLoad NameLoad Expr Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Call AttributeLoad NameLoad attr NameLoad If CompareIsNot AttributeLoad NameLoad attr NameLoad body Expr Call AttributeLoad AttributeLoad NameLoad attr attr Num decorator_list FunctionDef arguments args NameParam NameParam defaults body Return Call AttributeLoad NameLoad attr Num decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam NameParam defaults body If CompareEq NameLoad NameLoad body Assign NameStore Str orelse Assign NameStore BinOpAdd BinOpAdd Str SubscriptLoad AttributeLoad NameLoad attr Index NameLoad Str Assign NameStore Call NameLoad keyword NameLoad keyword NameLoad Assign NameStore Call AttributeLoad NameLoad attr Num If CompareEq AttributeLoad NameLoad attr NameLoad body Assign NameStore Call AttributeLoad NameLoad attr Num If CompareIsNot NameLoad NameLoad body Assign AttributeStore NameLoad attr AttributeLoad NameLoad attr Assign AttributeStore NameLoad attr AttributeLoad NameLoad attr Assign AttributeStore NameLoad attr NameLoad Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body Expr Str Assign AttributeStore NameLoad attr NameLoad Expr Call AttributeLoad NameLoad attr Assign AttributeStore NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Return AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam defaults body Return Call AttributeLoad AttributeLoad NameLoad attr attr decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Call AttributeLoad NameLoad attr NameLoad NameLoad NameLoad Call AttributeLoad AttributeLoad NameLoad attr attr Num decorator_list FunctionDef arguments args NameParam NameParam NameParam defaults body Expr Call AttributeLoad NameLoad attr NameLoad NameLoad NameLoad Call AttributeLoad AttributeLoad NameLoad attr attr Num decorator_list decorator_list ClassDef bases NameLoad body Expr Str FunctionDef arguments args NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Return NameLoad decorator_list decorator_list ClassDef bases NameLoad body Expr Str FunctionDef arguments args NameParam defaults body Assign AttributeStore NameLoad attr NameLoad Assign AttributeStore NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Return AttributeLoad NameLoad attr decorator_list FunctionDef arguments args NameParam defaults body Return AttributeLoad NameLoad attr decorator_list decorator_list
N/A N/A ANTLR3 runtime package N/A sys N/A inspect google.appengine._internal.antlr3 runtime_version runtime_version_str google.appengine._internal.antlr3.constants DEFAULT_CHANNEL HIDDEN_CHANNEL EOF EOR_TOKEN_TYPE INVALID_TOKEN_TYPE google.appengine._internal.antlr3.exceptions RecognitionException MismatchedTokenException MismatchedRangeException MismatchedTreeNodeException NoViableAltException EarlyExitException MismatchedSetException MismatchedNotSetException FailedPredicateException BacktrackingFailed UnwantedTokenException MissingTokenException google.appengine._internal.antlr3.tokens CommonToken EOF_TOKEN SKIP_TOKEN google.appengine._internal.antlr3.compat set frozenset reversed RecognizerSharedState N/A object N/A N/A 
    The set of fields needed by an abstract recognizer to recognize input
    and recover from errors etc...  As a separate state object, it can be
    shared among multiple grammars; e.g., when one grammar imports another.

    These fields are publically visible but the actual state pointer per
    parser is protected.
     __init__ N/A N/A self N/A N/A N/A N/A self following N/A N/A N/A self errorRecovery False N/A N/A self lastErrorIndex -1 N/A N/A self backtracking 0 N/A N/A self ruleMemo None N/A N/A self syntaxErrors 0 N/A N/A self token None N/A N/A self tokenStartCharIndex -1 N/A N/A self tokenStartLine None N/A N/A self tokenStartCharPositionInLine None N/A N/A self channel None N/A N/A self type None N/A N/A self text None N/A N/A BaseRecognizer N/A object N/A N/A 
    @brief Common recognizer functionality.

    A generic recognizer that can handle recognizers generated from
    lexer, parser, and tree grammars.  This is all the parsing
    support code essentially; most of it is error recovery stuff and
    backtracking.
     N/A MEMO_RULE_FAILED -2 N/A MEMO_RULE_UNKNOWN -1 N/A DEFAULT_TOKEN_CHANNEL DEFAULT_CHANNEL N/A HIDDEN HIDDEN_CHANNEL N/A tokenNames None N/A antlr_version N/A 3 0 1 0 N/A antlr_version_str 3.0.1 __init__ N/A N/A self state N/A None N/A N/A N/A self input None N/A N/A state None N/A N/A state N/A RecognizerSharedState N/A N/A self _state state N/A N/A N/A self antlr_version runtime_version N/A N/A N/A RuntimeError N/A ANTLR version mismatch: The recognizer has been generated by V%s, but this runtime is V%s. Please use the V%s runtime or higher. N/A N/A self antlr_version_str runtime_version_str N/A self antlr_version_str N/A N/A N/A N/A N/A self antlr_version N/A 3 1 0 0 N/A N/A self antlr_version runtime_version N/A N/A N/A RuntimeError N/A ANTLR version mismatch: The recognizer has been generated by V%s, but this runtime is V%s. Please use the V%s runtime. N/A N/A self antlr_version_str runtime_version_str N/A self antlr_version_str N/A setInput N/A N/A self input N/A N/A N/A N/A self input input N/A reset N/A N/A self N/A N/A N/A 
        reset the parser's state; subclasses must rewinds the input stream
         N/A N/A N/A self _state None N/A N/A N/A N/A N/A self _state following N/A N/A N/A N/A self _state errorRecovery False N/A N/A N/A self _state lastErrorIndex -1 N/A N/A N/A self _state syntaxErrors 0 N/A N/A N/A self _state backtracking 0 N/A N/A N/A N/A self _state ruleMemo None N/A N/A N/A N/A self _state ruleMemo N/A N/A match N/A N/A self input ttype follow N/A N/A N/A 
        Match current input symbol against ttype.  Attempt
        single token insertion or deletion error recovery.  If
        that fails, throw MismatchedTokenException.

        To turn off single token insertion or deletion error
        recovery, override mismatchRecover() and have it call
        plain mismatch(), which does not recover.  Then any error
        in a rule will cause an exception and immediate exit from
        rule.  Rule would recover by resynchronizing to the set of
        symbols that can follow rule ref.
         N/A matchedSymbol N/A N/A self getCurrentInputSymbol input N/A N/A N/A N/A N/A self input LA 1 ttype N/A N/A N/A N/A N/A self input consume N/A N/A N/A self _state errorRecovery False N/A matchedSymbol N/A N/A N/A N/A self _state backtracking 0 N/A N/A BacktrackingFailed N/A matchedSymbol N/A N/A self recoverFromMismatchedToken input ttype follow N/A matchedSymbol N/A matchAny N/A N/A self input N/A N/A N/A Match the wildcard: in a symbol N/A N/A N/A self _state errorRecovery False N/A N/A N/A N/A self input consume N/A mismatchIsUnwantedToken N/A N/A self input ttype N/A N/A N/A N/A N/A N/A input LA 2 ttype N/A mismatchIsMissingToken N/A N/A self input follow N/A N/A N/A N/A follow None N/A N/A False N/A N/A EOR_TOKEN_TYPE follow N/A N/A N/A N/A len N/A N/A self _state following 0 N/A N/A follow N/A follow N/A set N/A EOR_TOKEN_TYPE N/A viableTokensFollowingThisRule N/A N/A self computeContextSensitiveRuleFOLLOW N/A follow N/A follow viableTokensFollowingThisRule N/A N/A N/A N/A N/A input LA 1 follow N/A EOR_TOKEN_TYPE follow N/A N/A True N/A False N/A mismatch N/A N/A self input ttype follow N/A N/A N/A 
        Factor out what to do upon token mismatch so tree parsers can behave
        differently.  Override and call mismatchRecover(input, ttype, follow)
        to get single token insertion and deletion. Use this to turn of
        single token insertion and deletion. Override mismatchRecover
        to call this instead.
         N/A N/A N/A self mismatchIsUnwantedToken input ttype N/A N/A N/A UnwantedTokenException ttype input N/A N/A N/A N/A self mismatchIsMissingToken input follow N/A N/A N/A MissingTokenException ttype input None N/A N/A MismatchedTokenException ttype input N/A reportError N/A N/A self e N/A N/A N/A Report a recognition problem.

        This method sets errorRecovery to indicate the parser is recovering
        not parsing.  Once in recovery mode, no errors are generated.
        To get out of recovery mode, the parser must successfully match
        a token (after a resync).  So it will go:

        1. error occurs
        2. enter recovery mode, report error
        3. consume until token found in resynch set
        4. try to resume parsing
        5. next match() will reset errorRecovery mode

        If you override, make sure to update syntaxErrors if you care about
        that.

         N/A N/A N/A self _state errorRecovery N/A N/A N/A N/A N/A self _state syntaxErrors 1 N/A N/A N/A self _state errorRecovery True N/A N/A N/A self displayRecognitionError N/A self tokenNames e N/A displayRecognitionError N/A N/A self tokenNames e N/A N/A N/A hdr N/A N/A self getErrorHeader e N/A msg N/A N/A self getErrorMessage e tokenNames N/A N/A N/A self emitErrorMessage N/A N/A hdr msg N/A getErrorMessage N/A N/A self e tokenNames N/A N/A N/A 
        What error message should be generated for the various
        exception types?

        Not very object-oriented code, but I like having all error message
        generation within one method rather than spread among all of the
        exception classes. This also makes it much easier for the exception
        handling because the exception classes do not have to have pointers back
        to this object to access utility routines and so on. Also, changing
        the message for an exception type would be difficult because you
        would have to subclassing exception, but then somehow get ANTLR
        to make those kinds of exception objects instead of the default.
        This looks weird, but trust me--it makes the most sense in terms
        of flexibility.

        For grammar debugging, you will want to override this to add
        more information such as the stack frame with
        getRuleInvocationStack(e, this.getClass().getName()) and,
        for no viable alts, the decision description and state etc...

        Override this to change the message generated for one or more
        exception types.
         N/A N/A isinstance e UnwantedTokenException N/A N/A tokenName <unknown> N/A N/A N/A e expecting EOF N/A N/A tokenName EOF N/A N/A tokenName N/A N/A self tokenNames N/A N/A e expecting N/A msg N/A extraneous input %s expecting %s N/A N/A N/A self getTokenErrorDisplay N/A N/A e getUnexpectedToken tokenName N/A N/A N/A isinstance e MissingTokenException N/A N/A tokenName <unknown> N/A N/A N/A e expecting EOF N/A N/A tokenName EOF N/A N/A tokenName N/A N/A self tokenNames N/A N/A e expecting N/A msg N/A missing %s at %s N/A tokenName N/A N/A self getTokenErrorDisplay N/A e token N/A N/A N/A isinstance e MismatchedTokenException N/A N/A tokenName <unknown> N/A N/A N/A e expecting EOF N/A N/A tokenName EOF N/A N/A tokenName N/A N/A self tokenNames N/A N/A e expecting N/A msg N/A N/A N/A mismatched input  N/A N/A self getTokenErrorDisplay N/A e token  expecting  tokenName N/A N/A N/A isinstance e MismatchedTreeNodeException N/A N/A tokenName <unknown> N/A N/A N/A e expecting EOF N/A N/A tokenName EOF N/A N/A tokenName N/A N/A self tokenNames N/A N/A e expecting N/A msg N/A mismatched tree node: %s expecting %s N/A N/A e node tokenName N/A N/A N/A isinstance e NoViableAltException N/A N/A msg N/A no viable alternative at input  N/A N/A self getTokenErrorDisplay N/A e token N/A N/A N/A isinstance e EarlyExitException N/A N/A msg N/A required (...)+ loop did not match anything at input  N/A N/A self getTokenErrorDisplay N/A e token N/A N/A N/A isinstance e MismatchedSetException N/A N/A msg N/A N/A N/A mismatched input  N/A N/A self getTokenErrorDisplay N/A e token  expecting set  N/A repr N/A e expecting N/A N/A N/A isinstance e MismatchedNotSetException N/A N/A msg N/A N/A N/A mismatched input  N/A N/A self getTokenErrorDisplay N/A e token  expecting set  N/A repr N/A e expecting N/A N/A N/A isinstance e FailedPredicateException N/A N/A msg N/A N/A N/A N/A rule  N/A e ruleName  failed predicate: { N/A e predicateText }? N/A N/A msg N/A str e N/A msg N/A getNumberOfSyntaxErrors N/A N/A self N/A N/A N/A 
        Get number of recognition errors (lexer, parser, tree parser).  Each
        recognizer tracks its own number.  So parser and lexer each have
        separate count.  Does not count the spurious errors found between
        an error and next valid token match

        See also reportError()
	 N/A N/A N/A self _state syntaxErrors N/A getErrorHeader N/A N/A self e N/A N/A N/A 
        What is the error header, normally line/character position information?
         N/A N/A line %d:%d N/A N/A e line N/A e charPositionInLine N/A getTokenErrorDisplay N/A N/A self t N/A N/A N/A 
        How should a token be displayed in an error message? The default
        is to display just the text, but during development you might
        want to have a lot of information spit out.  Override in that case
        to use t.toString() (which, for CommonToken, dumps everything about
        the token). This is better than forcing you to override a method in
        your token objects because you don't have to go modify your lexer
        so that it creates a new Java type.
         N/A s N/A t text N/A N/A s None N/A N/A N/A N/A t type EOF N/A N/A s <EOF> N/A N/A s N/A N/A < N/A t type > N/A N/A repr s N/A emitErrorMessage N/A N/A self msg N/A N/A N/A Override this method to change where error messages go N/A N/A N/A N/A sys stderr write N/A msg N/A recover N/A N/A self input re N/A N/A N/A 
        Recover from an error found on the input stream.  This is
        for NoViableAlt and mismatched symbol exceptions.  If you enable
        single token insertion and deletion, this will usually not
        handle mismatched symbol exceptions but there could be a mismatched
        token that the match() routine could not recover from.
         N/A N/A N/A N/A self _state lastErrorIndex N/A N/A input index N/A N/A N/A N/A input consume N/A N/A N/A self _state lastErrorIndex N/A N/A input index N/A followSet N/A N/A self computeErrorRecoverySet N/A N/A N/A self beginResync N/A N/A N/A self consumeUntil input followSet N/A N/A N/A self endResync N/A beginResync N/A N/A self N/A N/A N/A 
        A hook to listen in on the token consumption during error recovery.
        The DebugParser subclasses this to fire events to the listenter.
         N/A N/A endResync N/A N/A self N/A N/A N/A 
        A hook to listen in on the token consumption during error recovery.
        The DebugParser subclasses this to fire events to the listenter.
         N/A N/A computeErrorRecoverySet N/A N/A self N/A N/A N/A 
        Compute the error recovery set for the current rule.  During
        rule invocation, the parser pushes the set of tokens that can
        follow that rule reference on the stack; this amounts to
        computing FIRST of what follows the rule reference in the
        enclosing rule. This local follow set only includes tokens
        from within the rule; i.e., the FIRST computation done by
        ANTLR stops at the end of a rule.

        EXAMPLE

        When you find a "no viable alt exception", the input is not
        consistent with any of the alternatives for rule r.  The best
        thing to do is to consume tokens until you see something that
        can legally follow a call to r *or* any rule that called r.
        You don't want the exact set of viable next tokens because the
        input might just be missing a token--you might consume the
        rest of the input looking for one of the missing tokens.

        Consider grammar:

        a : '[' b ']'
          | '(' b ')'
          ;
        b : c '^' INT ;
        c : ID
          | INT
          ;

        At each rule invocation, the set of tokens that could follow
        that rule is pushed on a stack.  Here are the various "local"
        follow sets:

        FOLLOW(b1_in_a) = FIRST(']') = ']'
        FOLLOW(b2_in_a) = FIRST(')') = ')'
        FOLLOW(c_in_b) = FIRST('^') = '^'

        Upon erroneous input "[]", the call chain is

        a -> b -> c

        and, hence, the follow context stack is:

        depth  local follow set     after call to rule
          0         \<EOF>                    a (from main())
          1          ']'                     b
          3          '^'                     c

        Notice that ')' is not included, because b would have to have
        been called from a different context in rule a for ')' to be
        included.

        For error recovery, we cannot consider FOLLOW(c)
        (context-sensitive or otherwise).  We need the combined set of
        all context-sensitive FOLLOW sets--the set of all tokens that
        could follow any reference in the call chain.  We need to
        resync to one of those tokens.  Note that FOLLOW(c)='^' and if
        we resync'd to that token, we'd consume until EOF.  We need to
        sync to context-sensitive FOLLOWs for a, b, and c: {']','^'}.
        In this case, for input "[]", LA(1) is in this set so we would
        not consume anything and after printing an error rule c would
        return normally.  It would not find the required '^' though.
        At this point, it gets a mismatched token error and throws an
        exception (since LA(1) is not in the viable following token
        set).  The rule exception handler tries to recover, but finds
        the same recovery set and doesn't consume anything.  Rule b
        exits normally returning to rule a.  Now it finds the ']' (and
        with the successful match exits errorRecovery mode).

        So, you cna see that the parser walks up call chain looking
        for the token that was a member of the recovery set.

        Errors are not generated in errorRecovery mode.

        ANTLR's error recovery mechanism is based upon original ideas:

        "Algorithms + Data Structures = Programs" by Niklaus Wirth

        and

        "A note on error recovery in recursive descent parsers":
        http://portal.acm.org/citation.cfm?id=947902.947905

        Later, Josef Grosch had some good ideas:

        "Efficient and Comfortable Error Recovery in Recursive Descent
        Parsers":
        ftp://www.cocolab.com/products/cocktail/doca4.ps/ell.ps.zip

        Like Grosch I implemented local FOLLOW sets that are combined
        at run-time upon error to avoid overhead during parsing.
         N/A N/A N/A self combineFollows False N/A computeContextSensitiveRuleFOLLOW N/A N/A self N/A N/A N/A 
        Compute the context-sensitive FOLLOW set for current rule.
        This is set of token types that can follow a specific rule
        reference given a specific call chain.  You get the set of
        viable tokens that can possibly come next (lookahead depth 1)
        given the current call chain.  Contrast this with the
        definition of plain FOLLOW for rule r:

         FOLLOW(r)={x | S=>*alpha r beta in G and x in FIRST(beta)}

        where x in T* and alpha, beta in V*; T is set of terminals and
        V is the set of terminals and nonterminals.  In other words,
        FOLLOW(r) is the set of all tokens that can possibly follow
        references to r in *any* sentential form (context).  At
        runtime, however, we know precisely which context applies as
        we have the call chain.  We may compute the exact (rather
        than covering superset) set of following tokens.

        For example, consider grammar:

        stat : ID '=' expr ';'      // FOLLOW(stat)=={EOF}
             | "return" expr '.'
             ;
        expr : atom ('+' atom)* ;   // FOLLOW(expr)=={';','.',')'}
        atom : INT                  // FOLLOW(atom)=={'+',')',';','.'}
             | '(' expr ')'
             ;

        The FOLLOW sets are all inclusive whereas context-sensitive
        FOLLOW sets are precisely what could follow a rule reference.
        For input input "i=(3);", here is the derivation:

        stat => ID '=' expr ';'
             => ID '=' atom ('+' atom)* ';'
             => ID '=' '(' expr ')' ('+' atom)* ';'
             => ID '=' '(' atom ')' ('+' atom)* ';'
             => ID '=' '(' INT ')' ('+' atom)* ';'
             => ID '=' '(' INT ')' ';'

        At the "3" token, you'd have a call chain of

          stat -> expr -> atom -> expr -> atom

        What can follow that specific nested ref to atom?  Exactly ')'
        as you can see by looking at the derivation of this specific
        input.  Contrast this with the FOLLOW(atom)={'+',')',';','.'}.

        You want the exact viable token set when recovering from a
        token mismatch.  Upon token mismatch, if LA(1) is member of
        the viable next token set, then you know there is most likely
        a missing token in the input stream.  "Insert" one by just not
        throwing an exception.
         N/A N/A N/A self combineFollows True N/A combineFollows N/A N/A self exact N/A N/A N/A followSet N/A set N/A N/A idx localFollowSet N/A reversed N/A list N/A enumerate N/A N/A self _state following N/A N/A followSet localFollowSet N/A exact N/A N/A N/A EOR_TOKEN_TYPE localFollowSet N/A N/A N/A idx 0 N/A N/A N/A N/A followSet remove EOR_TOKEN_TYPE N/A N/A N/A followSet N/A recoverFromMismatchedToken N/A N/A self input ttype follow N/A N/A N/A Attempt to recover from a single missing or extra token.

        EXTRA TOKEN

        LA(1) is not what we are looking for.  If LA(2) has the right token,
        however, then assume LA(1) is some extra spurious token.  Delete it
        and LA(2) as if we were doing a normal match(), which advances the
        input.

        MISSING TOKEN

        If current token is consistent with what could come after
        ttype then it is ok to 'insert' the missing token, else throw
        exception For example, Input 'i=(3;' is clearly missing the
        ')'.  When the parser returns from the nested call to expr, it
        will have call chain:

          stat -> expr -> atom

        and it will be trying to match the ')' at this point in the
        derivation:

             => ID '=' '(' INT ')' ('+' atom)* ';'
                                ^
        match() will see that ';' doesn't match ')' and report a
        mismatched token error.  To recover, it sees that LA(1)==';'
        is in the set of tokens that can follow the ')' token
        reference in rule atom.  It can assume that you forgot the ')'.
         N/A e None N/A N/A N/A self mismatchIsUnwantedToken input ttype N/A N/A e N/A UnwantedTokenException ttype input N/A N/A N/A self beginResync N/A N/A N/A input consume N/A N/A N/A self endResync N/A N/A N/A self reportError e N/A matchedSymbol N/A N/A self getCurrentInputSymbol input N/A N/A N/A input consume N/A matchedSymbol N/A N/A N/A self mismatchIsMissingToken input follow N/A N/A inserted N/A N/A self getMissingSymbol input e ttype follow N/A e N/A MissingTokenException ttype input inserted N/A N/A N/A self reportError e N/A inserted N/A e N/A MismatchedTokenException ttype input N/A e N/A recoverFromMismatchedSet N/A N/A self input e follow N/A N/A N/A Not currently used N/A N/A N/A self mismatchIsMissingToken input follow N/A N/A N/A N/A self reportError e N/A N/A N/A self getMissingSymbol input e INVALID_TOKEN_TYPE follow N/A e N/A getCurrentInputSymbol N/A N/A self input N/A N/A N/A 
        Match needs to return the current input symbol, which gets put
        into the label for the associated token ref; e.g., x=ID.  Token
        and tree parsers need to return different objects. Rather than test
        for input stream type or change the IntStream interface, I use
        a simple method to ask the recognizer to tell me what the current
        input symbol is.

        This is ignored for lexers.
         N/A None N/A getMissingSymbol N/A N/A self input e expectedTokenType follow N/A N/A N/A Conjure up a missing token during error recovery.

        The recognizer attempts to recover from single missing
        symbols. But, actions might refer to that missing symbol.
        For example, x=ID {f($x);}. The action clearly assumes
        that there has been an identifier matched previously and that
        $x points at that token. If that token is missing, but
        the next token in the stream is what we want we assume that
        this token is missing and we keep going. Because we
        have to return some token to replace the missing token,
        we have to conjure one up. This method gives the user control
        over the tokens returned for missing tokens. Mostly,
        you will want to create something special for identifier
        tokens. For literals such as '{' and ',', the default
        action in the parser or tree parser works. It simply creates
        a CommonToken of the appropriate type. The text will be the token.
        If you change what tokens must be created by the lexer,
        override this method to create the appropriate tokens.
         N/A None N/A consumeUntil N/A N/A self input tokenTypes N/A N/A N/A 
        Consume tokens until one matches the given token or token set

        tokenTypes can be a single token type or a set of token types

         N/A N/A N/A isinstance tokenTypes N/A set frozenset N/A N/A tokenTypes N/A frozenset N/A tokenTypes N/A ttype N/A N/A input LA 1 N/A N/A N/A ttype EOF N/A ttype tokenTypes N/A N/A N/A N/A input consume N/A ttype N/A N/A input LA 1 N/A getRuleInvocationStack N/A N/A self N/A N/A N/A 
        Return List<String> of the rules in your parser instance
        leading up to a call to this method.  You could override if
        you want more details such as the file/line info of where
        in the parser java code a rule is invoked.

        This is very useful for error messages and for context-sensitive
        error recovery.

        You must be careful, if you subclass a generated recognizers.
        The default implementation will only search the module of self
        for rules, but the subclass will not contain any rules.
        You probably want to override this method to look like

        def getRuleInvocationStack(self):
            return self._getRuleInvocationStack(<class>.__module__)

        where <class> is the class of the generated recognizer, e.g.
        the superclass of self.
         N/A N/A N/A self _getRuleInvocationStack N/A self __module__ N/A _getRuleInvocationStack N/A N/A cls module N/A N/A N/A 
        A more general version of getRuleInvocationStack where you can
        pass in, for example, a RecognitionException to get it's rule
        stack trace.  This routine is shared with all recognizers, hence,
        static.

        TODO: move to a utility class or something; weird having lexer call
        this
         N/A rules N/A N/A frame N/A reversed N/A N/A inspect stack N/A N/A code N/A N/A frame N/A 0 f_code N/A codeMod N/A N/A inspect getmodule code N/A N/A codeMod None N/A N/A N/A N/A N/A codeMod __name__ module N/A N/A N/A N/A N/A code co_name N/A nextToken <module> N/A N/A N/A N/A N/A rules append N/A code co_name N/A rules N/A N/A _getRuleInvocationStack N/A classmethod _getRuleInvocationStack getBacktrackingLevel N/A N/A self N/A N/A N/A N/A N/A self _state backtracking N/A getGrammarFileName N/A N/A self N/A N/A N/A For debugging and other purposes, might want the grammar name.

        Have ANTLR generate an implementation for this method.
         N/A N/A self grammarFileName N/A getSourceName N/A N/A self N/A N/A N/A NotImplementedError N/A toStrings N/A N/A self tokens N/A N/A N/A A convenience method for use most often with template rewrites.

        Convert a List<Token> to List<String>
         N/A N/A tokens None N/A N/A None N/A N/A N/A token text N/A token tokens N/A getRuleMemoization N/A N/A self ruleIndex ruleStartIndex N/A N/A N/A 
        Given a rule number and a start token index number, return
        MEMO_RULE_UNKNOWN if the rule has not parsed input starting from
        start index.  If this rule has parsed input starting from the
        start index before, then return where the rule stopped parsing.
        It returns the index of the last token matched by the rule.
         N/A N/A ruleIndex N/A N/A self _state ruleMemo N/A N/A N/A N/A N/A self _state ruleMemo N/A ruleIndex N/A N/A N/A N/A N/A N/A N/A self _state ruleMemo N/A ruleIndex get ruleStartIndex N/A self MEMO_RULE_UNKNOWN N/A alreadyParsedRule N/A N/A self input ruleIndex N/A N/A N/A 
        Has this rule already parsed input at the current index in the
        input stream?  Return the stop token index or MEMO_RULE_UNKNOWN.
        If we attempted but failed to parse properly before, return
        MEMO_RULE_FAILED.

        This method has a side-effect: if we have seen this input for
        this rule and successfully parsed before, then seek ahead to
        1 past the stop token matched for this rule last time.
         N/A stopIndex N/A N/A self getRuleMemoization ruleIndex N/A N/A input index N/A N/A stopIndex N/A self MEMO_RULE_UNKNOWN N/A N/A False N/A N/A stopIndex N/A self MEMO_RULE_FAILED N/A N/A BacktrackingFailed N/A N/A N/A N/A input seek N/A stopIndex 1 N/A True N/A memoize N/A N/A self input ruleIndex ruleStartIndex success N/A N/A N/A 
        Record whether or not this rule parsed the input at this position
        successfully.
         N/A success N/A N/A stopTokenIndex N/A N/A N/A input index 1 N/A N/A stopTokenIndex N/A self MEMO_RULE_FAILED N/A N/A ruleIndex N/A N/A self _state ruleMemo N/A N/A N/A N/A N/A N/A self _state ruleMemo N/A ruleIndex N/A ruleStartIndex stopTokenIndex N/A traceIn N/A N/A self ruleName ruleIndex inputSymbol N/A N/A N/A N/A N/A N/A sys stdout write N/A enter %s %s N/A ruleName inputSymbol N/A N/A N/A N/A self _state backtracking 0 N/A N/A N/A N/A N/A sys stdout write N/A  backtracking=%s N/A N/A self _state backtracking N/A N/A N/A N/A sys stdout write N/A traceOut N/A N/A self ruleName ruleIndex inputSymbol N/A N/A N/A N/A N/A N/A sys stdout write N/A exit %s %s N/A ruleName inputSymbol N/A N/A N/A N/A self _state backtracking 0 N/A N/A N/A N/A N/A sys stdout write N/A  backtracking=%s N/A N/A self _state backtracking N/A N/A N/A N/A sys stdout write N/A N/A TokenSource N/A object N/A N/A 
    @brief Abstract baseclass for token producers.

    A source of tokens must provide a sequence of tokens via nextToken()
    and also must reveal it's source of characters; CommonToken's text is
    computed from a CharStream; it only store indices into the char stream.

    Errors from the lexer are never passed to the parser.  Either you want
    to keep going or you do not upon token recognition error.  If you do not
    want to continue lexing then you do not want to continue parsing.  Just
    throw an exception not under RecognitionException and Java will naturally
    toss you all the way out of the recognizers.  If you want to continue
    lexing then you should not throw an exception to the parser--it has already
    requested a token.  Keep lexing until you get a valid one.  Just report
    errors and keep going, looking for a valid token.
     nextToken N/A N/A self N/A N/A N/A Return a Token object from your input stream (usually a CharStream).

        Do not fail/return upon lexing error; keep chewing on the characters
        until you get a good one; errors are not passed through to the parser.
         N/A NotImplementedError N/A __iter__ N/A N/A self N/A N/A N/A The TokenSource is an interator.

        The iteration will not include the final EOF token, see also the note
        for the next() method.

         N/A self N/A next N/A N/A self N/A N/A N/A Return next token or raise StopIteration.

        Note that this will raise StopIteration when hitting the EOF token,
        so EOF will not be part of the iteration.

         N/A token N/A N/A self nextToken N/A N/A N/A token None N/A N/A token type EOF N/A N/A StopIteration N/A token N/A N/A Lexer N/A BaseRecognizer TokenSource N/A N/A 
    @brief Baseclass for generated lexer classes.

    A lexer is recognizer that draws input symbols from a character stream.
    lexer grammars result in a subclass of this object. A Lexer object
    uses simplified match() and error recovery mechanisms in the interest
    of speed.
     __init__ N/A N/A self input state N/A None N/A N/A N/A N/A BaseRecognizer __init__ self state N/A N/A N/A TokenSource __init__ self N/A N/A self input input N/A reset N/A N/A self N/A N/A N/A N/A N/A BaseRecognizer reset self N/A N/A N/A self input None N/A N/A N/A N/A N/A self input seek 0 N/A N/A N/A self _state None N/A N/A N/A N/A N/A self _state token None N/A N/A N/A self _state type INVALID_TOKEN_TYPE N/A N/A N/A self _state channel DEFAULT_CHANNEL N/A N/A N/A self _state tokenStartCharIndex -1 N/A N/A N/A self _state tokenStartLine -1 N/A N/A N/A self _state tokenStartCharPositionInLine -1 N/A N/A N/A self _state text None N/A nextToken N/A N/A self N/A N/A N/A 
        Return a token from this source; i.e., match a token on the char
        stream.
         N/A 1 N/A N/A N/A N/A self _state token None N/A N/A N/A self _state channel DEFAULT_CHANNEL N/A N/A N/A self _state tokenStartCharIndex N/A N/A N/A self input index N/A N/A N/A self _state tokenStartCharPositionInLine N/A N/A self input charPositionInLine N/A N/A N/A self _state tokenStartLine N/A N/A self input line N/A N/A N/A self _state text None N/A N/A N/A N/A N/A self input LA 1 EOF N/A N/A EOF_TOKEN N/A N/A N/A N/A N/A self mTokens N/A N/A N/A N/A self _state token None N/A N/A N/A N/A self emit N/A N/A N/A N/A N/A self _state token SKIP_TOKEN N/A N/A N/A N/A N/A self _state token N/A N/A N/A NoViableAltException N/A re N/A N/A N/A N/A self reportError re N/A N/A N/A self recover re N/A N/A RecognitionException N/A re N/A N/A N/A N/A self reportError re N/A skip N/A N/A self N/A N/A N/A 
        Instruct the lexer to skip creating a token for current lexer rule
        and look for another token.  nextToken() knows to keep looking when
        a lexer rule finishes with token set to SKIP_TOKEN.  Recall that
        if token==null at end of any token rule, it creates one for you
        and emits it.
         N/A N/A N/A self _state token SKIP_TOKEN N/A mTokens N/A N/A self N/A N/A N/A This is the lexer entry point that sets instance var 'token' N/A NotImplementedError N/A setCharStream N/A N/A self input N/A N/A N/A Set the char stream and reset the lexer N/A N/A self input None N/A N/A N/A self reset N/A N/A self input input N/A getSourceName N/A N/A self N/A N/A N/A N/A N/A N/A self input getSourceName N/A emit N/A N/A self token N/A None N/A N/A 
        The standard method called to automatically emit a token at the
        outermost lexical rule.  The token object should point into the
        char buffer start..stop.  If there is a text override in 'text',
        use that to set the token's text.  Override this method to emit
        custom Token objects.

        If you are building trees, then you should also override
        Parser or TreeParser.getMissingSymbol().
         N/A N/A token None N/A N/A token N/A CommonToken input N/A self input type N/A N/A self _state type channel N/A N/A self _state channel start N/A N/A self _state tokenStartCharIndex stop N/A N/A N/A self getCharIndex 1 N/A N/A token line N/A N/A self _state tokenStartLine N/A N/A token text N/A N/A self _state text N/A N/A token charPositionInLine N/A N/A self _state tokenStartCharPositionInLine N/A N/A N/A self _state token token N/A token N/A match N/A N/A self s N/A N/A N/A N/A isinstance s basestring N/A N/A c s N/A N/A N/A N/A N/A N/A self input LA 1 N/A ord c N/A N/A N/A N/A N/A self _state backtracking 0 N/A N/A BacktrackingFailed N/A mte N/A MismatchedTokenException c N/A self input N/A N/A N/A self recover mte N/A mte N/A N/A N/A N/A self input consume N/A N/A N/A N/A N/A N/A self input LA 1 s N/A N/A N/A N/A N/A self _state backtracking 0 N/A N/A BacktrackingFailed N/A mte N/A MismatchedTokenException N/A unichr s N/A self input N/A N/A N/A self recover mte N/A mte N/A N/A N/A N/A self input consume N/A matchAny N/A N/A self N/A N/A N/A N/A N/A N/A self input consume N/A matchRange N/A N/A self a b N/A N/A N/A N/A N/A N/A N/A N/A self input LA 1 a N/A N/A N/A N/A self input LA 1 b N/A N/A N/A N/A N/A self _state backtracking 0 N/A N/A BacktrackingFailed N/A mre N/A MismatchedRangeException N/A unichr a N/A unichr b N/A self input N/A N/A N/A self recover mre N/A mre N/A N/A N/A N/A self input consume N/A getLine N/A N/A self N/A N/A N/A N/A N/A self input line N/A getCharPositionInLine N/A N/A self N/A N/A N/A N/A N/A self input charPositionInLine N/A getCharIndex N/A N/A self N/A N/A N/A What is the index of the current character of lookahead? N/A N/A N/A N/A self input index N/A getText N/A N/A self N/A N/A N/A 
        Return the text matched so far for the current token or any
        text override.
         N/A N/A N/A N/A self _state text None N/A N/A N/A N/A self _state text N/A N/A N/A N/A self input substring N/A N/A self _state tokenStartCharIndex N/A N/A N/A self getCharIndex 1 N/A setText N/A N/A self text N/A N/A N/A 
        Set the complete text of this token; it wipes any previous
        changes to the text.
         N/A N/A N/A self _state text text N/A N/A text N/A property getText setText reportError N/A N/A self e N/A N/A N/A N/A N/A self displayRecognitionError N/A self tokenNames e N/A getErrorMessage N/A N/A self e tokenNames N/A N/A N/A msg None N/A N/A isinstance e MismatchedTokenException N/A N/A msg N/A N/A N/A mismatched character  N/A N/A self getCharErrorDisplay N/A e c  expecting  N/A N/A self getCharErrorDisplay N/A e expecting N/A N/A N/A isinstance e NoViableAltException N/A N/A msg N/A no viable alternative at character  N/A N/A self getCharErrorDisplay N/A e c N/A N/A N/A isinstance e EarlyExitException N/A N/A msg N/A required (...)+ loop did not match anything at character  N/A N/A self getCharErrorDisplay N/A e c N/A N/A N/A isinstance e MismatchedNotSetException N/A N/A msg N/A N/A N/A mismatched character  N/A N/A self getCharErrorDisplay N/A e c  expecting set  N/A repr N/A e expecting N/A N/A N/A isinstance e MismatchedSetException N/A N/A msg N/A N/A N/A mismatched character  N/A N/A self getCharErrorDisplay N/A e c  expecting set  N/A repr N/A e expecting N/A N/A N/A isinstance e MismatchedRangeException N/A N/A msg N/A N/A N/A N/A N/A mismatched character  N/A N/A self getCharErrorDisplay N/A e c  expecting set  N/A N/A self getCharErrorDisplay N/A e a .. N/A N/A self getCharErrorDisplay N/A e b N/A N/A msg N/A N/A BaseRecognizer getErrorMessage self e tokenNames N/A msg N/A getCharErrorDisplay N/A N/A self c N/A N/A N/A N/A c EOF N/A N/A c <EOF> N/A N/A repr c N/A recover N/A N/A self re N/A N/A N/A 
        Lexers can normally match any char in it's vocabulary after matching
        a token, so do the easy thing and just kill a character and hope
        it all works out.  You can instead use the rule invocation stack
        to do sophisticated error recovery if you are in a fragment rule.
         N/A N/A N/A N/A self input consume N/A traceIn N/A N/A self ruleName ruleIndex N/A N/A N/A inputSymbol N/A %s line=%d:%s N/A N/A N/A N/A self input LT 1 N/A N/A self getLine N/A N/A self getCharPositionInLine N/A N/A N/A BaseRecognizer traceIn self ruleName ruleIndex inputSymbol N/A traceOut N/A N/A self ruleName ruleIndex N/A N/A N/A inputSymbol N/A %s line=%d:%s N/A N/A N/A N/A self input LT 1 N/A N/A self getLine N/A N/A self getCharPositionInLine N/A N/A N/A BaseRecognizer traceOut self ruleName ruleIndex inputSymbol N/A N/A Parser N/A BaseRecognizer N/A N/A 
    @brief Baseclass for generated parser classes.
     __init__ N/A N/A self lexer state N/A None N/A N/A N/A N/A BaseRecognizer __init__ self state N/A N/A N/A self setTokenStream lexer N/A reset N/A N/A self N/A N/A N/A N/A N/A BaseRecognizer reset self N/A N/A N/A self input None N/A N/A N/A N/A N/A self input seek 0 N/A getCurrentInputSymbol N/A N/A self input N/A N/A N/A N/A N/A input LT 1 N/A getMissingSymbol N/A N/A self input e expectedTokenType follow N/A N/A N/A N/A expectedTokenType EOF N/A N/A tokenText <missing EOF> N/A N/A tokenText N/A N/A <missing  N/A N/A self tokenNames N/A expectedTokenType > N/A t N/A CommonToken type expectedTokenType text tokenText N/A current N/A N/A input LT 1 N/A N/A N/A current type EOF N/A N/A current N/A N/A input LT -1 N/A N/A current None N/A N/A N/A t line N/A current line N/A N/A t charPositionInLine N/A current charPositionInLine N/A N/A t channel DEFAULT_CHANNEL N/A t N/A setTokenStream N/A N/A self input N/A N/A N/A Set the token stream and reset the parser N/A N/A self input None N/A N/A N/A self reset N/A N/A self input input N/A getTokenStream N/A N/A self N/A N/A N/A N/A self input N/A getSourceName N/A N/A self N/A N/A N/A N/A N/A N/A self input getSourceName N/A traceIn N/A N/A self ruleName ruleIndex N/A N/A N/A N/A N/A BaseRecognizer traceIn self ruleName ruleIndex N/A N/A N/A self input LT 1 N/A traceOut N/A N/A self ruleName ruleIndex N/A N/A N/A N/A N/A BaseRecognizer traceOut self ruleName ruleIndex N/A N/A N/A self input LT 1 N/A N/A RuleReturnScope N/A object N/A N/A 
    Rules can return start/stop info as well as possible trees and templates.
     getStart N/A N/A self N/A N/A N/A Return the start token or tree. N/A None N/A getStop N/A N/A self N/A N/A N/A Return the stop token or tree. N/A None N/A getTree N/A N/A self N/A N/A N/A Has a value potentially if output=AST. N/A None N/A getTemplate N/A N/A self N/A N/A N/A Has a value potentially if output=template. N/A None N/A N/A ParserRuleReturnScope N/A RuleReturnScope N/A N/A 
    Rules that return more than a single value must return an object
    containing all the values.  Besides the properties defined in
    RuleLabelScope.predefinedRulePropertiesScope there may be user-defined
    return values.  This class simply defines the minimum properties that
    are always defined and methods to access the others that might be
    available depending on output option such as template and tree.

    Note text is not an actual property of the return value, it is computed
    from start and stop using the input stream's toString() method.  I
    could add a ctor to this so that we can pass in and store the input
    stream, but I'm not sure we want to do that.  It would seem to be undefined
    to get the .text property anyway if the rule matches tokens from multiple
    input streams.

    I do not use getters for fields of objects that are used simply to
    group values such as this aggregate.  The getters/setters are there to
    satisfy the superclass interface.
     __init__ N/A N/A self N/A N/A N/A N/A self start None N/A N/A self stop None N/A getStart N/A N/A self N/A N/A N/A N/A self start N/A getStop N/A N/A self N/A N/A N/A N/A self stop N/A N/A