python.stg

antlr最新版本V3源代码

<endif>
<endif>
>>

/** How to generate a rule in the lexer; naked blocks are used for
 *  fragment rules.
 */
lexerRule(ruleName,nakedBlock,ruleDescriptor,block,memoize) ::= <<
# $ANTLR start <ruleName>
def m<ruleName>(self, <ruleDescriptor.parameterScope:parameterScope(scope=it)>):
<if(trace)>
    self.traceIn("<ruleName>", <ruleDescriptor.index>)<\n>
<endif>
    <ruleDeclarations()>
    try:
<if(nakedBlock)>
        <ruleMemoization(name=ruleName)>
        <lexerRuleLabelDefs()>
        <ruleDescriptor.actions.init>
        <block><\n>
<else>
        self.type = <ruleName>

        <ruleMemoization(name=ruleName)>
        <lexerRuleLabelDefs()>
        <ruleDescriptor.actions.init>
        <block>
        <ruleCleanUp()>
        <(ruleDescriptor.actions.after):execAction()>
<endif>

    finally:
<if(trace)>
        self.traceOut("<ruleName>", <ruleDescriptor.index>)<\n>
<endif>
	<memoize()>
        pass

# $ANTLR end <ruleName>


>>

/** How to generate code for the implicitly-defined lexer grammar rule
 *  that chooses between lexer rules.
 */
tokensRule(ruleName,nakedBlock,args,block,ruleDescriptor) ::= <<
def mTokens(self):
    <block><\n>


>>

// S U B R U L E S

