org.antlr.codegen.templates.ObjC.ObjC.stg Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of analytics-plugin Show documentation
Kill Bill Analytics plugin
There is a newer version: 8.1.2
/*
 [The "BSD licence"]
 Copyright (c) 2006, 2007 Kay Roepke 2010 Alan Condit
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:
 1. Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
 3. The name of the author may not be used to endorse or promote products
    derived from this software without specific prior written permission.

 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/*
 *  Template group file for the Objective C code generator.
 *  Heavily based on Java.stg
 *
 *  Written by Kay Roepke 
 *  Modified by Alan Condit 
 *
 *  This file is part of ANTLR and subject to the same license as ANTLR itself.
 */

group ObjC implements ANTLRCore;

objcTypeInitMap ::= [
    "int"           : "0",              // Integers     start out being 0
    "long"          : "0",              // Longs        start out being 0
    "float"         : "0.0",            // Floats       start out being 0
    "double"        : "0.0",            // Doubles      start out being 0
    "BOOL"          : "NO",             // Booleans     start out being Antlr ObjC for false
    "byte"          : "0",              // Bytes        start out being 0
    "short"         : "0",              // Shorts       start out being 0
    "char"          : "0",              // Chars        start out being 0
    "id"            : "nil",            // ids          start out being nil
    default         : "nil"             // anything other than an atomic type
]

className() ::= "LexerTreeParser!>"
leadIn(type) ::=
<<
/** \file
 *  This  file was generated by $ANTLR version 
 *
 *     -  From the grammar source file : 
 *     -                            On : 

 *     -                 for the lexer : Lexer


 *     -                for the parser : Parser


 *     -           for the tree parser : TreeParser

 *
 * Editing it, at least manually, is not wise. 
 *
 * ObjC language generator and runtime by Alan Condit, acondit|hereisanat|ipns|dotgoeshere|com.
 *
 *
>>

/** The overall file structure of a recognizer; stores methods for rules
 *  and cyclic DFAs plus support code.
 */
outputFile( LEXER,
            PARSER,
            TREE_PARSER,
            actionScope,
            actions,
            docComment,
            recognizer,
            name,
            tokens,
            tokenNames,
            rules,
            cyclicDFAs,
            bitsets,
            buildTemplate,
            buildAST,
            rewriteMode,
            profile,
            backtracking,
            synpreds,
            memoize,
            numRules,
            fileName,
            ANTLRVersion,
            generatedTimestamp,
            trace,
            scopes,
            superClass,
            literals
            ) ::=
<<

*/
// [The "BSD licence"]
// Copyright (c) 2010 Alan Condit
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. The name of the author may not be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// $ANTLR   



/* =============================================================================
 * This is what the grammar programmer asked us to put at the top of every file.
 */

/* End of Header action.
 * =============================================================================
 */


/* -----------------------------------------
 * Include the ANTLR3 generated header file.
 */
#import "LexerTreeParser!>.h"

/* ----------------------------------------- */




/** String literals used by  that we must do things like MATCHS() with.
 *  C will normally just lay down 8 bit characters, and you can use L"xxx" to
 *  get wchar_t, but wchar_t is 16 bits on Windows, which is not UTF32 and so
 *  we perform this little trick of defining the literals as arrays of UINT32
 *  and passing in the address of these.
 */
[]  = ;}; separator="\n">



/* ============================================================================= */

/* =============================================================================
 * Start of recognizer
 */



/* End of code
 * =============================================================================
 */

>>
headerFileExtension() ::= ".h"

headerFile( LEXER,
            PARSER,
            TREE_PARSER,
            actionScope,
            actions,
            docComment,
            recognizer,
            name,
            tokens,
            tokenNames,
            rules,
            cyclicDFAs,
            bitsets,
            buildTemplate,
            buildAST,
            rewriteMode,
            profile,
            backtracking,
            synpreds,
            memoize,
            numRules,
            fileName,
            ANTLRVersion,
            generatedTimestamp,
            trace,
            scopes,
            superClass,
            literals
          ) ::=
<<
// $ANTLR   

<@imports>

/* =============================================================================
 * Standard antlr3 OBJC runtime definitions
 */
#import \
#import "antlr3.h"
/* End of standard antlr3 runtime definitions
 * =============================================================================
 */

<@end>











>>

lexerHeaderFile( LEXER,
            PARSER,
            TREE_PARSER,
            actionScope,
            actions,
            docComment,
            recognizer,
            name,
            tokens,
            tokenNames,
            rules,
            cyclicDFAs,
            bitsets,
            buildTemplate,
            profile,
            backtracking,
            synpreds,
            memoize,
            numRules,
            fileName,
            ANTLRVersion,
            generatedTimestamp,
            trace,
            scopes,
            superClass="ANTLRLexer"
            ) ::=
<<

/* Start cyclicDFAInterface */


#pragma mark Rule return scopes start
}>
}>
#pragma mark Rule return scopes end
#pragma mark Tokens
 }; separator="\n">
 <@superClassName>: <@end> { !>
@interface  <@superClassName>: <@end> { // line 283
 *dfa;}; separator="\n">
Selector;}; separator="\n">
// start of actions.lexer.memVars

// start of action-actionScope-memVars

}
+ ( *)newWithCharStream:(id\)anInput;


}>)m_fragment; }; separator="\n"><\n>
_fragment;}; separator="\n"><\n> !>
@end /* end of  interface */<\n>
>>

headerReturnScope(ruleDescriptor) ::= ""
headerReturnType(ruleDescriptor) ::= <<


 void

 


 

>>
// Produce the lexer output
lexer(  grammar,
        name,
        tokens,
        scopes,
        rules,
        numRules,
        labelType="id",
        filterMode,
        superClass="ANTLRLexer"
        ) ::= <<


/** As per Terence: No returns for lexer rules! */
}>
}>
#pragma mark Rule return scopes end
!>
@implementation  // line 330

+ (void) initialize
{
    [ANTLRBaseRecognizer setGrammarFileName:@""];
}

+ (NSString *) tokenNameForType:(NSInteger)aTokenType
{
    return [[self getTokenNames] objectAtIndex:aTokenType];
}

