V}Oc@sdZddlZddlZddlmZmZddlmZmZm Z m Z m Z ddl m Z mZmZmZmZmZmZmZmZmZmZmZddlmZmZmZddlmZmZm Z de!fd YZ"d e!fd YZ#d e!fd YZ$de#e$fdYZ%de#fdYZ&de!fdYZ'de'fdYZ(dS(sANTLR3 runtime packageiN(truntime_versiontruntime_version_str(tDEFAULT_CHANNELtHIDDEN_CHANNELtEOFtEOR_TOKEN_TYPEtINVALID_TOKEN_TYPE( tRecognitionExceptiontMismatchedTokenExceptiontMismatchedRangeExceptiontMismatchedTreeNodeExceptiontNoViableAltExceptiontEarlyExitExceptiontMismatchedSetExceptiontMismatchedNotSetExceptiontFailedPredicateExceptiontBacktrackingFailedtUnwantedTokenExceptiontMissingTokenException(t CommonTokent EOF_TOKENt SKIP_TOKEN(tsett frozensettreversedtRecognizerSharedStatecBseZdZdZRS(sH 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. cCsyg|_t|_d|_d|_d|_d|_d|_d|_ d|_ d|_ d|_ d|_ d|_dS(Nii(t followingtFalset errorRecoverytlastErrorIndext backtrackingtNonetruleMemot syntaxErrorsttokenttokenStartCharIndexttokenStartLinettokenStartCharPositionInLinetchannelttypettext(tself((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyt__init__:s            (t__name__t __module__t__doc__R*(((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR0stBaseRecognizercBseZdZdZdZeZeZd-Z d.Z dZ d-dZ dZd Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%d Z&d!Z'e(e'Z'd"Z)d#Z*d$Z+d%Z,d&Z-d'Z.d(Z/d)Z0d*Z1d+Z2d,Z3RS(/s @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. iiiiis3.0.1cCsd|_|dkr!t}n||_|jtkr[td|jt|jfn@|jdkr|jtkrtd|jt|jfndS(NsANTLR version mismatch: The recognizer has been generated by V%s, but this runtime is V%s. Please use the V%s runtime or higher.iiisvANTLR version mismatch: The recognizer has been generated by V%s, but this runtime is V%s. Please use the V%s runtime.(iiii( RtinputRt_statet antlr_versionRt RuntimeErrortantlr_version_strR(R)tstate((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR*s"    cCs ||_dS(N(R/(R)R/((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytsetInputscCst|jdkrdSg|j_t|j_d|j_d|j_d|j_|jjdk rpi|j_ndS(sT reset the parser's state; subclasses must rewinds the input stream Nii( R0RRRRRR!RR (R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytresets     cCsx|j|}|jjd|krD|jjt|j_|S|jjdkr_tn|j |||}|S(sD 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 recoverFromMismatchedToken() and have it throw an exception. See TreeParser.recoverFromMismatchedToken(). This way 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. ii( tgetCurrentInputSymbolR/tLAtconsumeRR0RRRtrecoverFromMismatchedToken(R)R/tttypetfollowt matchedSymbol((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytmatchs   cCst|j_|jjdS(sMatch the wildcard: in a symbolN(RR0RR/R9(R)R/((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytmatchAnys cCs|jd|kS(Ni(R8(R)R/R;((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytmismatchIsUnwantedTokenscCs|dkrtSt|krc|j}||B}t|jjdkrc|ttg}qcn|jd|kst|krt StS(Nii( RRRt!computeContextSensitiveRuleFOLLOWtlenR0RRR8tTrue(R)R/R<tviableTokensFollowingThisRule((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytmismatchIsMissingTokens    !cCsE|jjrdS|jjd7_t|j_|j|j|dS(stReport 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. Ni(R0RR!RCtdisplayRecognitionErrort tokenNames(R)te((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyt reportErrors   cCs:|j|}|j||}|j|d|dS(Nt (tgetErrorHeadertgetErrorMessagetemitErrorMessage(R)RGRHthdrtmsg((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRF0scCslt|tr_d}|jtkr-d}n|j|j}d|j|j|f}n t|trd}|jtkrd}n|j|j}d||j|jf}nt|t rd}|jtkrd}n|j|j}d|j|jd|}nOt|t rld}|jtkrFd}n|j|j}d|j |f}nt|t rd|j|j}nt|t rd |j|j}nt|trd|j|jd t|j}nst|tr.d|j|jd t|j}n:t|tr\d |jd |jd }n t|}|S(s 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. s Rs extraneous input %s expecting %ssmissing %s at %ssmismatched input s expecting s%mismatched tree node: %s expecting %ssno viable alternative at input s5required (...)+ loop did not match anything at input s expecting set srule s failed predicate: {s}?(t isinstanceRt expectingRRGtgetTokenErrorDisplaytgetUnexpectedTokenRR"RR tnodeR R R treprRRtruleNamet predicateTexttstr(R)RHRGt tokenNameRO((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRL6sT    ! ** cCs |jjS(s. 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() (R0R!(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytgetNumberOfSyntaxErrorss cCsd|j|jfS(sY What is the error header, normally line/character position information? s line %d:%d(tlinetcharPositionInLine(R)RH((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRKscCsK|j}|dkrA|jtkr-d}qAd|jd}nt|S(s 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. stN(R(RR'RRU(R)ttts((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRRs   cCstjj|ddS(s6Override this method to change where error messages gos N(tsyststderrtwrite(R)RO((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRMscCsk|jj|jkr%|jn|j|j_|j}|j|j|||jdS(sb 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(R0RtindexR9tcomputeErrorRecoverySett beginResynct consumeUntilt endResync(R)R/tret followSet((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytrecovers    cCsdS(s A hook to listen in on the token consumption during error recovery. The DebugParser subclasses this to fire events to the listenter. N((R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRfscCsdS(s A hook to listen in on the token consumption during error recovery. The DebugParser subclasses this to fire events to the listenter. N((R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRhscCs |jtS(s 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 \ 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. (tcombineFollowsR(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRes^cCs |jtS(s& 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. (RlRC(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRAZs7cCs{t}xkttt|jjD]K\}}||O}|r(t|kro|dkrp|jtqpqsPq(q(W|S(Ni(RRtlistt enumerateR0RRtremove(R)texactRjtidxtlocalFollowSet((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRls +   cCsd}|j||rot||}|j|j|j|j||j|}|j|S|j||r|j ||||}t |||}|j||St ||}|dS(snAttempt 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( RR@RRfR9RhRIR7REtgetMissingSymbolRR(R)R/R;R<RHR=tinserted((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR:s"      cCs?|j||r5|j||j||t|S|dS(sNot currently usedN(RERIRsR(R)R/RHR<((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytrecoverFromMismatchedSets cCsdS(s 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(R(R)R/((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR7s cCsdS(sQConjure 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(R(R)R/RHtexpectedTokenTypeR<((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRsscCsrt|ttfs't|g}n|jd}x5|tkrm||krm|j|jd}q9WdS(s Consume tokens until one matches the given token or token set tokenTypes can be a single token type or a set of token types iN(RPRRR8RR9(R)R/t tokenTypesR;((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRg+s  cCs|j|jS(sG Return List 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(.__module__) where is the class of the generated recognizer, e.g. the superclass of self. (t_getRuleInvocationStackR,(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytgetRuleInvocationStack<scCsg}xttjD]n}|dj}tj|}|dkrMqn|j|krbqn|jdkrwqn|j|jqW|S(sJ 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 it nextTokensN(s nextTokens( Rtinspecttstacktf_codet getmoduleRR+tco_nametappend(tclstmoduletrulestframetcodetcodeMod((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRxUs  cCs |jjS(N(R0R(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytgetBacktrackingLevelzscCs||j_dS(N(R0R(R)tn((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytsetBacktrackingLevel}scCs |jjS(s4Return whether or not a backtracking attempt failed.(R0tfailed(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRscCs|jS(sFor debugging and other purposes, might want the grammar name. Have ANTLR generate an implementation for this method. (tgrammarFileName(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytgetGrammarFileNamescCs tdS(N(tNotImplementedError(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyt getSourceNamescCs*|dkrdSg|D]}|j^qS(swA convenience method for use most often with template rewrites. Convert a List to List N(RR((R)ttokensR"((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyt toStringss cCsB||jjkr%i|jj|R?R@RERIRFRLRZRKRRRMRkRfRhReRARlR:RuR7RsRgRyRxt classmethodRRRRRRRRRRR(((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR.~s^ "         i     a :  A  (   "         t TokenSourcecBs)eZdZdZdZdZRS(sk @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. cCs tdS(sReturn 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(R(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRzscCs|S(sThe TokenSource is an interator. The iteration will not include the final EOF token, see also the note for the next() method. ((R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyt__iter__ scCs4|j}|dks'|jtkr0tn|S(sReturn 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(RzRR'Rt StopIteration(R)R"((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytnexts  (R+R,R-RzRR(((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRs tLexercBseZdZddZdZdZdZdZdZ dZ ddZ d Z d Z d Zd Zd ZdZdZdZeeeZdZdZdZdZdZdZRS(s' @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. cCs*tj||tj|||_dS(N(R.R*RR/(R)R/R4((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR*/s cCstj||jdk r/|jjdn|jdkrBdSd|j_t|j_t |j_ d|j_ d|j_ d|j_ d|j_dS(Nii(R.R6R/RRR0R"RR'RR&R#R$R%R((R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR67s       cCs!xd|j_t|j_|jj|j_|jj|j_ |jj |j_ d|j_ |jj dtkr|tSyO|j|jjdkr|jn|jjtkrwn|jjSWqtk r}|j||j|qtk r}|j|qXqdS(sb Return a token from this source; i.e., match a token on the char stream. iN(RR0R"RR&R/RdR#R\R%R[R$R(R8RRtmTokenstemitRR RIRkR(R)Ri((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRzLs*      cCst|j_dS(sG 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(RR0R"(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytskipps cCs tdS(s<This is the lexer entry point that sets instance var 'token'N(R(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR|scCs d|_|j||_dS(s'Set the char stream and reset the lexerN(RR/R6(R)R/((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyt setCharStreams  cCs |jjS(N(R/R(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRsc Cs|dkrtd|jd|jjd|jjd|jjd|jd}|jj|_ |jj |_ |jj |_ n||j_ |S(s 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(). R/R'R&tstarttstopiN(RRR/R0R'R&R#t getCharIndexR$R[R(R%R\R"(R)R"((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRs      cCst|trx|D]t}|jjdt|kr}|jjdkrUtnt||j}|j ||n|jj qWnn|jjd|kr|jjdkrtntt ||j}|j ||n|jj dS(Nii( RPt basestringR/R8tordR0RRRRkR9tunichr(R)R`tctmte((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR>s        cCs|jjdS(N(R/R9(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR?scCs|jjd|ks0|jjd|kr|jjdkrKtntt|t||j}|j||n|jjdS(Nii( R/R8R0RRR RRkR9(R)tatbtmre((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyt matchRanges0 !  cCs |jjS(N(R/R[(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytgetLinescCs |jjS(N(R/R\(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytgetCharPositionInLinescCs |jjS(s8What is the index of the current character of lookahead?(R/Rd(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRscCs?|jjdk r|jjS|jj|jj|jdS(sd Return the text matched so far for the current token or any text override. iN(R0R(RR/t substringR#R(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytgetTexts    cCs||j_dS(si Set the complete text of this token; it wipes any previous changes to the text. N(R0R((R)R(((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pytsetTextscCs|j|j|dS(N(RFRG(R)RH((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRIs cCsmd}t|trBd|j|jd|j|j}n't|trjd|j|j}nt|trd|j|j}nt|trd|j|jdt |j}nt|t rd|j|jdt |j}net|t rTd|j|jd|j|j d|j|j }ntj|||}|S(Nsmismatched character s expecting s#no viable alternative at character s9required (...)+ loop did not match anything at character s expecting set s..(RRPRtgetCharErrorDisplayRRQR R RRUR R RRR.RL(R)RHRGRO((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRL s"-**AcCs|tkrd}nt|S(Ns(RRU(R)R((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR4s  cCs|jjdS(s2 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(R/R9(R)Ri((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRk:scCsEd|jjd|j|jf}tj||||dS(Ns %s line=%d:%si(R/tLTRRR.R(R)RVRR((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyREs cCsEd|jjd|j|jf}tj||||dS(Ns %s line=%d:%si(R/RRRR.R(R)RVRR((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyRNs N(R+R,R-RR*R6RzRRRRRR>R?RRRRRRtpropertyR(RIRLRRkRR(((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR%s0   $             +  tParsercBsbeZdZd dZdZdZdZdZdZ dZ dZ d Z RS( s8 @brief Baseclass for generated parser classes. cCs!tj|||j|dS(N(R.R*tsetTokenStream(R)tlexerR4((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR*]scCs3tj||jdk r/|jjdndS(Ni(R.R6R/RR(R)((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR6cs cCs |jdS(Ni(R(R)R/((s[/afs/athena.mit.edu/user/x/a/xavid/.local/lib/python2.7/site-packages/antlr3/recognizers.pyR7iscCs|tkrd}nd|j|d}td|d|}|jd}|jtkro|jd}n|dk r|j|_|j|_nt|_ |S(Ns s s$  (RNu54>