antlr3 1.6.3 → 1.7.2

data/templates/Ruby.stg

@@ -24,7 +24,7 @@ outputFile(LEXER, PARSER, TREE_PARSER, actionScope, actions, docComment, recogni
 
 # ~~~\> start load path setup
 this_directory = File.expand_path( File.dirname( __FILE__ ) )
-$:.unshift( this_directory ) unless $:.include?( this_directory )
+$LOAD_PATH.unshift( this_directory ) unless $LOAD_PATH.include?( this_directory )
 
 antlr_load_failed = proc do
   load_path = $LOAD_PATH.map { |dir| '  - ' \<\< dir }.join( $/ )
@@ -70,6 +70,7 @@ rescue LoadError
 end
 # \<~~~ end load path setup
 
+<placeAction(scope="all", name="header")>
 <placeAction(scope=actionScope,name="header")>
 
 <if(recognizer.grammar.grammarIsRoot)>
@@ -79,6 +80,7 @@ end
 <endif>
 
 <placeAction(scope=actionScope,name="footer")>
+<placeAction(scope="all", name="footer")>
 
 <if(actions.(actionScope).main)>
 if __FILE__ == $0 and ARGV.first != '--'
@@ -91,7 +93,7 @@ tokenDataModule() ::= <<
 # TokenData defines all of the token type integer values
 # as constants, which will be included in all 
 # ANTLR-generated recognizers.
-const_defined?(:TokenData) or TokenData = ANTLR3::TokenScheme.new
+const_defined?( :TokenData ) or TokenData = ANTLR3::TokenScheme.new
 
 module TokenData
 <if(tokens)>
@@ -165,7 +167,7 @@ class <if(grammar.grammarIsRoot)>Parser<else><grammar.name><endif> \< <superClas
 end # class <if(grammar.grammarIsRoot)>Parser<else><grammar.name><endif> \< <superClass>
 <if(!actions.(actionScope).main)>
 
-at_exit { <if(grammar.grammarIsRoot)>Parser<else><grammar.name><endif>.main(ARGV) } if __FILE__ == $0
+at_exit { <if(grammar.grammarIsRoot)>Parser<else><grammar.name><endif>.main( ARGV ) } if __FILE__ == $0
 <endif>
 >>
 
@@ -180,7 +182,7 @@ class <if(grammar.grammarIsRoot)>TreeParser<else><grammar.name><endif> \< <super
 end # class <if(grammar.grammarIsRoot)>TreeParser<else><grammar.name><endif> \< <superClass>
 <if(!actions.(actionScope).main)>
 
-at_exit { <if(grammar.grammarIsRoot)>TreeParser<else><grammar.name><endif>.main(ARGV) } if __FILE__ == $0
+at_exit { <if(grammar.grammarIsRoot)>TreeParser<else><grammar.name><endif>.main( ARGV ) } if __FILE__ == $0
 <endif>
 >>
 
@@ -202,7 +204,11 @@ imports( <grammar.directDelegates:{d|:<d.name>}; separator=", "> )<\n>
 
 include TokenData
 
-generated_using( "<fileName>", "<ANTLRVersion>", "<runtimeLibraryVersion()>" )
+begin
+  generated_using( "<fileName>", "<ANTLRVersion>", "<runtimeLibraryVersion()>" )
+rescue NoMethodError => error
+  # ignore
+end
 
 <if(!grammar.grammarIsRoot)>
 require '<grammar.composite.rootGrammar.recognizerName>'
@@ -230,7 +236,7 @@ def initialize_dfas
 end
 
 <endif>
-<bitsets:{TOKENS_FOLLOWING_<it.name>_IN_<it.inName>_<it.tokenIndex> = Set[<it.tokenTypes:{<it>}; separator=", ">]<\n>}>
+<bitsets:{TOKENS_FOLLOWING_<it.name>_IN_<it.inName>_<it.tokenIndex> = Set[ <it.tokenTypes:{<it>}; separator=", "> ]<\n>}>
 >>
 
 parserConstructor() ::= <<
@@ -266,7 +272,7 @@ synpredRule(ruleName, ruleDescriptor, block, description, nakedBlock) ::= <<
 # This is an imaginary rule inserted by ANTLR to
 # implement a syntactic predicate decision
 # 
-def <ruleName; format="lexerRule"><if(ruleDescriptor.parameterScope)>(<ruleDescriptor.parameterScope:parameterScope(scope=it)>)<endif>
+def <ruleName; format="lexerRule"><if(ruleDescriptor.parameterScope)>( <ruleDescriptor.parameterScope:parameterScope(scope=it)> )<endif>
   <traceIn()><ruleLabelDefs()>
   <block>
 ensure
@@ -287,7 +293,7 @@ rule(ruleName, ruleDescriptor, block, emptyRule, description, exceptions, finall
 # (in <fileName>)
 # <description>
 # 
-def <ruleName><if(ruleDescriptor.parameterScope)>(<ruleDescriptor.parameterScope:parameterScope(scope=it)>)<endif>
+def <ruleName><if(ruleDescriptor.parameterScope)>( <ruleDescriptor.parameterScope:parameterScope(scope=it)> )<endif>
   <traceIn()><ruleScopeSetUp()><ruleDeclarations()><ruleLabelDefs()><action(name="init", code=ruleDescriptor.actions.init)>
   <@body><ruleBody()><@end>
   
@@ -301,7 +307,7 @@ end
 
 delegateRule(ruleDescriptor) ::= <<
 # delegated rule <ruleDescriptor.name>
-def <ruleDescriptor.name>(<ruleDescriptor.parameterScope:parameterScope(scope=it)>)
+def <ruleDescriptor.name><if(ruleDescriptor.parameterScope)>( <ruleDescriptor.parameterScope:parameterScope(scope=it)> )<endif>
   <methodCall(del=ruleDescriptor.grammar, n=ruleDescriptor.name, args={<ruleDescriptor.parameterScope.attributes:{<it.name>}>})>
 end
 >>
@@ -312,7 +318,9 @@ recognizerClassName() ::= <<
 >>
 
 initializeDirectDelegate() ::= <<
-@<g:delegateName()> = <g.name>::<recognizerClassName()>.new(<trunc(g.delegators):{p|<p:delegateName()>, }>self, input, options.merge(:state => @state))
+@<g:delegateName()> = <g.name>::<recognizerClassName()>.new(
+  <trunc(g.delegators):{p|<p:delegateName()>, }>self, input, options.merge( :state => @state )
+)
 >>
 
 initializeDelegator() ::= <<
@@ -354,7 +362,6 @@ delegateName() ::= <<
 <if(it.label)><it.label; format="label"><else><it.name; format="snakecase"><endif>
 >>
 
-
 element() ::= <<
 <it.el><\n>
 >>
@@ -365,20 +372,16 @@ globalAttributeScopeClass(scope) ::= <<
 <if(scope.attributes)>@@<scope.name> = Struct.new( <scope.attributes:{:<it.decl>}; separator=", "> )<\n><endif>
 >>
 
-
 globalAttributeScopeStack(scope) ::= <<
 <if(scope.attributes)>@<scope.name>_stack = []<\n><endif>
 >>
 
-
 noRewrite(rewriteBlockLevel, treeLevel) ::= ""
 
-
 parameterScope(scope) ::= <<
 <scope.attributes:{<it.decl>}; separator=", ">
 >>
 
-
 positiveClosureBlockLoop() ::= <<
 match_count_<decisionNumber> = 0
 while true
@@ -403,14 +406,14 @@ returnScope(scope) ::= <<
 <endif>
 >>
 
-
 returnStructName(r) ::= "<r.name; format=\"camelcase\">ReturnValue"
+
 ruleAttributeScopeClass ::= globalAttributeScopeClass
 ruleAttributeScopeStack ::= globalAttributeScopeStack
 
 ruleBacktrackFailure() ::= <<
 <if(backtracking)>
-@state.backtracking > 0 and raise(ANTLR3::Error::BacktrackingFailed)<\n>
+@state.backtracking > 0 and raise( ANTLR3::Error::BacktrackingFailed )<\n>
 <endif>
 >>
 
@@ -445,7 +448,6 @@ ensure
 end
 >>
 
-
 ruleReturnValue() ::= <<
 <if(!ruleDescriptor.isSynPred)>
 <if(ruleDescriptor.hasReturnValue)>
@@ -473,50 +475,58 @@ return_value.start = @input.look<\n>
 <endif>
 >>
 
-
 ruleLabelDef(label) ::= <<
 <label.label.text; format="label"> = nil<\n>
 >>
 
-
 ruleLabelDefs() ::= <<
-<[ruleDescriptor.tokenLabels,ruleDescriptor.tokenListLabels,ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels]:{<it.label.text; format="label"> = nil<\n>}><[ruleDescriptor.tokenListLabels,ruleDescriptor.ruleListLabels,ruleDescriptor.wildcardTreeListLabels]:{list_of_<it.label.text; format="label"> = []<\n>}><[ruleDescriptor.ruleLabels,ruleDescriptor.ruleListLabels]:ruleLabelDef(label=it)><ruleDescriptor.ruleListLabels:{<it.label.text; format="label"> = nil<\n>}>
+<[
+    ruleDescriptor.tokenLabels,
+    ruleDescriptor.tokenListLabels,
+    ruleDescriptor.wildcardTreeLabels,
+    ruleDescriptor.wildcardTreeListLabels,
+    ruleDescriptor.ruleLabels,
+    ruleDescriptor.ruleListLabels
+ ]:
+ {<it.label.text; format="label"> = nil<\n>}
+><[
+    ruleDescriptor.tokenListLabels,
+    ruleDescriptor.ruleListLabels,
+    ruleDescriptor.wildcardTreeListLabels
+  ]:
+  {list_of_<it.label.text; format="label"> = []<\n>}
+>
 >>
 
-
-
 /* * * * * * * * * * * * * R U L E   H E L P E R S * * * * * * * * * * * * */
 
 traceIn() ::= <<
 <if(trace)>
-trace_in(__method__, <ruleDescriptor.index>)<\n>
+trace_in( __method__, <ruleDescriptor.index> )<\n>
 <else>
 # -> uncomment the next line to manually enable rule tracing
-# trace_in(__method__, <ruleDescriptor.index>)<\n>
+# trace_in( __method__, <ruleDescriptor.index> )<\n>
 <endif>
 >>
 
-
 traceOut() ::= <<
 <if(trace)>
-trace_out(__method__, <ruleDescriptor.index>)<\n>
+trace_out( __method__, <ruleDescriptor.index> )<\n>
 <else>
 # -> uncomment the next line to manually enable rule tracing
-# trace_out(__method__, <ruleDescriptor.index>)<\n>
+# trace_out( __method__, <ruleDescriptor.index> )<\n>
 <endif>
 >>
 
-
 ruleCleanUp() ::= <<
 <if(ruleDescriptor.hasMultipleReturnValues)>
 <if(!TREE_PARSER)>
 # - - - - - - - rule clean up - - - - - - - -
-return_value.stop = @input.look(-1)<\n>
+return_value.stop = @input.look( -1 )<\n>
 <endif>
 <endif>
 >>
 
-
 ruleMemoization(name) ::= <<
 <if(memoize)>
 # rule memoization
@@ -529,34 +539,28 @@ end<\n>
 
 
 ruleScopeSetUp() ::= <<
-<ruleDescriptor.useScopes:{@<it>_stack.push(@@<it>.new)<\n>}><ruleDescriptor.ruleScope:{@<it.name>_stack.push(@@<it.name>.new)<\n>}>
+<ruleDescriptor.useScopes:{@<it>_stack.push( @@<it>.new )<\n>}><ruleDescriptor.ruleScope:{@<it.name>_stack.push( @@<it.name>.new )<\n>}>
 >>
 
-
 ruleScopeCleanUp() ::= <<
 <ruleDescriptor.useScopes:{@<it>_stack.pop<\n>}><ruleDescriptor.ruleScope:{@<it.name>_stack.pop<\n>}>
 >>
 
-
 memoize() ::= <<
 <if(memoize)><if(backtracking)>
-memoize(__method__, <ruleDescriptor.name>_start_index, success) if @state.backtracking > 0<\n>
+memoize( __method__, <ruleDescriptor.name>_start_index, success ) if @state.backtracking > 0<\n>
 <endif><endif>
 >>
 
-
 /** helper template to format a ruby method call */
 methodCall(n, del, args) ::= <<
-<if(del)>@<del:delegateName()>.<endif><n><if(args)>(<args; separator=", ">)<endif>
+<if(del)>@<del:delegateName()>.<endif><n><if(args)>( <args; separator=", "> )<endif>
 >>
 
-
 /* * * * * * * * * * * * * L E X E R   P A R T S * * * * * * * * * * * * * */
 
-
 actionGate() ::= "@state.backtracking == 0"
 
-
 /** A (...) subrule with multiple alternatives */
 block(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
 # at line <description>
@@ -565,7 +569,6 @@ alt_<decisionNumber> = <maxAlt>
 <@body><blockBody()><@end>
 >>
 
-
 /** A rule block with multiple alternatives */
 ruleBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
 # at line <description>
@@ -577,14 +580,12 @@ case alt_<decisionNumber>
 end
 >>
 
-
 ruleBlockSingleAlt(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,description) ::= <<
 <decls>
 <@prealt()>
 <alts>
 >>
 
-
 /** A special case of a (...) subrule with a single alternative */
 blockSingleAlt(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,description) ::= <<
 # at line <description>
@@ -593,7 +594,6 @@ blockSingleAlt(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber
 <alts>
 >>
 
-
 /** A (..)+ block with 0 or more alternatives */
 positiveClosureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
 # at file <description>
@@ -603,10 +603,8 @@ positiveClosureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decision
 <@end>
 >>
 
-
 positiveClosureBlockSingleAlt ::= positiveClosureBlock
 
-
 /** A (..)* block with 0 or more alternatives */
 closureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,maxK,maxAlt,description) ::= <<
 # at line <description>
@@ -616,19 +614,15 @@ closureBlock(alts,decls,decision,enclosingBlockLevel,blockLevel,decisionNumber,m
 <@end>
 >>
 
-
 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
 
-
 /** An alternative is just a list of elements; at outermost
   * level
   */
@@ -637,23 +631,28 @@ alt(elements,altNum,description,autoAST,outerAlt,treeLevel,rew) ::= <<
 <elements:element()><rew>
 >>
 
-
 /** match a token optionally with a label in front */
 tokenRef(token,label,elementIndex,hetero) ::= <<
-<if(label)><label; format="label"> = <endif>match(<token>, TOKENS_FOLLOWING_<token>_IN_<ruleName>_<elementIndex>)
+<if(label)><label; format="label"> = <endif>match( <token>, TOKENS_FOLLOWING_<token>_IN_<ruleName>_<elementIndex> )
 >>
 
-
 /** ids+=ID */
 tokenRefAndListLabel(token,label,elementIndex,hetero) ::= <<
 <tokenRef(...)>
 <addToList(elem={<label; format="label">},...)>
 >>
+
+/* TRY THIS:
+tokenRefAndListLabel(token,label,elementIndex,hetero) ::= <<
+list_of_<label; format="label"> << match( <token>, TOKENS_FOLLOWING_<token>_IN_<ruleName>_<elementIndex> )
+>>
+*/
+
 addToList(label,elem) ::= <<
 list_of_<label; format="label"> \<\< <elem><\n>
 >>
-listLabel ::= addToList
 
+listLabel ::= addToList
 
 /** For now, sets are interval tests and must be tested inline */
 matchSet(s,label,elementIndex,postmatchCode) ::= <<
@@ -668,10 +667,10 @@ if <s>
 <endif>
 else
   <ruleBacktrackFailure()>
-  mse = MismatchedSet(nil)
+  mse = MismatchedSet( nil )
   <@mismatchedSetException()>
 <if(LEXER)>
-  recover(mse)
+  recover mse
   raise mse<\n>
 <else>
   raise mse<\n>
@@ -686,10 +685,8 @@ matchSetAndListLabel(s,label,elementIndex,postmatchCode) ::= <<
 <addToList(elem={<label; format="label">},...)>
 >>
 
-
 matchRuleBlockSet ::= matchSet
 
-
 wildcard(label,elementIndex) ::= <<
 <if(label)>
 <label; format="label"> = @input.look<\n>
@@ -697,6 +694,11 @@ wildcard(label,elementIndex) ::= <<
 match_any
 >>
 
+/* TRY THIS:
+wildcard(label,elementIndex) ::= <<
+<if(label)><label; format="label"> = <endif>match_any
+>>
+*/
 
 wildcardAndListLabel(label,elementIndex) ::= <<
 <wildcard(...)>
@@ -708,62 +710,65 @@ wildcardAndListLabel(label,elementIndex) ::= <<
   * arguments and a return value or values.
   */
 ruleRef(rule,label,elementIndex,args,scope) ::= <<
-@state.following.push(TOKENS_FOLLOWING_<rule.name>_IN_<ruleName>_<elementIndex>)
+@state.following.push( TOKENS_FOLLOWING_<rule.name>_IN_<ruleName>_<elementIndex> )
 <if(label)><label; format="label"> = <endif><methodCall(del=scope, n={<rule.name>}, args=args)>
 @state.following.pop
 >>
 
-
 /** ids+=ID */
 ruleRefAndListLabel(rule,label,elementIndex,args,scope) ::= <<
 <ruleRef(...)>
 <addToList(elem={<label; format="label">},...)>
 >>
 
-
 /** match ^(root children) in tree parser */
 tree(root, actionsAfterRoot, children, nullableChildList, enclosingTreeLevel, treeLevel) ::= <<
 <root:element()>
 <actionsAfterRoot:element()>
 <if(nullableChildList)>
 if @input.peek == DOWN
-  match(DOWN, nil)
+  match( DOWN, nil )
   <children:element()>
-  match(UP, nil)
+  match( UP, nil )
 end
 <else>
-match(DOWN, nil)
+match( DOWN, nil )
 <children:element()>
-match(UP, nil)
+match( UP, nil )
 <endif>
 >>
 
-
 /** Every predicate is used as a validating predicate (even when
   * it is also hoisted into a prediction expression).
   */
 validateSemanticPredicate(pred,description) ::= <<
-unless (<evalPredicate(...)>)
+<if(backtracking)>
+unless ( <evalPredicate(...)> )
   <ruleBacktrackFailure()>
-  raise FailedPredicate("<ruleName>", "<description>")
+  raise FailedPredicate( "<ruleName>", "<description>" )
 end
+<else>
+raise FailedPredicate( "<ruleName>", "<description>" ) unless ( <evalPredicate(...)> )
+<endif>
 >>
 
-
 dfaState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
-look_<decisionNumber>_<stateNumber> = @input.peek(<k>)<\n>
+look_<decisionNumber>_<stateNumber> = @input.peek( <k> )<\n>
 <edges; separator="\nels">
 else
 <if(eotPredictsAlt)>
   alt_<decisionNumber> = <eotPredictsAlt><\n>
 <else>
-  <ruleBacktrackFailure()>nvae = NoViableAlternative("<description>", <decisionNumber>, <stateNumber>)
-  <@noViableAltException>raise nvae<@end><\n>
+<if(backtracking)>
+  <ruleBacktrackFailure()><\n>
+<endif>
+<@noViableAltException>
+  raise NoViableAlternative( "<description>", <decisionNumber>, <stateNumber> )<\n>
+<@end>
 <endif>
 end
 >>
 
-
 /** Same as a normal DFA state except that we don't examine
   * look for the bypass alternative.  It delays error
   * detection but this is faster, smaller, and more what people
@@ -772,7 +777,7 @@ end
   * lookup; preds might not need.
   */
 dfaOptionalBlockState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
-look_<decisionNumber>_<stateNumber> = @input.peek(<k>)<\n>
+look_<decisionNumber>_<stateNumber> = @input.peek( <k> )<\n>
 <edges; separator="\nels">
 end
 >>
@@ -787,7 +792,7 @@ end
   * look lookup; preds might not need.
   */
 dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
-look_<decisionNumber>_<stateNumber> = @input.peek(<k>)<\n>
+look_<decisionNumber>_<stateNumber> = @input.peek( <k> )<\n>
 <edges; separator="\nels"><\n>
 <if(eotPredictsAlt)>
 else
@@ -802,14 +807,13 @@ end
   */
 dfaAcceptState(alt) ::= "alt_<decisionNumber> = <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 (<labelExpr>) <if(predicates)>and (<predicates>)<endif>
+if ( <labelExpr> )<if(predicates)> and ( <predicates> )<endif>
   <targetState>
 >>
 
@@ -819,29 +823,31 @@ if (<labelExpr>) <if(predicates)>and (<predicates>)<endif>
   * CodeGenerator.canGenerateSwitch().
   */
 dfaStateSwitch(k,edges,eotPredictsAlt,description,stateNumber,semPredState) ::= <<
-case look_<decisionNumber> = @input.peek(<k>)
+case look_<decisionNumber> = @input.peek( <k> )
 <edges; separator="\n">
 else
 <if(eotPredictsAlt)>
   alt_<decisionNumber> = <eotPredictsAlt><\n>
 <else>
-  <ruleBacktrackFailure()>
-  nvae = NoViableAlternative("<description>", <decisionNumber>, <stateNumber>)
-  <@noViableAltException>raise nvae<@end><\n>
+<if(backtracking)>
+  <ruleBacktrackFailure()><\n>
+<endif>
+<@noViableAltException>
+  raise NoViableAlternative( "<description>", <decisionNumber>, <stateNumber> )<\n>
+<@end>
 <endif>
 end
 >>
 
 
 dfaOptionalBlockStateSwitch(k, edges, eotPredictsAlt, description, stateNumber, semPredState) ::= <<
-case look_<decisionNumber> = @input.peek(<k>)
+case look_<decisionNumber> = @input.peek( <k> )
 <edges; separator="\n">
 end
 >>
 
-
 dfaLoopbackStateSwitch(k, edges, eotPredictsAlt, description, stateNumber, semPredState) ::= <<
-case look_<decisionNumber> = @input.peek(<k>)
+case look_<decisionNumber> = @input.peek( <k> )
 <edges; separator="\n">
 <if(eotPredictsAlt)>
 else
@@ -850,21 +856,18 @@ else
 end
 >>
 
-
 dfaEdgeSwitch(labels, targetState) ::= <<
 when <labels:{<it>}; separator=", "> then <targetState>
 >>
 
-
 /** 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 <name> attribute is inherited via the parser, lexer, ...
   */
 dfaDecision(decisionNumber, description) ::= <<
-alt_<decisionNumber> = @dfa<decisionNumber>.predict(@input)
+alt_<decisionNumber> = @dfa<decisionNumber>.predict( @input )
 >>
 
-
 /** Generate the tables and support code needed for the DFAState
   * object argument.  Unless there is a semantic predicate (or
   * syn pred, which become sem preds), all states should be
@@ -875,14 +878,14 @@ alt_<decisionNumber> = @dfa<decisionNumber>.predict(@input)
   */
 cyclicDFA(dfa) ::= <<
 class DFA<dfa.decisionNumber> \< ANTLR3::DFA
-  EOT = unpack(<dfa.javaCompressedEOT; anchor, separator=", ", wrap="\n">)
-  EOF = unpack(<dfa.javaCompressedEOF; anchor, separator=", ", wrap="\n">)
-  MIN = unpack(<dfa.javaCompressedMin; anchor, separator=", ", wrap="\n">)
-  MAX = unpack(<dfa.javaCompressedMax; anchor, separator=", ", wrap="\n">)
-  ACCEPT = unpack(<dfa.javaCompressedAccept; anchor, separator=", ", wrap="\n">)
-  SPECIAL = unpack(<dfa.javaCompressedSpecial; anchor, separator=", ", wrap="\n">)
+  EOT = unpack( <dfa.javaCompressedEOT; anchor, separator=", ", wrap="\n"> )
+  EOF = unpack( <dfa.javaCompressedEOF; anchor, separator=", ", wrap="\n"> )
+  MIN = unpack( <dfa.javaCompressedMin; anchor, separator=", ", wrap="\n"> )
+  MAX = unpack( <dfa.javaCompressedMax; anchor, separator=", ", wrap="\n"> )
+  ACCEPT = unpack( <dfa.javaCompressedAccept; anchor, separator=", ", wrap="\n"> )
+  SPECIAL = unpack( <dfa.javaCompressedSpecial; anchor, separator=", ", wrap="\n"> )
   TRANSITION = [
-    <dfa.javaCompressedTransition:{s|unpack(<s; wrap="\n", anchor, separator=", ">)}; separator=",\n">
+    <dfa.javaCompressedTransition:{s|unpack( <s; wrap="\n", anchor, separator=", "> )}; separator=",\n">
   ].freeze
   
   ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
@@ -915,21 +918,19 @@ def special_state_transition_for_dfa<dfa.decisionNumber>(s, input)
 <if(backtracking)>
   @state.backtracking > 0 and raise ANTLR3::Error::BacktrackingFailed<\n>
 <endif>
-  nva = ANTLR3::Error::NoViableAlternative.new(@dfa<dfa.decisionNumber>.description, <dfa.decisionNumber>, s, input)
-  @dfa<dfa.decisionNumber>.error(nva)
+  nva = ANTLR3::Error::NoViableAlternative.new( @dfa<dfa.decisionNumber>.description, <dfa.decisionNumber>, s, input )
+  @dfa<dfa.decisionNumber>.error( nva )
   raise nva
 end
 >>
 
-
-cyclicDFASynpred(name) ::= <<
+cyclicDFASynpred( name ) ::= <<
 def <name>() @recognizer.<name> end<\n>
 >>
 
-
 cyclicDFAInit(dfa) ::= <<
 <if(dfa.specialStateSTs)>
-@dfa<dfa.decisionNumber> = DFA<dfa.decisionNumber>.new(self, <dfa.decisionNumber>) do |s|
+@dfa<dfa.decisionNumber> = DFA<dfa.decisionNumber>.new( self, <dfa.decisionNumber> ) do |s|
   case s
   <dfa.specialStateSTs:{state|when <i0>
   <state>}; separator="\n">
@@ -939,15 +940,15 @@ cyclicDFAInit(dfa) ::= <<
 <if(backtracking)>
     @state.backtracking > 0 and raise ANTLR3::Error::BacktrackingFailed<\n>
 <endif>
-    nva = ANTLR3::Error::NoViableAlternative.new(@dfa<dfa.decisionNumber>.description, <dfa.decisionNumber>, s, input)
-    @dfa<dfa.decisionNumber>.error(nva)
+    nva = ANTLR3::Error::NoViableAlternative.new( @dfa<dfa.decisionNumber>.description, <dfa.decisionNumber>, s, input )
+    @dfa<dfa.decisionNumber>.error( nva )
     raise nva
   end
   
   s
 end<\n>
 <else>
-@dfa<dfa.decisionNumber> = DFA<dfa.decisionNumber>.new(self, <dfa.decisionNumber>)<\n>
+@dfa<dfa.decisionNumber> = DFA<dfa.decisionNumber>.new( self, <dfa.decisionNumber> )<\n>
 <endif>
 >>
 
@@ -959,12 +960,12 @@ cyclicDFAState(decisionNumber, stateNumber, edges, needErrorClause, semPredState
 look_<decisionNumber>_<stateNumber> = @input.peek
 <if(semPredState)>
 index_<decisionNumber>_<stateNumber> = @input.index
-@input.rewind(@input.last_marker, false)<\n>
+@input.rewind( @input.last_marker, false )<\n>
 <endif>
 s = -1
 <edges; separator="els">end
 <if(semPredState)> <! return input cursor to state before we rewound !>
-@input.seek(index_<decisionNumber>_<stateNumber>)<\n>
+@input.seek( index_<decisionNumber>_<stateNumber> )<\n>
 <endif>
 >>
 
@@ -973,11 +974,10 @@ s = -1
   * for special states.
   */
 cyclicDFAEdge(labelExpr, targetStateNumber, edgeNumber, predicates) ::= <<
-if (<labelExpr>)<if(predicates)> && (<predicates>)<endif>
+if ( <labelExpr> )<if(predicates)> and ( <predicates> )<endif>
   s = <targetStateNumber><\n>
 >>
 
-
 /** An edge pointing at end-of-token; essentially matches any
   * char; always jump to the target.
   */
@@ -986,20 +986,18 @@ e
   s = <targetStateNumber><\n>
 >>
 
+andPredicates(left,right) ::= "( <left> ) and ( <right> )"
 
-andPredicates(left,right) ::= "( ( <left> ) and ( <right> ) )"
+orPredicates(operands) ::= "( <first(operands)> )<rest(operands):{o|  or ( <o> )}>"
 
-orPredicates(operands) ::= "(<first(operands)><rest(operands):{o|  or <o>}>)"
+notPredicate(pred) ::= "not ( <pred> )"
 
-notPredicate(pred) ::= "not (<evalPredicate(...)>)"
-
-evalPredicate(pred,description) ::= "(<pred>)"
+evalPredicate(pred,description) ::= "( <pred> )"
 
 evalSynPredicate(pred,description) ::= <<
-syntactic_predicate?(<pred:{<it; format="lexerRule">}; format="symbol">)
+syntactic_predicate?( :<pred:{<it; format="lexerRule">}> )
 >>
 
-
 lookaheadTest(atom, k, atomAsInt) ::= "look_<decisionNumber>_<stateNumber> == <atom>"
 
 /** Sometimes a look test cannot assume that LA(k) is in a
@@ -1008,34 +1006,30 @@ lookaheadTest(atom, k, atomAsInt) ::= "look_<decisionNumber>_<stateNumber> == <a
   */
 isolatedLookaheadTest(atom, k, atomAsInt) ::= "@input.peek(<k>) == <atom>"
 
-
 lookaheadRangeTest(lower, upper, k, rangeNumber, lowerAsInt, upperAsInt) ::= <<
-look_<decisionNumber>_<stateNumber>.between?(<lower>, <upper>)
+look_<decisionNumber>_<stateNumber>.between?( <lower>, <upper> )
 >>
 
-
 isolatedLookaheadRangeTest(lower, upper, k, rangeNumber, lowerAsInt, upperAsInt) ::= <<
-@input.peek(<k>).between?(<lower>, <upper>)
+@input.peek( <k> ).between?( <lower>, <upper> )
 >>
+
 setTest(ranges) ::= <<
 <ranges; separator=" || ">
 >>
 
-
 parameterAttributeRef(attr) ::= "<attr.name>"
 
-
 parameterSetAttributeRef(attr,expr) ::= "<attr.name> = <expr>"
 
-
 scopeAttributeRef(scope, attr, index, negIndex) ::= <<
 <if(negIndex)>
-@<scope>_stack[-<negIndex>].<attr.name>
+@<scope>_stack[ -<negIndex> ].<attr.name>
 <else>
 <if(index)>
-@<scope>_stack[<index>].<attr.name>
+@<scope>_stack[ <index> ].<attr.name>
 <else>
-@<scope>_stack[-1].<attr.name>
+@<scope>_stack.last.<attr.name>
 <endif>
 <endif>
 >>
@@ -1043,12 +1037,12 @@ scopeAttributeRef(scope, attr, index, negIndex) ::= <<
 
 scopeSetAttributeRef(scope, attr, expr, index, negIndex) ::= <<
 <if(negIndex)>
-@<scope>_stack[-<negIndex>].<attr.name> = <expr>
+@<scope>_stack[ -<negIndex> ].<attr.name> = <expr>
 <else>
 <if(index)>
-@<scope>_stack[<index>].<attr.name> = <expr>
+@<scope>_stack[ <index> ].<attr.name> = <expr>
 <else>
-@<scope>_stack[-1].<attr.name> = <expr>
+@<scope>_stack.last.<attr.name> = <expr>
 <endif>
 <endif>
 >>
@@ -1061,19 +1055,17 @@ scopeSetAttributeRef(scope, attr, expr, index, negIndex) ::= <<
   */
 isolatedDynamicScopeRef(scope) ::= "@<scope>_stack"
 
-
 /** reference an attribute of rule; might only have single
   * return value
   */
 ruleLabelRef(referencedRule, scope, attr) ::= <<
 <if(referencedRule.hasMultipleReturnValues)>
-(<scope; format="label">.nil? ? nil : <scope; format="label">.<attr.name>)
+( <scope; format="label">.nil? ? nil : <scope; format="label">.<attr.name> )
 <else>
 <scope; format="label">
 <endif>
 >>
 
-
 returnAttributeRef(ruleDescriptor, attr) ::= <<
 <if(ruleDescriptor.hasMultipleReturnValues)>
 return_value.<attr.name>
@@ -1082,7 +1074,6 @@ return_value.<attr.name>
 <endif>
 >>
 
-
 returnSetAttributeRef(ruleDescriptor, attr, expr) ::= <<
 <if(ruleDescriptor.hasMultipleReturnValues)>
 return_value.<attr.name> = <expr>
@@ -1091,57 +1082,37 @@ return_value.<attr.name> = <expr>
 <endif>
 >>
 
-
 /** How to translate $tokenLabel */
 tokenLabelRef(label) ::= "<label; format=\"label\">"
 
-
 /** ids+=ID {$ids} or e+=expr {$e} */
 listLabelRef(label) ::= "list_of_<label; format=\"label\">"
 
-
 tokenLabelPropertyRef_text(scope, attr) ::= "<scope; format=\"label\">.text"
-
-
 tokenLabelPropertyRef_type(scope, attr) ::= "<scope; format=\"label\">.type"
-
-
 tokenLabelPropertyRef_line(scope, attr) ::= "<scope; format=\"label\">.line"
-
-
 tokenLabelPropertyRef_pos(scope, attr) ::= "<scope; format=\"label\">.column"
-
-
 tokenLabelPropertyRef_channel(scope, attr) ::= "<scope; format=\"label\">.channel"
-
-
 tokenLabelPropertyRef_index(scope, attr) ::= "<scope; format=\"label\">.index"
-
-
 tokenLabelPropertyRef_tree(scope, attr) ::= "tree_for_<scope>"
 
-
 ruleLabelPropertyRef_start(scope, attr) ::= "<scope; format=\"label\">.start"
-
-
 ruleLabelPropertyRef_stop(scope, attr) ::= "<scope; format=\"label\">.stop"
-
-
 ruleLabelPropertyRef_tree(scope, attr) ::= "<scope; format=\"label\">.tree"
 
-
 ruleLabelPropertyRef_text(scope, attr) ::= <<
 <if(TREE_PARSER)>
-(<scope; format="label">.nil? ? nil : @input.token_stream.to_s(
-    @input.tree_adaptor.token_start_index(<scope; format="label">.start),
-    @input.tree_adaptor.token_stop_index(<scope; format="label">.start)))
+(
+  @input.token_stream.to_s(
+    @input.tree_adaptor.token_start_index( <scope; format="label">.start ),
+    @input.tree_adaptor.token_stop_index( <scope; format="label">.start )
+  ) if <scope; format="label">
+)
 <else>
-(<scope; format="label">.nil? ? nil : @input.to_s(<scope; format="label">.start,<scope; format="label">.stop))
+( <scope; format="label"> && @input.to_s( <scope; format="label">.start, <scope; format="label">.stop ) )
 <endif>
 >>
-
-
-ruleLabelPropertyRef_st(scope, attr) ::= "(<scope; format=\"label\">.nil? ? nil : <scope; format=\"label\">.template)"
+ruleLabelPropertyRef_st(scope, attr) ::= "( <scope; format=\"label\"> && <scope; format=\"label\">.template )"
 
 /******************************************************************************
  *****************  L E X E R - O N L Y   T E M P L A T E S  ******************
@@ -1154,20 +1125,23 @@ lexer(grammar, name, tokens, scopes, rules, numRules, labelType="ANTLR3::Token",
 
 class <if(grammar.delegator)><grammar.name><else>Lexer<endif> \< <superClass>
   @grammar_home = <grammar.name>
-  <if(!grammar.grammarIsRoot)><autoloadDelegates()><\n><endif>
+<if(!grammar.grammarIsRoot)>
+  <autoloadDelegates()><\n>
+<endif>
   include TokenData
 <if(filterMode)>
   include ANTLR3::FilterMode<\n>
 <endif>
   <scopes:{<if(it.isDynamicGlobalScope)><globalAttributeScopeClass(scope=it)><\n><endif>}>
+  
   begin
     generated_using( "<fileName>", "<ANTLRVersion>", "<runtimeLibraryVersion()>" )
   rescue NoMethodError => error
-    error.name.to_sym == :generated_using or raise
+    # ignore
   end
   
-  RULE_NAMES   = [<trunc(rules):{r|"<r.ruleName>"}; separator=", ", wrap="\n", anchor>].freeze
-  RULE_METHODS = [<trunc(rules):{r|:<r.ruleName; format="lexerRule">}; separator=", ", wrap="\n", anchor>].freeze
+  RULE_NAMES   = [ <trunc(rules):{r|"<r.ruleName>"}; separator=", ", wrap="\n", anchor> ].freeze
+  RULE_METHODS = [ <trunc(rules):{r|:<r.ruleName; format="lexerRule">}; separator=", ", wrap="\n", anchor> ].freeze
 
 <if(grammar.delegators)>
   masters( <grammar.delegators:{d|:<d.name>}; separator=", "> )<\n>
@@ -1176,25 +1150,17 @@ class <if(grammar.delegator)><grammar.name><else>Lexer<endif> \< <superClass>
   imports( <grammar.directDelegates:{d|:<d.name>}; separator=", "> )<\n>
 <endif>
   
-  def initialize(<grammar.delegators:{g|<g:delegateName()>, }>input=nil, options = {})
-    super(input, options)
+  def initialize( <grammar.delegators:{g|<g:delegateName()>, }>input=nil, options = {} )
+    super( input, options )
 <if(memoize)>
 <if(grammar.grammarIsRoot)>
     @state.rule_memory = {}<\n>
 <endif>
 <endif>
-    <grammar.delegators:{g|@<g:delegateName()> = <g:delegateName()><\n>}><grammar.directDelegates:{g|@<g:delegateName()> = <newDelegate(g)><\n>}><last(grammar.delegators):{g|@parent = @<g:delegateName()><\n>}>
-<if(actions.lexer.init)>
-    
-    # - - - - - - - - - - @init - - - - - - - - - - - - - - -
-    <actions.lexer.init><\n>
-<endif>
+    <grammar.delegators:{g|@<g:delegateName()> = <g:delegateName()><\n>}><grammar.directDelegates:{g|@<g:delegateName()> = <newDelegate(g)><\n>}><last(grammar.delegators):{g|@parent = @<g:delegateName()><\n>}><placeAction(scope="lexer",name="init")>
   end
-<if(actions.lexer.members)>
   
-  # - - - - - - - - - - custom @members - - - - - - - - - - -
-  <actions.lexer.members>
-<endif>
+  <placeAction(scope="lexer",name="members")>
   
   # - - - - - - - - - - - lexer rules - - - - - - - - - - - -
   <rules:{<it><\n>}>
@@ -1219,7 +1185,7 @@ class <if(grammar.delegator)><grammar.name><else>Lexer<endif> \< <superClass>
 end # class <if(grammar.delegator)><grammar.name><else>Lexer<endif> \< <superClass>
 <if(!actions.(actionScope).main)>
 
-at_exit { <if(grammar.delegator)><grammar.name><else>Lexer<endif>.main(ARGV) } if __FILE__ == $0
+at_exit { <if(grammar.delegator)><grammar.name><else>Lexer<endif>.main( ARGV ) } if __FILE__ == $0
 <endif>
 >>
 
@@ -1239,7 +1205,7 @@ lexerRuleLabelDefs() ::= <<
 lexerRule(ruleName,nakedBlock,ruleDescriptor,block,memoize) ::= <<
 # lexer rule <ruleName; format="lexerRule"> (<ruleName>)
 # (in <fileName>)
-def <ruleName; format="lexerRule"><if(ruleDescriptor.parameterScope)>(<ruleDescriptor.parameterScope:parameterScope(scope=it)>)<endif>
+def <ruleName; format="lexerRule"><if(ruleDescriptor.parameterScope)>( <ruleDescriptor.parameterScope:parameterScope(scope=it)> )<endif>
   <traceIn()><ruleScopeSetUp()><ruleDeclarations()><if(memoize)>
 <if(backtracking)>
   
@@ -1308,7 +1274,7 @@ end
 lexerRulePropertyRef_text(scope, attr) ::= "self.text"
 lexerRulePropertyRef_type(scope, attr) ::= "type"
 lexerRulePropertyRef_line(scope, attr) ::= "@state.token_start_line"
-lexerRulePropertyRef_pos(scope, attr) ::= "@state.token_start_column"
+lexerRulePropertyRef_pos(scope, attr)  ::= "@state.token_start_column"
 
 /** Undefined, but present for consistency with Token
   * attributes; set to -1
@@ -1316,7 +1282,7 @@ lexerRulePropertyRef_pos(scope, attr) ::= "@state.token_start_column"
 lexerRulePropertyRef_index(scope, attr) ::= "-1"
 lexerRulePropertyRef_channel(scope, attr) ::= "channel"
 lexerRulePropertyRef_start(scope, attr) ::= "@state.token_start_position"
-lexerRulePropertyRef_stop(scope, attr) ::= "(self.character_index - 1)"
+lexerRulePropertyRef_stop(scope, attr) ::= "( self.character_index - 1 )"
 
 /** A lexer rule reference */
 lexerRuleRef(rule,label,args,elementIndex,scope) ::= <<
@@ -1361,7 +1327,7 @@ charRef(char,label) ::= <<
 <if(label)>
 <label; format="label"> = @input.peek<\n>
 <endif>
-match(<char>)
+match( <char> )
 >>
 
 /** match a character range */
@@ -1369,7 +1335,7 @@ charRangeRef(a,b,label) ::= <<
 <if(label)>
 <label; format="label"> = @input.peek<\n>
 <endif>
-match_range(<a>, <b>)
+match_range( <a>, <b> )
 >>
 
 filteringNextToken() ::= ""
@@ -1379,7 +1345,7 @@ filteringActionGate() ::= "@state.backtracking == 1"
 lexerStringRef(string,label) ::= <<
 <if(label)>
 <label; format="label">_start = self.character_index
-match(<string>)
+match( <string> )
 <label; format="label"> = create_token do |t|
   t.input   = @input
   t.type    = ANTLR3::INVALID_TOKEN_TYPE
@@ -1388,16 +1354,16 @@ match(<string>)
   t.stop    = character_index - 1
 end
 <else>
-match(<string>)
+match( <string> )
 <endif>
 >>
 
 
 /** EOF in the lexer */
 lexerMatchEOF(label,elementIndex) ::= <<
-<if(label)>                                     
+<if(label)>
 <label; format="label">_start_<elementIndex> = character_index
-match(ANTLR3::EOF)
+match( ANTLR3::EOF )
 <label; format="label"> = create_token do |t|
   t.input   = @input
   t.type    = ANTLR3::INVALID_TOKEN_TYPE
@@ -1406,7 +1372,7 @@ match(ANTLR3::EOF)
   t.stop    = character_index - 1
 end<\n>
 <else>
-match(ANTLR3::EOF)<\n>
+match( ANTLR3::EOF )<\n>
 <endif>
 >>
 
@@ -1420,7 +1386,7 @@ rulePropertyRef_stop(scope, attr) ::= "return_value.stop"
 rulePropertyRef_tree(scope, attr) ::= "return_value.tree"
 
 /** $text in parser rule */
-rulePropertyRef_text(scope, attr) ::= "@input.to_s(return_value.start, @input.look(-1))"
+rulePropertyRef_text(scope, attr) ::= "@input.to_s( return_value.start, @input.look( -1 ) )"
 
 /** $template in parser rule */
 rulePropertyRef_st(scope, attr) ::= "return_value.template"
@@ -1465,7 +1431,7 @@ autoloadDelegates() ::= <<
 
 delegateLexerRule(ruleDescriptor) ::= <<
 # delegated lexer rule <ruleDescriptor.name; format="lexerRule"> (<ruleDescriptor.name> in the grammar)
-def <ruleDescriptor.name; format="lexerRule">(<ruleDescriptor.parameterScope:parameterScope(scope=it)>)
+def <ruleDescriptor.name; format="lexerRule"><if(ruleDescriptor.parameterScope)>( <ruleDescriptor.parameterScope:parameterScope(scope=it)> )<endif>
   <methodCall(del=ruleDescriptor.grammar, n={<ruleDescriptor.name; format="lexerRule">}, args=ruleDescriptor.parameterScope.attributes)>
 end
 >>
@@ -1479,7 +1445,9 @@ grammarClassName() ::= <<
 >>
 
 newDelegate(gram) ::= <<
-<gram.name>.new(<trunc(gram.delegators):{p|<p:delegateName()>, }>self, @input, :state => @state<@delegateOptions()>)
+<gram.name>.new( <trunc(gram.delegators):{p|<p:delegateName()>, }>
+  self, @input, :state => @state<@delegateOptions()>
+)
 >>
 
 placeAction(scope, name) ::= <<
@@ -1491,4 +1459,4 @@ placeAction(scope, name) ::= <<
 <endif>
 >>
 
-runtimeLibraryVersion() ::= "1.6.3"
+runtimeLibraryVersion() ::= "1.7.2"