+ ( *)newWithCharStream:(id\)anInput
{
    return [[ alloc] initWithCharStream:anInput];
}

- (id) initWithCharStream:(id\)anInput
{
    if ((self = [super initWithCharStream:anInput State:[ANTLRRecognizerSharedState newANTLRRecognizerSharedStateWithRuleLen:+1]]) != nil) {

        if ( state.ruleMemo == nil ) {
            state.ruleMemo = [[ANTLRRuleStack newANTLRRuleStackWithSize:+1] retain];
        }
        if ( [state.ruleMemo count] == 0 ) {
            // initialize the memoization cache - the indices are 1-based in the runtime code!
            
            for (NSInteger i = 0; i \< ; i++) {
                [state.ruleMemo addObject:[ANTLRHashRule newANTLRHashRuleWithLen:17]];
            }
        }

        };separator="\n">
         = [DFA newDFAWithRecognizer:self];}; separator="\n">
        
    }
    return self;
}

- (void) dealloc
{
     release];}; separator="\n">

    [super dealloc];
}

/* Start of actions.lexer.methods */

/* start methods() */
<@methods()>


- (void) reset
{
    
    [super reset];
}





/* Start of Rules */


@end /* end of  implementation line 397 */
>>

/** A override of Lexer.nextToken() that backtracks over mTokens() looking
 *  for matches.  No error can be generated upon error; just rewind, consume
 *  a token and then try again.  backtracking needs to be set as well.
 *  Make rule memoization happen only at levels above 1 as we start mTokens
 *  at backtracking==1.
 */
filteringNextToken() ::= <<
- (id\) nextToken
{
    while (YES) {
        if ( [input LA:1] == ANTLRCharStreamEOF ) {
            return [ANTLRCommonToken eofToken];
        }
        state.token = nil;
        state.channel = ANTLRTokenChannelDefault;
        state.tokenStartCharIndex = [input getIndex];
        state.tokenStartCharPositionInLine = [input getCharPositionInLine];
        state.tokenStartLine = [input getLine];
        state.text = nil;
        @try {
            NSInteger m = [input mark];
            state.backtracking = 1; /* means we won't throw slow exception */
            state.failed = NO;
            [self mTokens];
            state.backtracking = 0;
            /* mTokens backtracks with synpred at backtracking==2
               and we set the synpredgate to allow actions at level 1. */
            if ( state.failed == YES ) {
                [input rewind:m];
                [input consume]; /* advance one char and try again */
            } else {
                [self emit];
                return state.token;
            }
        }
        @catch (ANTLRRecognitionException *re) {
            // shouldn't happen in backtracking mode, but...
            [self reportError:re];
            [self recover:re];
        }
    }
}

- (void)memoize:(id\)anInput
      RuleIndex:(NSInteger)ruleIndex
     StartIndex:(NSInteger)ruleStartIndex
{
    if ( state.backtracking > 1 ) [super memoize:anInput RuleIndex:ruleIndex StartIndex:ruleStartIndex];
}

- (BOOL)alreadyParsedRule:(id\)anInput RuleIndex:(NSInteger)ruleIndex
{
    if ( state.backtracking > 1 ) return [super alreadyParsedRule:anInput RuleIndex:ruleIndex];
    return NO;
}
>>

actionGate() ::= "state.backtracking == 0"

filteringActionGate() ::= "state.backtracking == 1"

parserHeaderFile( LEXER,
            PARSER,
            TREE_PARSER,
            actionScope,
            actions,
            docComment,
            recognizer,
            name,
            tokens,
            tokenNames,
            rules,
            cyclicDFAs,
            bitsets,
            buildTemplate,
            profile,
            backtracking,
            synpreds,
            memoize,
            numRules,
            fileName,
            ANTLRVersion,
            generatedTimestamp,
            trace,
            scopes,
            superClass="ANTLRParser"
            ) ::=
<<
/* parserHeaderFile */

>>

treeParserHeaderFile( LEXER,
            PARSER,
            TREE_PARSER,
            actionScope,
            actions,
            docComment,
            recognizer,
            name,
            tokens,
            tokenNames,
            rules,
            cyclicDFAs,
            bitsets,
            buildTemplate,
            profile,
            backtracking,
            synpreds,
            memoize,
            numRules,
            fileName,
            ANTLRVersion,
            generatedTimestamp,
            trace,
            scopes,
            superClass="ANTLRTreeParser"
            ) ::= 
<<
/* treeParserHeaderFile */

>>

genericParserHeaderFile( LEXER,
            PARSER,
            TREE_PARSER,
            actionScope,
            actions,
            docComment,
            recognizer,
            name,
            tokens,
            tokenNames,
            rules,
            cyclicDFAs,
            bitsets,
            buildTemplate,
            profile,
            backtracking,
            synpreds,
            memoize,
            numRules,
            fileName,
            ANTLRVersion,
            generatedTimestamp,
            trace,
            scopes,
            superClass
            ) ::=
<<

typedef enum {
    ANTLR_EOF = -1,
    INVALID,
    EOR,
    DOWN,
    UP,
    MIN
} ANTLR3TokenType;


#pragma mark Tokens
 }; separator="\n">
#pragma mark Dynamic Global Scopes
}>
#pragma mark Dynamic Rule Scopes
}>
}>
#pragma mark Rule Return Scopes start
}>}>
#pragma mark Rule return scopes end
}>}>}>
#pragma mark Rule return scopes end
!>
 <@superClassName>: <@end> { !>
@interface  <@superClassName>: <@end> { /* line 572 */
// start of globalAttributeScopeMemVar
}><\n>
// start of action-actionScope-memVars

// start of ruleAttributeScopeMemVar
}><\n>
// Start of memVars
<@memVars()>

 *dfa;}; separator="\n">
Selector;}; separator="\n">
 }

// start of action-actionScope-methodsDecl


<@methodsdecl()>

}>)_fragment; }; separator="\n"><\n>
_fragment;}; separator="\n"><\n> !>

@end /* end of  interface */<\n>
>>

