anchor.diff:   *  the AST constructed from the parser.]
    *
    * Contributing authors:
  - *		John Mitchell		johnm@non.net
  - *		Terence Parr		parrt@magelang.com
  - *		John Lilley		jlilley@empathy.com
  - *		Scott Stanchfield	thetick@magelang.com
  - *		Markus Mohnen		mohnen@informatik.rwth-aachen.de
  - *		Peter Williams		pete.williams@sun.com
  - *		Allan Jacobs		Allan.Jacobs@eng.sun.com
  - *		Steve Messick		messick@redhills.com
  - *		James Strachan		jstrachan@protique.com
  - *		John Pybus		john@pybus.org
  - *		John Rose		rose00@mac.com
  - *		Jeremy Rayner		groovy@ross-rayner.com
  + *              John Mitchell           johnm@non.net
  + *              Terence Parr            parrt@magelang.com
  + *              John Lilley             jlilley@empathy.com
  + *              Scott Stanchfield       thetick@magelang.com
  + *              Markus Mohnen           mohnen@informatik.rwth-aachen.de
  + *              Peter Williams          pete.williams@sun.com
  + *              Allan Jacobs            Allan.Jacobs@eng.sun.com
  + *              Steve Messick           messick@redhills.com
  + *              James Strachan          jstrachan@protique.com
  + *              John Pybus              john@pybus.org
  + *              John Rose               rose00@mac.com
  + *              Jeremy Rayner           groovy@ross-rayner.com
    *
    * Version 1.00 December 9, 1997 -- initial release
    * Version 1.01 December 10, 1997
  - *		fixed bug in octal def (0..7 not 0..8)
  + *              fixed bug in octal def (0..7 not 0..8)
    * Version 1.10 August 1998 (parrt)
  - *		added tree construction
  - *		fixed definition of WS,comments for mac,pc,unix newlines
  - *		added unary plus
  + *              added tree construction
  + *              fixed definition of WS,comments for mac,pc,unix newlines
  + *              added unary plus
    * Version 1.11 (Nov 20, 1998)
  - *		Added "shutup" option to turn off last ambig warning.
  - *		Fixed inner class def to allow named class defs as statements
  - *		synchronized requires compound not simple statement
  - *		add [] after builtInType DOT class in primaryExpression
  - *		"const" is reserved but not valid..removed from modifiers
  + *              Added "shutup" option to turn off last ambig warning.
  + *              Fixed inner class def to allow named class defs as statements
  + *              synchronized requires compound not simple statement
  + *              add [] after builtInType DOT class in primaryExpression
  + *              "const" is reserved but not valid..removed from modifiers
    * Version 1.12 (Feb 2, 1999)
  - *		Changed LITERAL_xxx to xxx in tree grammar.
  - *		Updated java.g to use tokens {...} now for 2.6.0 (new feature).
  + *              Changed LITERAL_xxx to xxx in tree grammar.
  + *              Updated java.g to use tokens {...} now for 2.6.0 (new feature).
    *
    * Version 1.13 (Apr 23, 1999)
  - *		Didn't have (stat)? for else clause in tree parser.
  - *		Didn't gen ASTs for interface extends.  Updated tree parser too.
  - *		Updated to 2.6.0.
  + *              Didn't have (stat)? for else clause in tree parser.
  + *              Didn't gen ASTs for interface extends.  Updated tree parser too.
  + *              Updated to 2.6.0.
    * Version 1.14 (Jun 20, 1999)
  - *		Allowed final/abstract on local classes.
  - *		Removed local interfaces from methods
  - *		Put instanceof precedence where it belongs...in relationalExpr
  - *			It also had expr not type as arg; fixed it.
  - *		Missing ! on SEMI in classBlock
  - *		fixed: (expr) + "string" was parsed incorrectly (+ as unary plus).
  - *		fixed: didn't like Object[].class in parser or tree parser
  + *              Allowed final/abstract on local classes.
  + *              Removed local interfaces from methods
  + *              Put instanceof precedence where it belongs...in relationalExpr
  + *                      It also had expr not type as arg; fixed it.
  + *              Missing ! on SEMI in classBlock
  + *              fixed: (expr) + "string" was parsed incorrectly (+ as unary plus).
  + *              fixed: didn't like Object[].class in parser or tree parser
    * Version 1.15 (Jun 26, 1999)
  - *		Screwed up rule with instanceof in it. :(  Fixed.
  - *		Tree parser didn't like (expr).something; fixed.
  - *		Allowed multiple inheritance in tree grammar. oops.
  + *              Screwed up rule with instanceof in it. :(  Fixed.
  + *              Tree parser didn't like (expr).something; fixed.
  + *              Allowed multiple inheritance in tree grammar. oops.
    * Version 1.16 (August 22, 1999)
  - *		Extending an interface built a wacky tree: had extra EXTENDS.
  - *		Tree grammar didn't allow multiple superinterfaces.
  - *		Tree grammar didn't allow empty var initializer: {}
  + *              Extending an interface built a wacky tree: had extra EXTENDS.
  + *              Tree grammar didn't allow multiple superinterfaces.
  + *              Tree grammar didn't allow empty var initializer: {}
    * Version 1.17 (October 12, 1999)
  - *		ESC lexer rule allowed 399 max not 377 max.
  - *		java.tree.g didn't handle the expression of synchronized
  - *		statements.
  + *              ESC lexer rule allowed 399 max not 377 max.
  + *              java.tree.g didn't handle the expression of synchronized
  + *              statements.
    * Version 1.18 (August 12, 2001)
  - *	  	Terence updated to Java 2 Version 1.3 by
  - *		observing/combining work of Allan Jacobs and Steve
  - *		Messick.  Handles 1.3 src.  Summary:
  - *		o  primary didn't include boolean.class kind of thing
  - *	  	o  constructor calls parsed explicitly now:
  - * 		   see explicitConstructorInvocation
  - *		o  add strictfp modifier
  - *	  	o  missing objBlock after new expression in tree grammar
  - *		o  merged local class definition alternatives, moved after declaration
  - *		o  fixed problem with ClassName.super.field
  - *	  	o  reordered some alternatives to make things more efficient
  - *		o  long and double constants were not differentiated from int/float
  - *		o  whitespace rule was inefficient: matched only one char
  - *		o  add an examples directory with some nasty 1.3 cases
  - *		o  made Main.java use buffered IO and a Reader for Unicode support
  - *		o  supports UNICODE?
  - *		   Using Unicode charVocabulay makes code file big, but only
  - *		   in the bitsets at the end. I need to make ANTLR generate
  - *		   unicode bitsets more efficiently.
  + *              Terence updated to Java 2 Version 1.3 by
  + *              observing/combining work of Allan Jacobs and Steve
  + *              Messick.  Handles 1.3 src.  Summary:
  + *              o  primary didn't include boolean.class kind of thing
  + *              o  constructor calls parsed explicitly now:
  + *                 see explicitConstructorInvocation
  + *              o  add strictfp modifier
  + *              o  missing objBlock after new expression in tree grammar
  + *              o  merged local class definition alternatives, moved after declaration
  + *              o  fixed problem with ClassName.super.field
  + *              o  reordered some alternatives to make things more efficient
  + *              o  long and double constants were not differentiated from int/float
  + *              o  whitespace rule was inefficient: matched only one char
  + *              o  add an examples directory with some nasty 1.3 cases
  + *              o  made Main.java use buffered IO and a Reader for Unicode support
  + *              o  supports UNICODE?
  + *                 Using Unicode charVocabulay makes code file big, but only
  + *                 in the bitsets at the end. I need to make ANTLR generate
  + *                 unicode bitsets more efficiently.
    * Version 1.19 (April 25, 2002)
  - *		Terence added in nice fixes by John Pybus concerning floating
  - *		constants and problems with super() calls.  John did a nice
  - *		reorg of the primary/postfix expression stuff to read better
  - *		and makes f.g.super() parse properly (it was METHOD_CALL not
  - *		a SUPER_CTOR_CALL).  Also:
  + *              Terence added in nice fixes by John Pybus concerning floating
  + *              constants and problems with super() calls.  John did a nice
  + *              reorg of the primary/postfix expression stuff to read better
  + *              and makes f.g.super() parse properly (it was METHOD_CALL not
  + *              a SUPER_CTOR_CALL).  Also:
    *
  - *		o  "finally" clause was a root...made it a child of "try"
  - *		o  Added stuff for asserts too for Java 1.4, but *commented out*
  - *		   as it is not backward compatible.
  + *              o  "finally" clause was a root...made it a child of "try"
  + *              o  Added stuff for asserts too for Java 1.4, but *commented out*
  + *                 as it is not backward compatible.
    *
    * Version 1.20 (October 27, 2002)
    *
  - *	  Terence ended up reorging John Pybus' stuff to
  - *	  remove some nondeterminisms and some syntactic predicates.
  - *	  Note that the grammar is stricter now; e.g., this(...) must
  - *	be the first statement.
  + *        Terence ended up reorging John Pybus' stuff to
  + *        remove some nondeterminisms and some syntactic predicates.
  + *        Note that the grammar is stricter now; e.g., this(...) must
  + *      be the first statement.
    *
  - *	  Trinary ?: operator wasn't working as array name:
  - *		  (isBig ? bigDigits : digits)[i];
  + *        Trinary ?: operator wasn't working as array name:
  + *                (isBig ? bigDigits : digits)[i];
    *
  - *	  Checked parser/tree parser on source for
  - *		  Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4,
  - *		and the 110k-line jGuru server source.
  + *        Checked parser/tree parser on source for
  + *                Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4,
  + *              and the 110k-line jGuru server source.
    *
    * Version 1.21 (October 17, 2003)
    *  Fixed lots of problems including:
  
positive.code: 
  class GroovyRecognizer extends Parser;
  options {
  	k = 3;							// three token lookahead
  	exportVocab=Groovy;				// Call its vocabulary "Groovy"
  	codeGenMakeSwitchThreshold = 2;	// Some optimizations
  	codeGenBitsetTestThreshold = 3;
  	defaultErrorHandler = false;	// Don't generate parser error handlers
  	buildAST = true;
  //	ASTLabelType = "GroovyAST"; 
  }
  
  tokens {
  	BLOCK; MODIFIERS; OBJBLOCK; SLIST; METHOD_DEF; VARIABLE_DEF;
  	INSTANCE_INIT; STATIC_INIT; TYPE; CLASS_DEF; INTERFACE_DEF;
  	PACKAGE_DEF; ARRAY_DECLARATOR; EXTENDS_CLAUSE; IMPLEMENTS_CLAUSE;
  	PARAMETERS; PARAMETER_DEF; LABELED_STAT; TYPECAST; INDEX_OP;
  	POST_INC; POST_DEC; METHOD_CALL; EXPR;
  	IMPORT; UNARY_MINUS; UNARY_PLUS; CASE_GROUP; ELIST; FOR_INIT; FOR_CONDITION;
  	FOR_ITERATOR; EMPTY_STAT; FINAL="final"; ABSTRACT="abstract";
  UNUSED_GOTO="goto"; UNUSED_CONST="const"; UNUSED_DO="do";
  	STRICTFP="strictfp"; SUPER_CTOR_CALL; CTOR_CALL; CTOR_IDENT; VARIABLE_PARAMETER_DEF;
  STRING_CONSTRUCTOR; STRING_CTOR_MIDDLE;
  CLOSED_BLOCK; IMPLICIT_PARAMETERS; DEF="def";
  SELECT_SLOT; REFLECT_MEMBER; DYNAMIC_MEMBER;
  LABELED_ARG; SPREAD_ARG; OPTIONAL_ARG; SCOPE_ESCAPE;
  LIST_CONSTRUCTOR; MAP_CONSTRUCTOR;
  FOR_IN_ITERABLE; RANGE_EXCLUSIVE;
  	STATIC_IMPORT; ENUM_DEF; ENUM_CONSTANT_DEF; FOR_EACH_CLAUSE; ANNOTATION_DEF; ANNOTATIONS;
  	ANNOTATION; ANNOTATION_MEMBER_VALUE_PAIR; ANNOTATION_FIELD_DEF; ANNOTATION_ARRAY_INIT;
  	TYPE_ARGUMENTS; TYPE_ARGUMENT; TYPE_PARAMETERS; TYPE_PARAMETER; WILDCARD_TYPE;
  	TYPE_UPPER_BOUNDS; TYPE_LOWER_BOUNDS;
  }
  
  {
  	/** This factory is the correct way to wire together a Groovy parser and lexer. */
  	public static GroovyRecognizer make(GroovyLexer lexer) {
  		GroovyRecognizer parser = new GroovyRecognizer(lexer.plumb());
  		// TO DO: set up a common error-handling control block, to avoid excessive tangle between these guys
  		parser.lexer = lexer;
  		lexer.parser = parser;
  		parser.setASTNodeClass("org.codehaus.groovy.antlr.GroovySourceAST");
  	 parser.warningList = new ArrayList();
  		return parser;
  	}
  	// Create a scanner that reads from the input stream passed to us...
  	public static GroovyRecognizer make(InputStream in) { return make(new GroovyLexer(in)); }
  	public static GroovyRecognizer make(Reader in) { return make(new GroovyLexer(in)); }
  	public static GroovyRecognizer make(InputBuffer in) { return make(new GroovyLexer(in)); }
  	public static GroovyRecognizer make(LexerSharedInputState in) { return make(new GroovyLexer(in)); }
  
  	List warningList;
  	public List getWarningList() { return warningList; }
  
  	GroovyLexer lexer;
  public GroovyLexer getLexer() { return lexer; }
  	public void setFilename(String f) { super.setFilename(f); lexer.setFilename(f); }
  
  	// stuff to adjust ANTLR's tracing machinery
      public static boolean tracing = false;  // only effective if antlr.Tool is run with -traceParser
      public void traceIn(String rname) throws TokenStreamException {
          if (!GroovyRecognizer.tracing)  return;
  
negative.code: class GroovyLexer extends Lexer;
  
  options {
      exportVocab=Groovy;             // call the vocabulary "Groovy"
      testLiterals=false;             // don't automatically test for literals
      k=4;                                    // four characters of lookahead
      charVocabulary='\u0003'..'\uFFFF';
      // without inlining some bitset tests, couldn't do unicode;
      // I need to make ANTLR generate smaller bitsets; see
      // bottom of GroovyLexer.java
      codeGenBitsetTestThreshold=20;
  }
  
  {
      /** flag for enabling the "assert" keyword */
      private boolean assertEnabled = true;
      /** flag for enabling the "enum" keyword */
      private boolean enumEnabled = true;
  
      /** Enable the "assert" keyword */
      public void enableAssert(boolean shouldEnable) { assertEnabled = shouldEnable; }
      /** Query the "assert" keyword state */
      public boolean isAssertEnabled() { return assertEnabled; }
      /** Enable the "enum" keyword */
      public void enableEnum(boolean shouldEnable) { enumEnabled = shouldEnable; }
      /** Query the "enum" keyword state */
      public boolean isEnumEnabled() { return enumEnabled; }
  
  
  /** Bumped when inside '[x]' or '(x)', reset inside '{x}'.  See ONE_NL.  */
      protected int parenLevel = 0;
      protected int suppressNewline = 0;  // be really mean to newlines inside strings
      protected static final int SCS_TRIPLE = 1, SCS_VAL = 2, SCS_LIT = 4, SCS_LIMIT = 8;
      protected int stringCtorState = 0;  // hack string constructor boundaries
      /** Push parenLevel here and reset whenever inside '{x}'. */
      protected ArrayList parenLevelStack = new ArrayList();
      protected Token lastToken = Token.badToken;
  
      protected void pushParenLevel() {
          parenLevelStack.add(new Integer(parenLevel*8 + stringCtorState));
          parenLevel = 0;
          stringCtorState = 0;
      }
      protected void popParenLevel() {
          int npl = parenLevelStack.size();
          if (npl == 0)  return;
          int i = ((Integer) parenLevelStack.remove(--npl)).intValue();
          parenLevel      = i / SCS_LIMIT;
          stringCtorState = i % SCS_LIMIT;
      }
  
      protected void restartStringCtor(boolean expectLiteral) {
          if (stringCtorState != 0) {
              stringCtorState = (expectLiteral? SCS_LIT: SCS_VAL) + (stringCtorState & SCS_TRIPLE);
          }
      }
  
      void newlineCheck() throws RecognitionException {
          if (suppressNewline > 0) {
              suppressNewline = 0;
              require(suppressNewline == 0,
                  "end of line reached within a simple string 'x' or \"x\"",
                  "for multi-line literals, use triple quotes '''x''' or \"\"\"x\"\"\"");
          }
          newline();
      }
  
      /** This is a bit of plumbing which resumes collection of string constructor bodies,
       *  after an embedded expression has been parsed.
       *  Usage:  new GroovyRecognizer(new GroovyLexer(in).plumb()).
       */
      public TokenStream plumb() {
          return new TokenStream() {
              public Token nextToken() throws TokenStreamException {
                  if (stringCtorState >= SCS_LIT) {
                      // This goo is modeled upon the ANTLR code for nextToken:
                      boolean tripleQuote = (stringCtorState & SCS_TRIPLE) != 0;
                      stringCtorState = 0;  // get out of this mode, now
                      resetText();
                      try {
                          mSTRING_CTOR_END(true, /*fromStart:*/false, tripleQuote);
                          return lastToken = _returnToken;
                      } catch (RecognitionException e) {
                          throw new TokenStreamRecognitionException(e);
                      } catch (CharStreamException cse) {
                          if ( cse instanceof CharStreamIOException ) {
                              throw new TokenStreamIOException(((CharStreamIOException)cse).io);
                          }
                          else {
                              throw new TokenStreamException(cse.getMessage());
                          }
                      }
                  }
                  return lastToken = GroovyLexer.this.nextToken();
              }
          };
      }
  
          // stuff to adjust ANTLR's tracing machinery
      public static boolean tracing = false;  // only effective if antlr.Tool is run with -traceLexer
      public void traceIn(String rname) throws CharStreamException {
          if (!GroovyLexer.tracing)  return;
  