/** A (...) subrule with multiple alternatives */
block(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
# <fileName>:<description>
alt<decisionNumber> = <maxAlt>
<decls>
<@predecision()>
<decision>
<@postdecision()>
<@prebranch()>
<alts:altSwitchCase(); separator="\nel">
<@postbranch()>
>>

/** A rule block with multiple alternatives */
ruleBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
# <fileName>:<description>
alt<decisionNumber> = <maxAlt>
<decls>
<@predecision()>
<decision>
<@postdecision()>
<alts:altSwitchCase(); separator="\nel">
>>

ruleBlockSingleAlt(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,description) ::= <<
# <fileName>:<description>
<decls>
<@prealt()>
<alts>
<@postalt()>
>>

/** A special case of a (...) subrule with a single alternative */
blockSingleAlt(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,description) ::= <<
# <fileName>:<description>
<decls>
<@prealt()>
<alts>
<@postalt()>
>>

/** A (..)+ block with 1 or more alternatives */
positiveClosureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
# <fileName>:<description>
cnt<decisionNumber> = 0
<decls>
<@preloop()>
while True: #loop<decisionNumber>
    alt<decisionNumber> = <maxAlt>
    <@predecision()>
    <decision>
    <@postdecision()>
    <alts:altSwitchCase(); separator="\nel">
    else:
        if cnt<decisionNumber> >= 1:
            break #loop<decisionNumber>

        <ruleBacktrackFailure()>
        eee = EarlyExitException(<decisionNumber>, self.input)
        <@earlyExitException()>
        raise eee

    cnt<decisionNumber> += 1

<@postloop()>
>>

positiveClosureBlockSingleAlt ::= positiveClosureBlock

/** A (..)* block with 1 or more alternatives */
closureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
# <fileName>:<description>
<decls>
<@preloop()>
while True: #loop<decisionNumber>
    alt<decisionNumber> = <maxAlt>
    <@predecision()>
    <decision>
    <@postdecision()>
    <alts:altSwitchCase(); separator="\nel">
    else:
        break #loop<decisionNumber>

<@postloop()>
>>

closureBlockSingleAlt ::= closureBlock

/** Optional blocks (x)? are translated to (x|) by before code generation
 *  so we can just use the normal block template
 */
optionalBlock ::= block

optionalBlockSingleAlt ::= block

/** A case in a switch that jumps to an alternative given the alternative
 *  number.  A DFA predicts the alternative and then a simple switch
 *  does the jump to the code that actually matches that alternative.
 */
altSwitchCase() ::= <<
if alt<decisionNumber> == <i>:
    <@prealt()>
    <it>
>>

/** An alternative is just a list of elements; at outermost level */
alt(elements,altNum,description,autoAST,outerAlt) ::= <<
# <fileName>:<description>
<@declarations()>
<elements:element()>
<@cleanup()>
>>

// E L E M E N T S

/** Dump the elements one per line */
element() ::= <<
<@prematch()>
<it.el><\n>
>>

/** match a token optionally with a label in front */
tokenRef(token,label,elementIndex) ::= <<
<if(label)>
<label> = self.input.LT(1)<\n>
<endif>
self.match(self.input, <token>, self.FOLLOW_<token>_in_<ruleName><elementIndex>)
<checkRuleBacktrackFailure()>
>>

/** ids+=ID */
tokenRefAndListLabel(token,label,elementIndex) ::= <<
<tokenRef(...)>
<listLabel(...)>
>>

listLabel(label, elem) ::= <<
if list_<label> is None:
    list_<label> = []
list_<label>.append(<label>)<\n>
>>

/** match a character */
charRef(char,label) ::= <<
<if(label)>
<label> = self.input.LA(1)<\n>
<endif>
self.match(<char>)
<checkRuleBacktrackFailure()>
>>

/** match a character range */
charRangeRef(a,b,label) ::= <<
<if(label)>
<label> = self.input.LA(1)<\n>
<endif>
self.matchRange(<a>, <b>)
<checkRuleBacktrackFailure()>
>>

/** For now, sets are interval tests and must be tested inline */
matchSet(s,label,elementIndex,postmatchCode="") ::= <<
<if(label)>
<label> = self.input.LT(1)<\n>
<endif>
if <s>:
    self.input.consume();
    <postmatchCode>
<if(!LEXER)>
    self.errorRecovery = False<\n>
<endif>
<if(backtracking)>
    self.failed = False<\n>
<endif>

else:
    <ruleBacktrackFailure()>
    mse = MismatchedSetException(None, self.input)
    <@mismatchedSetException()>
<if(LEXER)>
    self.recover(mse)<\n>
<else>
    self.recoverFromMismatchedSet(
        self.input, mse, self.FOLLOW_set_in_<ruleName><elementIndex>
        )<\n>
<endif>
    raise mse
<\n>
>>

matchSetAndListLabel(s,label,elementIndex,postmatchCode) ::= <<
<matchSet(...)>
<listLabel(...)>
>>

/** Match a string literal */
lexerStringRef(string,label) ::= <<
<if(label)>
<label>Start = self.getCharIndex()
self.match(<string>)
<checkRuleBacktrackFailure()>
<label> = CommonToken(input=self.input, type=INVALID_TOKEN_TYPE, channel=DEFAULT_CHANNEL, start=<label>Start, stop=self.getCharIndex()-1)
<else>
self.match(<string>)
<checkRuleBacktrackFailure()><\n>
<endif>
>>

wildcard(label,elementIndex) ::= <<
<if(label)>
<label> = self.input.LT(1)<\n>
<endif>
self.matchAny(self.input)
<checkRuleBacktrackFailure()>
>>

wildcardAndListLabel(label,elementIndex) ::= <<
<wildcard(...)>
<listLabel(...)>
>>

/** Match . wildcard in lexer */
wildcardChar(label, elementIndex) ::= <<
<if(label)>
<label> = self.input.LA(1)<\n>
<endif>
self.matchAny()
<checkRuleBacktrackFailure()>
>>

wildcardCharListLabel(label, elementIndex) ::= <<
<wildcardChar(...)>
<listLabel(...)>
>>

/** Match a rule reference by invoking it possibly with arguments
 *  and a return value or values.
 */
ruleRef(rule,label,elementIndex,args) ::= <<
self.following.append(self.FOLLOW_<rule>_in_<ruleName><elementIndex>)
<if(label)>
<label> = self.<rule>(<args; separator=", ">)<\n>
<else>
self.<rule>(<args; separator=", ">)<\n>
<endif>
self.following.pop()
<checkRuleBacktrackFailure()>
>>

/** ids+=rule */
ruleRefAndListLabel(rule,label,elementIndex,args) ::= <<
<ruleRef(...)>
<listLabel(...)>
>>

/** A lexer rule reference */
lexerRuleRef(rule,label,args,elementIndex) ::= <<
<if(label)>
<label>Start<elementIndex> = self.getCharIndex()
self.m<rule>(<args; separator=", ">)
<checkRuleBacktrackFailure()>
<label> = CommonToken(
    input=self.input, 
    type=INVALID_TOKEN_TYPE,
    channel=DEFAULT_CHANNEL,
    start=<label>Start<elementIndex>,
    stop=self.getCharIndex()-1
    )
<else>
self.m<rule>(<args; separator=", ">)
<checkRuleBacktrackFailure()>
<endif>
>>

/** i+=INT in lexer */
lexerRuleRefAndListLabel(rule,label,args,elementIndex) ::= <<
<lexerRuleRef(...)>
<listLabel(elem=label,...)>
>>

/** EOF in the lexer */
lexerMatchEOF(label,elementIndex) ::= <<
<if(label)>
<label>Start<elementIndex> = self.getCharIndex()
self.match(EOF)
<checkRuleBacktrackFailure()>
<label> = CommonToken(input=self.input, type=EOF, channel=DEFAULT_CHANNEL, start=<label>Start<elementIndex>, stop=self.getCharIndex()-1)
<else>
self.match(EOF)
<checkRuleBacktrackFailure()>
<endif>
>>

/** match ^(root children) in tree parser */
tree(root, actionsAfterRoot, children, nullableChildList) ::= <<
<root:element()>
<actionsAfterRoot:element()>
<if(nullableChildList)>
if self.input.LA(1) == DOWN:
    self.match(self.input, DOWN, None)
    <checkRuleBacktrackFailure()>
    <children:element()>
    self.match(self.input, UP, None)
    <checkRuleBacktrackFailure()>

<else>
self.match(self.input, DOWN, None)
<checkRuleBacktrackFailure()>
<children:element()>
self.match(self.input, UP, None)
<checkRuleBacktrackFailure()>
<endif>
>>

/** Every predicate is used as a validating predicate (even when it is
 *  also hoisted into a prediction expression).
 */
validateSemanticPredicate(pred,description) ::= <<
if not (<evalPredicate(...)>):
    <ruleBacktrackFailure()>
    raise FailedPredicateException(self.input, "<ruleName>", "<description>")

>>

// F i x e d  D F A  (if-then-else)

dfaState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
LA<decisionNumber>_<stateNumber> = self.input.LA(<k>)<\n>
<edges; separator="\nel">
else:
<if(eotPredictsAlt)>
    alt<decisionNumber> = <eotPredictsAlt>
<else>
    <ruleBacktrackFailure()>
    nvae = NoViableAltException("<description>", <decisionNumber>, <stateNumber>, self.input)<\n>
    <@noViableAltException()>
    raise nvae<\n>
<endif>
>>

/** Same as a normal DFA state except that we don't examine lookahead
 *  for the bypass alternative.  It delays error detection but this
 *  is faster, smaller, and more what people expect.  For (X)? people
 *  expect "if ( LA(1)==X ) match(X);" and that's it.
 */
dfaOptionalBlockState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
LA<decisionNumber>_<stateNumber> = self.input.LA(<k>)<\n>
<edges; separator="\nel">
>>

/** A DFA state that is actually the loopback decision of a closure
 *  loop.  If end-of-token (EOT) predicts any of the targets then it
 *  should act like a default clause (i.e., no error can be generated).
 *  This is used only in the lexer so that for ('a')* on the end of a rule
 *  anything other than 'a' predicts exiting.
 */
dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
LA<decisionNumber>_<stateNumber> = self.input.LA(<k>)<\n>
<edges; separator="\nel"><\n>
<if(eotPredictsAlt)>
<if(!edges)>
alt<decisionNumber> = <eotPredictsAlt> <! if no edges, don't gen ELSE !>
<else>
else:
    alt<decisionNumber> = <eotPredictsAlt>
<\n>
<endif>
<endif>
>>

/** An accept state indicates a unique alternative has been predicted */
dfaAcceptState(alt) ::= "alt<decisionNumber> = <alt>"