/** How to generate a parser */
genericParser(  grammar,
                name,
                scopes,
                tokens,
                tokenNames,
                rules,
                numRules,
                cyclicDFAs,          // parser init -- initializes the DFAs
                bitsets,
                inputStreamType,
                superClass="ANTLRParser",
                ASTLabelType="ANTLRCommonTree",
                labelType="id",
                members,
                rewriteElementType,
                filterMode
              ) ::= <<



#pragma mark Bitsets
_in_}, words64=it.bits)>

#pragma mark Dynamic Global Scopes
}>

#pragma mark Dynamic Rule Scopes

}>

#pragma mark Rule return scopes start
}>
}>

@implementation   // line 637

+ (void) initialize
{
    #pragma mark Bitsets
    _in_}, words64=it.bits)>
    [ANTLRBaseRecognizer setTokenNames:[[[NSArray alloc] initWithObjects:@"\", @"\", @"\", @"\", }; separator=", ", wrap="\n ">, nil] retain]];
    }>
}

+ ( *)new:()aStream
{

    return [[ alloc] initWithTokenStream:aStream];

    return [[ alloc] initWithStream:aStream];
<\n>
}


- (id) initWithTokenStream:()aStream
{
    if ((self = [super initWithTokenStream:aStream State:[[ANTLRRecognizerSharedState newANTLRRecognizerSharedStateWithRuleLen:+1] retain]]) != nil) {

- (id) initWithStream:()aStream
{
    if ((self = [super initWithStream:aStream State:[[ANTLRRecognizerSharedState newANTLRRecognizerSharedStateWithRuleLen:+1] retain]]) != nil) {
<\n>
         !>
         = [DFA newDFAWithRecognizer:self];}; separator="\n">
        }> !>
        }>
        /* start of actions-actionScope-init */
        
        /* start of init */
        <@init()>
    }
    return self;
}

- (void) dealloc
{
     release];}; separator="\n">
    }>
    
    <@dealloc()>
    [super dealloc];
}
// start actions.actionScope.methods

// start methods()
<@methods()>
// start rules


@end /* end of  implementation line 692 */<\n>
>>

parserCtorBody() ::= <<


state.ruleMemo = [[ANTLRRuleStack newANTLRRuleStack:+1] retain];<\n> 


 = ;}; separator="\n">
>>

parser( grammar,
        name,
        scopes,
        tokens,
        tokenNames,
        rules,
        numRules,
        bitsets,
        ASTLabelType="ANTLRCommonTree",
        superClass="ANTLRParser",
        labelType="ANTLRCommonToken",
        members={}
        ) ::= <<
", rewriteElementType="ANTLRCommonToken", ...)>
>>

treeParser( grammar,
        name,
        scopes,
        tokens,
        tokenNames,
        globalAction,
        rules,
        numRules,
        bitsets,
        ASTLabelType="ANTLRCommonTree",
        superClass={ANTLRTreeRewriterANTLRTreeFilterANTLRTreeParser},
        labelType="ANTLRCommonTree",
        members={},
        filterMode
        ) ::= <<
", rewriteElementType="Node", ...)>
>>

/** A simpler version of a rule template that is specific to the imaginary
 *  rules created for syntactic predicates.  As they never have return values
 *  nor parameters etc..., just give simplest possible method.  Don't do
 *  any of the normal memoization stuff in here either; it's a waste.
 *  As predicates cannot be inlined into the invoking rule, they need to
 *  be in a rule by themselves.
 */
synpredRule(ruleName, ruleDescriptor, block, description, nakedBlock) ::=
<<
// $ANTLR start _fragment
- (void) _fragment
{
    
    
        [self traceIn:\@"_fragment" Index:];
    @try {
        
    }
    @finally {
        [self traceOut:\@"_fragment" Index:];
    }

    

} // $ANTLR end _fragment
>>

synpred(name) ::= <<
SEL Selector = @selector(_fragment);

- (BOOL) 
{
    state.backtracking++;
    <@start()>
    NSInteger start = [input mark];
    @try {
        [self _fragment]; // can never throw exception
    }
    @catch (ANTLRRecognitionException *re) {
        NSLog(@"impossible: %@\n", re);
    }
    BOOL success = (state.failed == NO);
    [input rewind:start];
    <@stop()>
    state.backtracking--;
    state.failed=NO;
    return success;
} // $ANTLR end  <\n> !>
>>

lexerSynpred(name) ::= <<

>>

ruleMemoization(name) ::= <<

if ( state.backtracking && [self alreadyParsedRule:input RuleIndex:] ) return ;

>>

/** How to test for failure and return from rule */
checkRuleBacktrackFailure() ::= <<
if ( state.failed == YES ) return ;
>>

/** This rule has failed, exit indicating failure during backtrack */
ruleBacktrackFailure() ::= <<
if ( state.backtracking > 0 ) { state.failed = YES; return ; }
>>

/** How to generate code for a rule.
 *  The return type aggregates are declared in the header file (headerFile template)
 */
rule(ruleName,ruleDescriptor,block,emptyRule,description,exceptions,finally,memoize) ::= <<
/*
 * $ANTLR start 
 * :
 */
- () 
{
    traceIn("", );
    NSLog(@"enter  %@ failed=%@ backtracking=%d", [input LT:1], (state.failed==YES)?@"YES":@"NO", state.backtracking);
    
    
    
    <@preamble()>
    @try {
        
        
        
        
        <(ruleDescriptor.actions.after):execAction()>
    }

    <\n>}>



    

    @catch (ANTLRRecognitionException *re) {
        [self reportError:re];
        [self recover:input Exception:re];
        <@setErrorReturnValue()>
    }



    @finally {
    traceOut("", );
    NSLog(@"exit  %@ failed=%@ backtracking=%d", [input LT:1], state.failed ? @"YES" : @"NO", state.backtracking);
        
        
        
    }
    <@postamble()>
    return ;
}
/* $ANTLR end  */
>>

finalCode(finalBlock) ::= <<
{
    
}
>>

catch(decl,action) ::= <<
@catch () {
    
}
>>

ruleDeclarations() ::= <<

 retval = [ new];
[retval setStart:[input LT:1]];<\n>

  = ;
}>
 // This is not in the Java.stg
  = ;
 !>


NSInteger _StartIndex = [input getIndex];

>>

ruleScopeSetUp() ::= <<
/* ruleScopeSetUp */
_scope = [[_Scope new_Scope] retain];
[gStack push:_scope];}>
 = [ANTLRSymbolStack newANTLRSymbolStackWithLen:30];
[ruleStack push:[[_Scope new_Scope] retain]];}>
>>

ruleScopeCleanUp() ::= <<

 pop];}; separator="\n">
>>

ruleLabelDefs() ::= <<
<[ruleDescriptor.tokenLabels, ruleDescriptor.tokenListLabels,
  ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels]
    :{ * = nil;}; separator="\n">
<[ruleDescriptor.tokenListLabels,ruleDescriptor.ruleListLabels,ruleDescriptor.wildcardTreeListLabels]
    :{NSMutableArray *list_ = nil;}; separator="\n"
>

 = nil;}; separator="\n">
>>

lexerRuleLabelDefs() ::= <<
<[ruleDescriptor.tokenLabels,
  ruleDescriptor.tokenListLabels,
  ruleDescriptor.ruleLabels]
    :{ *=nil;}; separator="\n"
>
;}; separator="\n">
<[ruleDescriptor.tokenListLabels,
  ruleDescriptor.ruleListLabels]:{NSMutableArray *list_=nil; }; separator="\n">
>>

ruleReturnValue() ::= <<





retval



>>

ruleCleanUp() ::= <<
// token+rule list labels
<[ruleDescriptor.tokenListLabels,ruleDescriptor.ruleListLabels]:{[list_ release];}; separator="\n">


[retval setStop:[input LT:-1]];<\n>


>>

memoize() ::= <<


if (state.backtracking > 0) [self memoize:input RuleIndex: StartIndex:_StartIndex];


>>

/** How to generate a rule in the lexer; naked blocks are used for
 *  fragment rules.
 */
lexerRule(ruleName, nakedBlock, ruleDescriptor, block, memoize) ::= <<
// $ANTLR start ""
- (void) m
{
    //[self traceIn:[NSString stringWithFormat:@" %d\n", ]];
    NSLog(@"enter  %C line=%d:%d failed=%@ backtracking=%d",
        [input LA:1],
        [self getLine],
        [self getCharPositionInLine],
        (state.failed==YES) ? @"YES" : @"NO",
        state.backtracking);
    
    
    
    @try {

        
        
        
        <\n>

        NSInteger _type = ;
        NSInteger _channel = ANTLRTokenChannelDefault;
        
        
        
        
        
        [state setType:_type];<\n>
        state.channel = _channel;
        <(ruleDescriptor.actions.after):execAction()>

    }
    @finally {
        //[self traceOut:[NSString stringWithFormat:@" %d\n", ]];
        NSLog(@"exit  %C line=%d:%d failed=%@ backtracking=%d",
                    [input LA:1], [self getLine], [self getCharPositionInLine],
                    (state.failed==YES) ? @"YES" : @"NO", state.backtracking);
        
        
    }
    return;
}
// $ANTLR end ""
>>

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

// S U B R U L E S

/** A (...) subrule with multiple alternatives */
block(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
// : // block
NSInteger alt=;

<@predecision()>

<@postdecision()>
<@prebranch()>
switch (alt) {
    
}
<@postbranch()>
>>

/** A rule block with multiple alternatives */
ruleBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
// : //ruleblock
NSInteger alt=;

<@predecision()>

<@postdecision()>
switch (alt) {
    
}
>>

ruleBlockSingleAlt(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,description) ::= <<
// : // ruleBlockSingleAlt

<@prealt()>

<@postalt()>
>>

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

<@prealt()>

<@postalt()>
>>

/** A (..)+ block with 1 or more alternatives */
positiveClosureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
// : // positiveClosureBlock
NSInteger cnt=0;

<@preloop()>
do {
    NSInteger alt=;
    <@predecision()>
    
    <@postdecision()>
    switch (alt) {
        
        default :
            if ( cnt >= 1 )
                goto loop;

            

            ANTLREarlyExitException *eee = [ANTLREarlyExitException exceptionWithStream:input decisionNumber:];
            <@earlyExitException()>
            @throw eee;
    }
    cnt++;
} while (YES);
loop: ;
<@postloop()>
>>

positiveClosureBlockSingleAlt ::= positiveClosureBlock

/** A (..)* block with 0 or more alternatives */
closureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<

<@preloop()>
do {
    NSInteger alt=;
    <@predecision()>
    
    <@postdecision()>
    switch (alt) {
        
        default :
            goto loop;
    }
} while (YES);
loop: ;
<@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() ::= <<
case  : ;
    <@prealt()>
    
    break;<\n>
>>

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

<@cleanup()>
}
>>

/** What to emit when there is no rewrite.  For auto build
 *  mode, does nothing.
 */
noRewrite(rewriteBlockLevel, treeLevel) ::= ""

// E L E M E N T S

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

/** match a token optionally with a label in front */
tokenRef(token,label,elementIndex,hetero) ::= <<
=( *)[self match:input TokenType: Follow:FOLLOW__in_]; 
>>

/** ids+=ID */
tokenRefAndListLabel(token,label,elementIndex,hetero) ::= <<


>>

listLabel(label,elem) ::= <<
if (list_ == nil) list_ = [[NSMutableArray arrayWithCapacity:5] retain];
[list_ addObject:];<\n>
>>

/** match a character */
charRef(char,label) ::= <<

NSInteger  = [input LA:1];<\n>

[self matchChar:]; <\n>
>>

/** match a character range */
charRangeRef(a,b,label) ::= <<

 = [input LA:1];<\n>

[self matchRangeFromChar: to:]; 
>>

/** For now, sets are interval tests and must be tested inline */
matchSet(s,label,elementIndex,postmatchCode="") ::= <<


 = [input LA:1];<\n>

 = ( *)[input LT:1];<\n>


if () {
    [input consume];
    

    [state setIsErrorRecovery:NO];

    state.failed = NO;<\n>
} else {
    
    ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException exceptionWithSet:nil stream:input];
    <@mismatchedSetException()>

    [self recover:mse];
    @throw mse;

    @throw mse;
    ];
    !>

}<\n>
>>

matchRuleBlockSet ::= matchSet

matchSetAndListLabel(s,label,elementIndex,postmatchCode) ::= <<


>>

/** Match a string literal */
lexerStringRef(string,label) ::= <<

NSInteger Start = [self getIndex];
[self matchString:]; 
 = [[ANTLRCommonToken newANTLRCommonToken:input Type:ANTLRTokenTypeInvalid Channel:ANTLRTokenChannelDefault Start:Start Stop:[self getIndex]] retain];

[self matchString:]; <\n>

>>

wildcard(label,elementIndex) ::= <<

 = ( *)[input LT:1];<\n>

[self matchAny:input]; 
>>

wildcardAndListLabel(label,elementIndex) ::= <<


>>

/** Match . wildcard in lexer */
wildcardChar(label, elementIndex) ::= <<

NSInteger  = [input LA:1];<\n>

[self matchAny]; <\n>
>>

wildcardCharListLabel(label, elementIndex) ::= <<


>>

/** Match a rule reference by invoking it possibly with arguments
 *  and a return value or values.  The 'rule' argument was the
 *  target rule name, but now is type Rule, whose toString is
 *  same: the rule name.  Now though you can access full rule
 *  descriptor stuff.
 */
ruleRef(rule,label,elementIndex,args,scope) ::= <<
[self pushFollow:FOLLOW__in_];
 = [self :];<\n>

[self :];<\n>

[self popFollow];
<\n>
>>

/** ids+=r */
ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<


>>

/** A lexer rule reference.
 *
 *  The 'rule' argument was the target rule name, but now
 *  is type Rule, whose toString is same: the rule name.
 *  Now though you can access full rule descriptor stuff.
 */
lexerRuleRef(rule,label,args,elementIndex,scope) ::= <<

NSInteger Start = [self getIndex];
[self m:]; <\n>
 = [[ANTLRCommonToken newANTLRCommonToken:input Type:ANTLRTokenTypeInvalid Channel:ANTLRTokenChannelDefault Start:Start Stop:[self getIndex]-1] retain];
[ setLine:[self getLine]];

    [self m:]; <\n>

>>

/** i+=INT in lexer */
lexerRuleRefAndListLabel(rule,label,args,elementIndex,scope) ::= <<


>>

/** EOF in the lexer */
lexerMatchEOF(label,elementIndex) ::= <<

NSInteger Start = [self getIndex];
[self matchChar:ANTLRCharStreamEOF]; <\n>
  = [[ANTLRCommonToken newANTLRCommonToken:input Type:ANTLRTokenTypeEOF Channel:ANTLRTokenChannelDefault Start:Start Stop:[self getIndex]-1] retain];
[ setLine:[self getLine]];

[self matchChar:ANTLRCharStreamEOF]; <\n>

>>

/** match ^(root children) in tree parser */
tree(root, actionsAfterRoot, children, nullableChildList, enclosingTreeLevel, treeLevel) ::= <<



if ( [input LA:1] == DOWN ) {
    [self match:input TokenType:DOWN Follow:nil]; 
    
    [self match:input TokenType:UP Follow:nil]; 
}

    [self match:input TokenType:DOWN Follow:nil]; 
    
    [self match:input TokenType:UP Follow:nil]; 

>>

/** Every predicate is used as a validating predicate (even when it is
 *  also hoisted into a prediction expression).
 */
validateSemanticPredicate(pred,description) ::= <<
if ( !() ) {
    
    @throw [ANTLRFailedPredicateException exceptionWithRuleName:@"" predicate:@"" stream:input];
}
>>

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

dfaState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
NSInteger LA_ = [input LA:];<\n>

else {

    alt = ;

    
    ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newANTLRNoViableAltException: state: stream:input];
    <@noViableAltException()>
    @throw nvae;<\n>

}
>>

/** 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) ::= <<
NSInteger LA_ = [input LA:];<\n>

>>

/** 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) ::= <<
NSInteger LA_ = [input LA:];
<\n>


alt=; 

else {
    alt = ;
}<\n>


>>

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

/** A simple edge with an expression.  If the expression is satisfied,
 *  enter to the target state.  To handle gated productions, we may
 *  have to evaluate some predicates for this edge.
 */
dfaEdge(labelExpr, targetState, predicates) ::= <<
if ( () && ()) {
    
}
>>

// F i x e d  D F A  (switch case)

/** A DFA state where a SWITCH may be generated.  The code generator
 *  decides if this is possible: CodeGenerator.canGenerateSwitch().
 */
dfaStateSwitch(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
switch ([input LA:]) {
    <\n>
default: ;

    alt = ;

    
    ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newANTLRNoViableAltException: state: stream:input];
    <@noViableAltException()>
    @throw nvae;<\n>

}<\n>
>>

dfaOptionalBlockStateSwitch(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
switch ([input LA:]) {
    <\n>
}<\n>
>>

dfaLoopbackStateSwitch(k, edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
switch ([input LA:]) {
    <\n>

default: ;
    alt = 
    break;<\n>

}<\n>
>>

dfaEdgeSwitch(labels, targetState) ::= <<
: ;}; separator="\n">
    {
    
    }
    break;
>>

// C y c l i c  D F A

/** The code to initiate execution of a cyclic DFA; this is used
 *  in the rule to predict an alt just like the fixed DFA case.
 *  The  attribute is inherited via the parser, lexer, ...
 */
dfaDecision(decisionNumber,description) ::= <<
alt = [dfa predict:input];
>>

/** Used in headerFile */
cyclicDFAInterface(dfa) ::= <<
#pragma mark Cyclic DFA interface start DFA
@interface DFA : ANTLRDFA {
}
+ newDFAWithRecognizer:(ANTLRBaseRecognizer *)theRecognizer;
- initWithRecognizer:(ANTLRBaseRecognizer *)recognizer;
@end /* end of DFA interface  */<\n>
#pragma mark Cyclic DFA interface end DFA
>>

/** Used in lexer/parser implementation files */
/* Dump DFA tables as run-length-encoded Strings of octal values.
 * Can't use hex as compiler translates them before compilation.
 * These strings are split into multiple, concatenated strings.
 * Java puts them back together at compile time thankfully.
 * Java cannot handle large static arrays, so we're stuck with this
 * encode/decode approach.  See analysis and runtime DFA for
 * the encoding methods.
 */
cyclicDFA(dfa) ::= <<
#pragma mark Cyclic DFA implementation start DFA
@implementation DFA
const static NSInteger dfa_eot[] =
    {};
const static NSInteger dfa_eof[] =
    {};
const static unichar dfa_min[] =
    {};
const static unichar dfa_max[] =
    {};
const static NSInteger dfa_accept[] =
    {};
const static NSInteger dfa_special[] =
    {};
const static NSInteger dfa_transition[] = {};
_transition[] = {};
}; null="">

+ () newDFAWithRecognizer:(ANTLRBaseRecognizer *)aRecognizer
{
    return [[[DFA alloc] initWithRecognizer:aRecognizer] retain];
}

- (id) initWithRecognizer:(ANTLRBaseRecognizer *) theRecognizer
{
    if ((self = [super initWithRecognizer:theRecognizer]) != nil) {
        decisionNumber = ;
        eot = dfa_eot;
        eof = dfa_eof;
        min = dfa_min;
        max = dfa_max;
        accept = dfa_accept;
        special = dfa_special;
        if (!(transition = calloc(, sizeof(void*)))) {
            [self release];
            return nil;
        }
        len = ;
        ] = dfa_transition;}; separator="\n", null="">
    }
    return self;
}


/* start dfa.specialStateSTs */
- (NSInteger) specialStateTransition:(NSInteger)s Stream:(id\)anInput
{

    id\ input = anInput;<\n>


    id\ input = (id\)anInput;<\n>


    id\ input = (id\)anInput;<\n>

    switch (s) {
         : ;
            }; separator="\n">
    }

    if ( [recognizer getBacktrackingLevel] > 0 ) { [recognizer setFailed:YES]; return -1; }<\n>

    ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newANTLRNoViableAltException: state:s stream:[recognizer getInput]];
    /* [self error:nvae]; */ 
    @throw nvae;
}<\n>
/* end dfa.specialStateSTs */


- (void) dealloc
{
    free(transition);
    [super dealloc];
}

- (NSString *) description
{
    return @"";
}

<@errorMethod()>

@end /* end DFA implementation */<\n>
#pragma mark Cyclic DFA implementation end DFA
<\n>
>>
/** A state in a cyclic DFA; it's a special state and part of a big switch on
 *  state.
 */
cyclicDFAState(decisionNumber, stateNumber, edges, needErrorClause, semPredState) ::= <<
/* cyclicDFAState */
NSInteger LA_ = [input LA:1];<\n>
 
NSInteger index_ = [input getIndex];
[input rewind];<\n>

s = -1;

 
[input seek:index_];<\n>

if ( s >= 0 )
    return s;
 break;
>>

/** Just like a fixed DFA edge, test the lookahead and indicate what
 *  state to jump to next if successful.
 */
cyclicDFAEdge(labelExpr, targetStateNumber, edgeNumber, predicates) ::= <<
/* cyclicDFAEdge */
if ( && ()) { s = ;}<\n>
>>

/** An edge pointing at end-of-token; essentially matches any char;
 *  always jump to the target.
 */
eotDFAEdge(targetStateNumber,edgeNumber, predicates) ::= <<
/* eotDFAEdge */
s = ;<\n>
>>

// D F A  E X P R E S S I O N S

andPredicates(left,right) ::= "(&&)"

orPredicates(operands) ::= "(first(operands)}>)"

notPredicate(pred) ::= "!()"

evalPredicate(pred,description) ::= "()"

/*
 * evalSynPredicate(pred,description) ::= "()"
 *
 * synpreds are broken in cyclic DFA special states
 *  Damn! For now, work around with using the selectors directly, and by providing a trampoline evalSynPred method in
 *  ANTLRDFA
 */
/* evalSynPredicate(pred,description) ::= "[self evaluateSyntacticPredicate:Selector stream:input]" */
evalSynPredicate(pred,description) ::= "[self evaluateSyntacticPredicate:@selector(_fragment)]"
/* evalSynPredicate(pred,description) ::= "[recognizer ]" */

lookaheadTest(atom,k,atomAsInt) ::= "LA_=="

/** Sometimes a lookahead test cannot assume that LA(k) is in a temp variable
 *  somewhere.  Must ask for the lookahead directly.
 */
isolatedLookaheadTest(atom,k,atomAsInt) ::= "[input LA:] == "

lookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::= <<
(LA_\>= && LA_\<=)
>>

isolatedLookaheadRangeTest(lower,upper,k,rangeNumber,lowerAsInt,upperAsInt) ::= "(([input LA:] \>= ) && ([input LA:] \<= ))"

setTest(ranges) ::= ""

// A T T R I B U T E S

globalAttributeScopeDecl(scope) ::= <<
@interface _Scope : ANTLRSymbolsScope {  /* globalAttributeScopeDecl */

 ;}; separator="\n"><\n>

}
/* start of properties */<\n>
, setter=set:)  ;}; separator="\n"><\n>
/* end properties */<\n>
+ (_Scope *)new_Scope;
/* start of iterated get and set functions */<\n>
)get;<\n>- (void)set:()aVal;}; separator="\n"><\n>
/* End of iterated get and set functions */<\n>
@end /* end of _Scope interface */<\n>
>>

globalAttributeScopeMemVar(scope) ::= <<
/* globalAttributeScopeMemVar */
ANTLRSymbolStack *gStack;
_Scope *_scope;
>>

globalAttributeScopeImpl(scope) ::= <<
@implementation _Scope  /* globalAttributeScopeImpl */
/* start of synthesize -- OBJC-Line 1750 */<\n>
;}; separator="\n"><\n>

+ (_Scope *)new_Scope
{
    return [[[_Scope alloc] init] retain];
}
/* start of iterate get and set functions */<\n>
)get \{ return(  ); \}<\n>
- (void)set:()aVal \{  = aVal; \}<\n\n>}; separator="\n"><\n>
/* End of iterate get and set functions */<\n>
@end /* end of _Scope implementation */<\n>
>>

globalAttributeScopeInit(scope) ::= <<
/* globalAttributeScopeInit */
_scope = [_Scope new_Scope];
>>

globalAttributeScopeDealloc(scope) ::= <<
[_scope release];
>>

globalAttributeScope(scope) ::= <<

ANTLRSymbolStack *gStack = [ANTLRSymbolStack newANTLRSymbolStackWithLen:30];<\n>

>>

ruleAttributeScopeDecl(scope) ::= <<

@interface _Scope : ANTLRSymbolsScope { /* ruleAttributeScopeDecl */<\n>
;}; separator="\n"> !>
 ;}; separator="\n"><\n>
}

, setter=set:)  ;}; separator="\n"><\n>
/* end properties */<\n>

+ (_Scope *)new_Scope;
- (get
@end /* end of _Scope interface */<\n>

>>

ruleAttributeScopeMemVar(scope) ::= <<
/* ruleAttributeScopeMemVar */<\n>
_Scope *_scope;
>>

ruleAttributeScopeImpl(scope) ::= <<

@implementation _Scope /* ruleAttributeScopeImpl */<\n>
;}; separator="\n"><\n>
+ (_Scope *)new_Scope
{
    return [[[_Scope alloc] init] retain];
}

// start of iterate get and set functions<\n>

- ()get \{ return(  ); \}<\n>
- (void)set:()aVal \{  = aVal; \}<\n\n>}; separator="\n"><\n>
// End of iterate get and set functions<\n>

@end /* end of _Scope implemtation */<\n>

>>

ruleAttributeScopeInit(scope) ::= <<
/* ruleAttributeScopeInit */
_scope = [_Scope new_Scope];
>>

ruleAttributeScopeDealloc(scope) ::= <<
[_Scope release];
>>

ruleAttributeScope(scope) ::= <<

/* ruleAttributeScope */
ANTLRSymbolStack *Stack = [ANTLRSymbolStack newANTLRSymbolStackWithLen:30];<\n>

>>

returnStructName() ::= "__return"

returnType() ::= <<


 *




void



void

>>

/** Generate the Objective-C type associated with a single or multiple return
 *  values.
 */
ruleLabelType(referencedRule) ::= <<

__return *

void

>>

delegateName() ::= <<
g
>>

/** Using a type to init value map, try to init a type; if not in table
 *  must be an object, default value is "null".
 */
initValue(typeName) ::= <<

>>

/** Define a rule label including default value */
ruleLabelDef(label) ::= <<
  = ;<\n>
>>

/** Define a return struct for a rule if the code needs to access its
 *  start/stop tokens, tree stuff, attributes, ...  Leave a hole for
 *  subgroups to stick in members.
 */
returnScopeInterface(scope) ::= <<

/* returnScopeInterface */
@interface  :ANTLRTreeParserRuleReturnScope { /* returnScopeInterface line 1806 */
<@memVars()> /* start of memVars() */

 ;}; separator="\n"><\n>

}
<@properties()> /* start properties */

, setter=set:)  ;}; separator="\n"><\n>
/* end properties */<\n>

+ ( *)new;
/* this is start of set and get methods */
<@methodsDecl()>  /* methodsDecl */

/* start of iterated get and set functions */<\n>

- ()get;
- (void)set:()aVal;}; separator="\n"><\n>
// End of iterated get and set functions<\n>

@end /* end of returnScopeInterface interface */<\n>

>>

returnScope(scope) ::= <<
/* returnScope */

@implementation  /* returnScope */
<@synthesize()> /* start of synthesize -- OBJC-Line 1837 */

;}; separator="\n"><\n>

+ ( *)new
{
    return [[[ alloc] init] retain];
}

<@methods()>

/* start of iterate get and set functions */<\n>

- ()get \{ return(  ); \}<\n>
- (void)set:()aVal \{  = aVal; \}<\n\n>}; separator="\n"><\n>
// End of iterate get and set functions<\n>


<@ruleReturnMembers()><\n>
@end /* end of returnScope implementation */<\n>

>>

parameterScope(scope) ::= <<
)}; separator=" ">
>>

parameterAttributeRef(attr) ::= ""
parameterSetAttributeRef(attr,expr) ::= "=;"

/** Note that the scopeAttributeRef does not have access to the
 * grammar name directly
 */
scopeAttributeRef(scope,attr,index,negIndex) ::= <<
/* scopeAttributeRef */

([((_Scope *)[gStack objectAtIndex:[gStack size]--1)]).


((_Scope *)[gStack objectAtIndex:]).

((_Scope *)[gStack peek]).


>>

scopeSetAttributeRef(scope,attr,expr,index,negIndex) ::= <<
/* scopeSetAttributeRef */

((_Scope *)[gStack objectAtIndex:([gStack size]--1)]). =;


((_Scope *)[gStack objectAtIndex:]). = ;

((_Scope *)[gStack peek]). = ;


>>

scopeAttributeRefStack() ::= <<
/* scopeAttributeRefStack */

((_scope *)[Stack objectAtIndex:[Stack count]--1]). = ;


((_scope *)[Stack objectAtIndex:]). = ;

[Stack peek]. = ;


>>

/** $x is either global scope or x is rule with dynamic scope; refers
 *  to stack itself not top of stack.  This is useful for predicates
 *  like {$function.size()>0 && $function::name.equals("foo")}?
 */
isolatedDynamicScopeRef(scope) ::= "Stack"

/** reference an attribute of rule; might only have single return value */
ruleLabelRef(referencedRule,scope,attr) ::= <<

(!=nil?.:)



>>

returnAttributeRef(ruleDescriptor,attr) ::= <<

retval.;  /* added to returnAttributeRef */



>>

returnSetAttributeRef(ruleDescriptor,attr,expr) ::= <<

 retval. =; /* added to returnSetAttributeRef */

 = ;

>>

/** How to translate $tokenLabel */
tokenLabelRef(label) ::= ""

/** ids+=ID {$ids} or e+=expr {$e} */
listLabelRef(label) ::= "list_"


// not sure the next are the right approach; and they are evaluated early;
// they cannot see TREE_PARSER or PARSER attributes for example. :(

tokenLabelPropertyRef_text(scope,attr) ::= "(!=nil?[ getText]:0)"
tokenLabelPropertyRef_type(scope,attr) ::= "(!=nil?[ getType]:0)"
tokenLabelPropertyRef_line(scope,attr) ::= "(!=nil?[ getLine]:0)"
tokenLabelPropertyRef_pos(scope,attr) ::= "(!=nil?[ getCharPositionInLine]:0)"
tokenLabelPropertyRef_channel(scope,attr) ::= "(!=nil?[ getChannel]:0)"
tokenLabelPropertyRef_index(scope,attr) ::= "(!=nil?[ getTokenIndex]:0)"
tokenLabelPropertyRef_tree(scope,attr) ::= "_tree"
tokenLabelPropertyRef_int(scope,attr) ::= "(!=nil?[[ getText] integerValue]:0]"

ruleLabelPropertyRef_start(scope,attr) ::= "(!=nil?(( *).startToken):nil)"
ruleLabelPropertyRef_stop(scope,attr) ::= "(!=nil?(( *).stopToken):nil)"
ruleLabelPropertyRef_tree(scope,attr) ::= "(!=nil?(( *).tree):nil)"
ruleLabelPropertyRef_text(scope,attr) ::= <<

(!=nil?[[input getTokenStream] toStringFromStart:[[input getTreeAdaptor] getTokenStartIndex:[ getStart]]
         ToEnd:[[input getTreeAdaptor] getTokenStopIndex:[ getStart]]]:nil)

(!=nil?([input toStringFromStart:[ getStart] ToEnd:[ getStop]]:nil)

>>
ruleLabelPropertyRef_st(scope,attr) ::= "(!=nil?[ st]:nil)"

/** Isolated $RULE ref ok in lexer as it's a Token */
lexerRuleLabel(label) ::= ""

lexerRuleLabelPropertyRef_type(scope,attr) ::= "(!=nil?[ getType]:0)"
lexerRuleLabelPropertyRef_line(scope,attr) ::= "(!=nil?[ getLine]:0)"
lexerRuleLabelPropertyRef_pos(scope,attr) ::= "(!=nil?[ getCharPositionInLine]:-1)"
lexerRuleLabelPropertyRef_channel(scope,attr) ::= "(!=nil?[ getChannel]:0)"
lexerRuleLabelPropertyRef_index(scope,attr) ::= "(!=nil?[ getTokenIndex]:0)"
lexerRuleLabelPropertyRef_text(scope,attr) ::= "(!=nil?[ getText]:nil)"
lexerRuleLabelPropertyRef_int(scope,attr) ::="(!=nil?[[ text] integerValue]:0)"

// Somebody may ref $template or $tree or $stop within a rule:
rulePropertyRef_start(scope,attr) ::= "(( *)retval.startToken)"
rulePropertyRef_stop(scope,attr) ::= "(( *)retval.stopToken)"
rulePropertyRef_tree(scope,attr) ::= "(( *)retval.tree)"
rulePropertyRef_text(scope,attr) ::= <<

[[input getTokenStream] toStringFromStart:[[input getTreeAdaptor] getTokenStartIndex:retval.start]
                                    ToEnd:[[input getTreeAdaptor] getTokenStopIndex:retval.start]]

[input toStringFromToken:retval.start ToToken:[input LT:-1]]

>>
rulePropertyRef_st(scope,attr) ::= "retval.st"

/* hideous: find a way to cut down on the number of templates to support read/write access */
/* TODO: also, which ones are valid to write to? ask Ter */
lexerRuleSetPropertyRef_text(scope,attr,expr) ::= "[state setText:];"
lexerRuleSetPropertyRef_type(scope,attr,expr) ::= "_type"
lexerRuleSetPropertyRef_line(scope,attr,expr) ::= "[state getTokenStartLine]"
lexerRuleSetPropertyRef_pos(scope,attr,expr) ::= "[state getCharPositionInLine]"
lexerRuleSetPropertyRef_index(scope,attr,expr) ::= "-1" /* undefined token index in lexer */
lexerRuleSetPropertyRef_channel(scope,attr,expr) ::= "[state setChannel:];"
lexerRuleSetPropertyRef_start(scope,attr,expr) ::= "[state getTokenStartCharIndex]"
lexerRuleSetPropertyRef_stop(scope,attr,expr) ::= "([self getIndex]-1)"


lexerRulePropertyRef_text(scope,attr) ::= "[self getText]"
lexerRulePropertyRef_type(scope,attr) ::= "[state getType]"
lexerRulePropertyRef_line(scope,attr) ::= "state.tokenStartLine"
lexerRulePropertyRef_pos(scope,attr) ::= "state.tokenStartCharPositionInLine"
lexerRulePropertyRef_index(scope,attr) ::= "-1" // undefined token index in lexer
lexerRulePropertyRef_channel(scope,attr) ::= "_channel"
lexerRulePropertyRef_start(scope,attr) ::= "state.tokenStartCharIndex"
lexerRulePropertyRef_stop(scope,attr) ::= "([self getIndex]-1)"
lexerRulePropertyRef_int(scope,attr) ::= "[[ getText] integerValue]"

// setting $st and $tree is allowed in local rule. everything else
// is flagged as error
ruleSetPropertyRef_tree(scope,attr,expr) ::= "retval.tree =;"
ruleSetPropertyRef_st(scope,attr,expr) ::= "retval.st =;" /* "<\n>#error StringTemplates are unsupported<\n>" */


/** How to execute an action */
execAction(action) ::= <<

if (  ) {
    
}



>>

/** How to always execute an action even when backtracking */
execForcedAction(action) ::= ""

// M I S C (properties, etc...)

bitset(name, words64) ::= <<
static ANTLRBitSet *;
static const unsigned long long _data[] = { LL};separator=", ">};<\n>
>>

bitsetInit(name, words64) ::= <<
 = [[ANTLRBitSet newANTLRBitSetWithBits:(const unsigned long long *)_data Count:(NSUInteger)] retain];<\n>
>>

codeFileExtension() ::= ".m"

true() ::= "YES"
false() ::= "NO"