Logo Search packages:      
Sourcecode: eclipse version File versions  Download package

Parser.java

/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Tom Tromey - patch for readTable(String) as described in http://bugs.eclipse.org/bugs/show_bug.cgi?id=32196
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.parser;

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.ResourceBundle;

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.ast.*;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
import org.eclipse.jdt.internal.compiler.env.IGenericType;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.CompilerModifiers;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.parser.diagnose.DiagnoseParser;
import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
import org.eclipse.jdt.internal.compiler.util.Messages;
import org.eclipse.jdt.internal.compiler.util.Util;

public class Parser implements  ParserBasicInformation, TerminalTokens, CompilerModifiers, OperatorIds, TypeIds {
      protected static final int THIS_CALL = ExplicitConstructorCall.This;
      protected static final int SUPER_CALL = ExplicitConstructorCall.Super;

      public static char asb[] = null;
      public static char asr[] = null;
      //ast stack
      protected final static int AstStackIncrement = 100;
      public static char base_action[] = null;
      public static final int BracketKinds = 3;
    
      public static short check_table[] = null;
      public static final int CurlyBracket = 2;
      private static final boolean DEBUG = false;
      private static final String EOF_TOKEN = "$eof" ; //$NON-NLS-1$
      private static final String ERROR_TOKEN = "$error" ; //$NON-NLS-1$
      //expression stack
      protected final static int ExpressionStackIncrement = 100;

      protected final static int GenericsStackIncrement = 10;
    
      private final static String FILEPREFIX = "parser"; //$NON-NLS-1$
    public static char in_symb[] = null;
      private static final String INVALID_CHARACTER = "Invalid Character" ; //$NON-NLS-1$
      public static char lhs[] =  null;

      public static String name[] = null;
      public static char nasb[] = null;
      public static char nasr[] = null;
      public static char non_terminal_index[] = null;
      private final static String READABLE_NAMES_FILE = "readableNames"; //$NON-NLS-1$
      private final static String READABLE_NAMES_FILE_NAME =
            "org.eclipse.jdt.internal.compiler.parser." + READABLE_NAMES_FILE; //$NON-NLS-1$
      public static String readableName[] = null;
      
      public static byte rhs[] = null;
      
      public static long rules_compliance[] =  null;
      
      public static final int RoundBracket = 0;
    
    public static byte scope_la[] = null;
    public static char scope_lhs[] = null;
      
      public static char scope_prefix[] = null;
    public static char scope_rhs[] = null;
    public static char scope_state[] = null;

    public static char scope_state_set[] = null;
    public static char scope_suffix[] = null;
      public static final int SquareBracket = 1;
            
      //internal data for the automat 
      protected final static int StackIncrement = 255;
      
      public static char term_action[] = null;
      public static byte term_check[] = null;

      public static char terminal_index[] = null;

      private static final String UNEXPECTED_EOF = "Unexpected End Of File" ; //$NON-NLS-1$
      public static boolean VERBOSE_RECOVERY = false;



      protected int astLengthPtr;
      protected int[] astLengthStack;
      protected int astPtr;
      protected ASTNode[] astStack = new ASTNode[AstStackIncrement];
      public CompilationUnitDeclaration compilationUnit; /*the result from parse()*/
      protected RecoveredElement currentElement;
      public int currentToken;
      protected boolean diet = false; //tells the scanner to jump over some parts of the code/expressions like method bodies
      protected int dietInt = 0; // if > 0 force the none-diet-parsing mode (even if diet if requested) [field parsing with anonymous inner classes...]
      protected int endPosition; //accurate only when used ! (the start position is pushed into intStack while the end the current one)
      protected int endStatementPosition;
      protected int expressionLengthPtr;
      protected int[] expressionLengthStack;
      protected int expressionPtr;
      protected Expression[] expressionStack = new Expression[ExpressionStackIncrement];
      public int firstToken ; // handle for multiple parsing goals

      // generics management
      protected int genericsIdentifiersLengthPtr;
      protected int[] genericsIdentifiersLengthStack = new int[GenericsStackIncrement];
      protected int genericsLengthPtr;
      protected int[] genericsLengthStack = new int[GenericsStackIncrement];
      protected int genericsPtr;
      protected ASTNode[] genericsStack = new ASTNode[GenericsStackIncrement];
      
      protected boolean hasError;
      protected boolean hasReportedError;

      //identifiers stacks 
      protected int identifierLengthPtr;
      protected int[] identifierLengthStack;
      protected long[] identifierPositionStack;
      protected int identifierPtr;
      protected char[][] identifierStack;
      
      protected boolean ignoreNextOpeningBrace;
      //positions , dimensions , .... (int stacks)
      protected int intPtr;
      protected int[] intStack;
      public int lastAct ; //handle for multiple parsing goals

      //error recovery management
      protected int lastCheckPoint;
      protected int lastErrorEndPosition;
      protected int lastErrorEndPositionBeforeRecovery = -1;
      protected int lastIgnoredToken, nextIgnoredToken;
      protected int listLength; // for recovering some incomplete list (interfaces, throws or parameters)
      protected int listTypeParameterLength; // for recovering some incomplete list (type parameters)
      protected int lParenPos,rParenPos; //accurate only when used !
      protected int modifiers;
      protected int modifiersSourceStart;
      protected int[] nestedMethod; //the ptr is nestedType
      protected int nestedType, dimensions;
      ASTNode [] noAstNodes = new ASTNode[AstStackIncrement];
      Expression [] noExpressions = new Expression[ExpressionStackIncrement];
      //modifiers dimensions nestedType etc.......
      protected boolean optimizeStringLiterals =true;
      protected CompilerOptions options;
      protected ProblemReporter problemReporter;
      protected int rBraceStart, rBraceEnd, rBraceSuccessorStart; //accurate only when used !
      protected int realBlockPtr;
      protected int[] realBlockStack;
      protected int recoveredStaticInitializerStart;
      public ReferenceContext referenceContext;
      public boolean reportOnlyOneSyntaxError = false;
      public boolean reportSyntaxErrorIsRequired = true;
      protected boolean restartRecovery;
      //scanner token 
      public Scanner scanner;
      protected int[] stack = new int[StackIncrement];
      protected int stateStackTop;
      protected int synchronizedBlockSourceStart;
      protected int[] variablesCounter;

      // javadoc
      public Javadoc javadoc;
      public JavadocParser javadocParser;
      // used for recovery
      protected int lastJavadocEnd;
      
      static {
            try{
                  initTables();
            } catch(java.io.IOException ex){
                  throw new ExceptionInInitializerError(ex.getMessage());
            }
      }
public static int asi(int state) {

      return asb[original_state(state)]; 
}
public final static short base_check(int i) {
      return check_table[i - (NUM_RULES + 1)];
}
private final static void buildFile(String filename, List listToDump) throws java.io.IOException {
      BufferedWriter writer = new BufferedWriter(new FileWriter(filename));
      for (Iterator iterator = listToDump.iterator(); iterator.hasNext(); ) {
            writer.write(String.valueOf(iterator.next()));
      }
      writer.flush();
      writer.close();
      System.out.println(filename + " creation complete"); //$NON-NLS-1$
}
private final static String[] buildFileForName(String filename, String contents) throws java.io.IOException {
      String[] result = new String[contents.length()];
      result[0] = null;
      int resultCount = 1;
      
      StringBuffer buffer = new StringBuffer();
      
      int start = contents.indexOf("name[]"); //$NON-NLS-1$
      start = contents.indexOf('\"', start); 
      int end = contents.indexOf("};", start); //$NON-NLS-1$
      
      contents = contents.substring(start, end);
      
      boolean addLineSeparator = false;
      int tokenStart = -1;
      StringBuffer currentToken = new StringBuffer();
      for (int i = 0; i < contents.length(); i++) {
            char c = contents.charAt(i);
            if(c == '\"') {
                  if(tokenStart == -1) {
                        tokenStart = i + 1;     
                  } else {
                        if(addLineSeparator) {
                              buffer.append('\n');
                              result[resultCount++] = currentToken.toString();
                              currentToken = new StringBuffer();
                        }
                        String token = contents.substring(tokenStart, i);
                        if(token.equals(ERROR_TOKEN)){
                              token = INVALID_CHARACTER;
                        } else if(token.equals(EOF_TOKEN)) {
                              token = UNEXPECTED_EOF;
                        }
                        buffer.append(token);
                        currentToken.append(token);
                        addLineSeparator = true;
                        tokenStart = -1;
                  }
            }
            if(tokenStart == -1 && c == '+'){
                  addLineSeparator = false;
            }
      }
      if(currentToken.length() > 0) {
            result[resultCount++] = currentToken.toString();
      }
      
      buildFileForTable(filename, buffer.toString().toCharArray());
      
      System.arraycopy(result, 0, result = new String[resultCount], 0, resultCount);
      return result;
}
private static void buildFileForReadableName(
      String file,
      char[] newLhs,
      char[] newNonTerminalIndex,
      String[] newName,
      String[] tokens) throws java.io.IOException {

      ArrayList entries = new ArrayList();
      
      boolean[] alreadyAdded = new boolean[newName.length];
      
      for (int i = 0; i < tokens.length; i = i + 3) {
            if("1".equals(tokens[i])) { //$NON-NLS-1$
                  int index = newNonTerminalIndex[newLhs[Integer.parseInt(tokens[i + 1])]];
                  StringBuffer buffer = new StringBuffer();
                  if(!alreadyAdded[index]) {
                        alreadyAdded[index] = true;
                        buffer.append(newName[index]);
                        buffer.append('=');
                        buffer.append(tokens[i+2].trim());
                        buffer.append('\n');
                        entries.add(String.valueOf(buffer));
                  }
            }
      }
      int i = 1;
      while(!INVALID_CHARACTER.equals(newName[i])) i++;
      i++;
      for (; i < alreadyAdded.length; i++) {
            if(!alreadyAdded[i]) {
                  System.out.println(newName[i] + " has no readable name"); //$NON-NLS-1$
            }
      }
      Collections.sort(entries);
      buildFile(file, entries);
}
private static void buildFileForCompliance(
            String file,
            int length,
            String[] tokens) throws java.io.IOException {

            byte[] result = new byte[length * 8];
            
            for (int i = 0; i < tokens.length; i = i + 3) {
                  if("2".equals(tokens[i])) { //$NON-NLS-1$
                        int index = Integer.parseInt(tokens[i + 1]);
                        String token = tokens[i + 2].trim();
                        long compliance = 0;
                        if("1.4".equals(token)) { //$NON-NLS-1$
                              compliance = ClassFileConstants.JDK1_4;
                        } else if("1.5".equals(token)) { //$NON-NLS-1$
                              compliance = ClassFileConstants.JDK1_5;
                        } else if("recovery".equals(token)) { //$NON-NLS-1$
                              compliance = ClassFileConstants.JDK_DEFERRED;
                        }
                        
                        int j = index * 8;
                        result[j] =       (byte)(compliance >>> 56);
                        result[j + 1] = (byte)(compliance >>> 48);
                        result[j + 2] = (byte)(compliance >>> 40);
                        result[j + 3] = (byte)(compliance >>> 32);
                        result[j + 4] = (byte)(compliance >>> 24);
                        result[j + 5] = (byte)(compliance >>> 16);
                        result[j + 6] = (byte)(compliance >>> 8);
                        result[j + 7] = (byte)(compliance);
                  }
            }

            buildFileForTable(file, result);
      }
private final static void buildFileForTable(String filename, byte[] bytes) throws java.io.IOException {
      java.io.FileOutputStream stream = new java.io.FileOutputStream(filename);
      stream.write(bytes);
      stream.close();
      System.out.println(filename + " creation complete"); //$NON-NLS-1$
}
private final static void buildFileForTable(String filename, char[] chars) throws java.io.IOException {

      byte[] bytes = new byte[chars.length * 2];
      for (int i = 0; i < chars.length; i++) {
            bytes[2 * i] = (byte) (chars[i] >>> 8);
            bytes[2 * i + 1] = (byte) (chars[i] & 0xFF);
      }

      java.io.FileOutputStream stream = new java.io.FileOutputStream(filename);
      stream.write(bytes);
      stream.close();
      System.out.println(filename + " creation complete"); //$NON-NLS-1$
}
private final static byte[] buildFileOfByteFor(String filename, String tag, String[] tokens) throws java.io.IOException {

      //transform the String tokens into chars before dumping then into file

      int i = 0;
      //read upto the tag
      while (!tokens[i++].equals(tag)){/*empty*/}
      //read upto the }
      
      byte[] bytes = new byte[tokens.length]; //can't be bigger
      int ic = 0;
      String token;
      while (!(token = tokens[i++]).equals("}")) { //$NON-NLS-1$
            int c = Integer.parseInt(token);
            bytes[ic++] = (byte) c;
      }

      //resize
      System.arraycopy(bytes, 0, bytes = new byte[ic], 0, ic);

      buildFileForTable(filename, bytes);
      return bytes;
}
private final static char[] buildFileOfIntFor(String filename, String tag, String[] tokens) throws java.io.IOException {

      //transform the String tokens into chars before dumping then into file

      int i = 0;
      //read upto the tag
      while (!tokens[i++].equals(tag)){/*empty*/}
      //read upto the }
      
      char[] chars = new char[tokens.length]; //can't be bigger
      int ic = 0;
      String token;
      while (!(token = tokens[i++]).equals("}")) { //$NON-NLS-1$
            int c = Integer.parseInt(token);
            chars[ic++] = (char) c;
      }

      //resize
      System.arraycopy(chars, 0, chars = new char[ic], 0, ic);

      buildFileForTable(filename, chars);
      return chars;
}
private final static void buildFileOfShortFor(String filename, String tag, String[] tokens) throws java.io.IOException {

      //transform the String tokens into chars before dumping then into file

      int i = 0;
      //read upto the tag
      while (!tokens[i++].equals(tag)){/*empty*/}
      //read upto the }
      
      char[] chars = new char[tokens.length]; //can't be bigger
      int ic = 0;
      String token;
      while (!(token = tokens[i++]).equals("}")) { //$NON-NLS-1$
            int c = Integer.parseInt(token);
            chars[ic++] = (char) (c + 32768);
      }

      //resize
      System.arraycopy(chars, 0, chars = new char[ic], 0, ic);

      buildFileForTable(filename, chars);
}
public final static void buildFilesFromLPG(String dataFilename, String dataFilename2)     throws java.io.IOException {

      //RUN THIS METHOD TO GENERATE PARSER*.RSC FILES

      //build from the lpg javadcl.java files that represents the parser tables
      //lhs check_table asb asr symbol_index

      //[org.eclipse.jdt.internal.compiler.parser.Parser.buildFilesFromLPG("d:/leapfrog/grammar/javadcl.java")]
      char[] contents = new char[] {};
      try {
            contents = Util.getFileCharContent(new File(dataFilename), null);
      } catch (IOException ex) {
            System.out.println(Messages.parser_incorrectPath); 
            return;
      }
      java.util.StringTokenizer st = 
            new java.util.StringTokenizer(new String(contents), " \t\n\r[]={,;");  //$NON-NLS-1$
      String[] tokens = new String[st.countTokens()];
      int j = 0;
      while (st.hasMoreTokens()) {
            tokens[j++] = st.nextToken();
      }
      final String prefix = FILEPREFIX;
      int i = 0;
      
      char[] newLhs = buildFileOfIntFor(prefix + (++i) + ".rsc", "lhs", tokens); //$NON-NLS-1$ //$NON-NLS-2$
      buildFileOfShortFor(prefix + (++i) + ".rsc", "check_table", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfIntFor(prefix + (++i) + ".rsc", "asb", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfIntFor(prefix + (++i) + ".rsc", "asr", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfIntFor(prefix + (++i) + ".rsc", "nasb", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfIntFor(prefix + (++i) + ".rsc", "nasr", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfIntFor(prefix + (++i) + ".rsc", "terminal_index", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      char[] newNonTerminalIndex = buildFileOfIntFor(prefix + (++i) + ".rsc", "non_terminal_index", tokens); //$NON-NLS-1$ //$NON-NLS-2$
      buildFileOfIntFor(prefix + (++i) + ".rsc", "term_action", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      
      buildFileOfIntFor(prefix + (++i) + ".rsc", "scope_prefix", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfIntFor(prefix + (++i) + ".rsc", "scope_suffix", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfIntFor(prefix + (++i) + ".rsc", "scope_lhs", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfIntFor(prefix + (++i) + ".rsc", "scope_state_set", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfIntFor(prefix + (++i) + ".rsc", "scope_rhs", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfIntFor(prefix + (++i) + ".rsc", "scope_state", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfIntFor(prefix + (++i) + ".rsc", "in_symb", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      
      byte[] newRhs = buildFileOfByteFor(prefix + (++i) + ".rsc", "rhs", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfByteFor(prefix + (++i) + ".rsc", "term_check", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      buildFileOfByteFor(prefix + (++i) + ".rsc", "scope_la", tokens); //$NON-NLS-2$ //$NON-NLS-1$
      
      String[] newName = buildFileForName(prefix + (++i) + ".rsc", new String(contents)); //$NON-NLS-1$
      
      contents = new char[] {};
      try {
            contents = Util.getFileCharContent(new File(dataFilename2), null);
      } catch (IOException ex) {
            System.out.println(Messages.parser_incorrectPath); 
            return;
      }
      st = new java.util.StringTokenizer(new String(contents), "\t\n\r=#");  //$NON-NLS-1$
      tokens = new String[st.countTokens()];
      j = 0;
      while (st.hasMoreTokens()) {
            tokens[j++] = st.nextToken();
      }
      
      buildFileForCompliance(prefix + (++i) + ".rsc", newRhs.length, tokens);//$NON-NLS-1$
      buildFileForReadableName(READABLE_NAMES_FILE+".properties", newLhs, newNonTerminalIndex, newName, tokens);//$NON-NLS-1$
      
      System.out.println(Messages.parser_moveFiles); 
}
public static int in_symbol(int state) {
      return in_symb[original_state(state)];
}
public final static void initTables() throws java.io.IOException {

      final String prefix = FILEPREFIX;
      int i = 0;
      lhs = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      char[] chars = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      check_table = new short[chars.length];
      for (int c = chars.length; c-- > 0;) {
            check_table[c] = (short) (chars[c] - 32768);
      }
      asb = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      asr = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      nasb = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      nasr = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      terminal_index = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      non_terminal_index = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      term_action = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      
      scope_prefix = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      scope_suffix = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      scope_lhs = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      scope_state_set = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      scope_rhs = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      scope_state = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      in_symb = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      
      rhs = readByteTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      term_check = readByteTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      scope_la = readByteTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      
      name = readNameTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      
      rules_compliance = readLongTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
      
      readableName = readReadableNameTable(READABLE_NAMES_FILE_NAME);
      
      base_action = lhs;
}
public static int nasi(int state) {
      return nasb[original_state(state)];
}
public static int ntAction(int state, int sym) {
      return base_action[state + sym];
}
protected static int original_state(int state) {
      return -base_check(state);
}
protected static byte[] readByteTable(String filename) throws java.io.IOException {

      //files are located at Parser.class directory

      InputStream stream = Parser.class.getResourceAsStream(filename);
      if (stream == null) {
            throw new java.io.IOException(Messages.bind(Messages.parser_missingFile, filename)); 
      }
      byte[] bytes = null;
      try {
            stream = new BufferedInputStream(stream);
            bytes = Util.getInputStreamAsByteArray(stream, -1);
      } finally {
            try {
                  stream.close();
            } catch (IOException e) {
                  // ignore
            }
      }
      return bytes;
}
      
protected static String[] readNameTable(String filename) throws java.io.IOException {
      char[] contents = readTable(filename);
      char[][] nameAsChar = CharOperation.splitOn('\n', contents);

      String[] result = new String[nameAsChar.length + 1];
      result[0] = null;
      for (int i = 0; i < nameAsChar.length; i++) {
            result[i + 1] = new String(nameAsChar[i]);
      }
      
      return result;
}
protected static String[] readReadableNameTable(String filename) {
      String[] result = new String[name.length];

      ResourceBundle bundle;
      try {
            bundle = ResourceBundle.getBundle(filename, Locale.getDefault());
      } catch(MissingResourceException e) {
            System.out.println("Missing resource : " + filename.replace('.', '/') + ".properties for locale " + Locale.getDefault()); //$NON-NLS-1$//$NON-NLS-2$
            throw e;
      }
      for (int i = 0; i < NT_OFFSET + 1; i++) {
            result[i] = name[i];
      }
      for (int i = NT_OFFSET; i < name.length; i++) {
            try {
                  String n = bundle.getString(name[i]);
                  if(n != null && n.length() > 0) {
                        result[i] = n;
                  } else {
                        result[i] = name[i];
                  }
            } catch(MissingResourceException e) {
                  result[i] = name[i];
            }
      }
      return result;
}
protected static char[] readTable(String filename) throws java.io.IOException {

      //files are located at Parser.class directory

      InputStream stream = Parser.class.getResourceAsStream(filename);
      if (stream == null) {
            throw new java.io.IOException(Messages.bind(Messages.parser_missingFile, filename)); 
      }
      byte[] bytes = null;
      try {
            stream = new BufferedInputStream(stream);
            bytes = Util.getInputStreamAsByteArray(stream, -1);
      } finally {
            try {
                  stream.close();
            } catch (IOException e) {
                  // ignore
            }
      }

      //minimal integrity check (even size expected)
      int length = bytes.length;
      if (length % 2 != 0)
            throw new java.io.IOException(Messages.bind(Messages.parser_corruptedFile, filename)); 

      // convert bytes into chars
      char[] chars = new char[length / 2];
      int i = 0;
      int charIndex = 0;

      while (true) {
            chars[charIndex++] = (char) (((bytes[i++] & 0xFF) << 8) + (bytes[i++] & 0xFF));
            if (i == length)
                  break;
      }
      return chars;
}
protected static long[] readLongTable(String filename) throws java.io.IOException {

      //files are located at Parser.class directory

      InputStream stream = Parser.class.getResourceAsStream(filename);
      if (stream == null) {
            throw new java.io.IOException(Messages.bind(Messages.parser_missingFile, filename)); 
      }
      byte[] bytes = null;
      try {
            stream = new BufferedInputStream(stream);
            bytes = Util.getInputStreamAsByteArray(stream, -1);
      } finally {
            try {
                  stream.close();
            } catch (IOException e) {
                  // ignore
            }
      }

      //minimal integrity check (even size expected)
      int length = bytes.length;
      if (length % 8 != 0)
            throw new java.io.IOException(Messages.bind(Messages.parser_corruptedFile, filename)); 

      // convert bytes into longs
      long[] longs = new long[length / 8];
      int i = 0;
      int longIndex = 0;

      while (true) {
            longs[longIndex++] = 
              (((long) (bytes[i++] & 0xFF)) << 56)
            + (((long) (bytes[i++] & 0xFF)) << 48)
            + (((long) (bytes[i++] & 0xFF)) << 40)
            + (((long) (bytes[i++] & 0xFF)) << 32)
            + (((long) (bytes[i++] & 0xFF)) << 24)
            + (((long) (bytes[i++] & 0xFF)) << 16)
            + (((long) (bytes[i++] & 0xFF)) << 8)
            + (bytes[i++] & 0xFF);
            
            if (i == length)
                  break;
      }
      return longs;
}
public static int tAction(int state, int sym) {
      return term_action[term_check[base_action[state]+sym] == sym ? base_action[state] + sym : base_action[state]];
}

public Parser(ProblemReporter problemReporter, boolean optimizeStringLiterals) {
            
      this.problemReporter = problemReporter;
      this.options = problemReporter.options;
      this.optimizeStringLiterals = optimizeStringLiterals;
      this.initializeScanner();
      this.astLengthStack = new int[50];
      this.expressionLengthStack = new int[30];
      this.intStack = new int[50];
      this.identifierStack = new char[30][];
      this.identifierLengthStack = new int[30];
      this.nestedMethod = new int[30];
      this.realBlockStack = new int[30];
      this.identifierPositionStack = new long[30];
      this.variablesCounter = new int[30];
      
      // javadoc support
      this.javadocParser = new JavadocParser(this);   
}
protected void annotationRecoveryCheckPoint(int start, int end) {
      if(this.lastCheckPoint > start && this.lastCheckPoint < end) {
            this.lastCheckPoint = end + 1;
      }
}
public void arrayInitializer(int length) {
      //length is the size of the array Initializer
      //expressionPtr points on the last elt of the arrayInitializer, 
      // in other words, it has not been decremented yet.

      ArrayInitializer ai = new ArrayInitializer();
      if (length != 0) {
            this.expressionPtr -= length;
            System.arraycopy(this.expressionStack, this.expressionPtr + 1, ai.expressions = new Expression[length], 0, length);
      }
      pushOnExpressionStack(ai);
      //positionning
      ai.sourceEnd = this.endStatementPosition;
      ai.sourceStart = this.intStack[this.intPtr--];
}
protected void blockReal() {
      // See consumeLocalVariableDeclarationStatement in case of change: duplicated code
      // increment the amount of declared variables for this block
      this.realBlockStack[this.realBlockPtr]++;
}
/*
 * Build initial recovery state.
 * Recovery state is inferred from the current state of the parser (reduced node stack).
 */
public RecoveredElement buildInitialRecoveryState(){

      /* initialize recovery by retrieving available reduced nodes 
       * also rebuild bracket balance 
       */
      this.lastCheckPoint = 0;
      this.lastErrorEndPositionBeforeRecovery = this.scanner.currentPosition;

      RecoveredElement element = null;
      if (this.referenceContext instanceof CompilationUnitDeclaration){
            element = new RecoveredUnit(this.compilationUnit, 0, this);
            
            /* ignore current stack state, since restarting from the beginnning 
               since could not trust simple brace count */
            if (true){ // experimenting restart recovery from scratch
                  this.compilationUnit.currentPackage = null;
                  this.compilationUnit.imports = null;
                  this.compilationUnit.types = null;
                  this.currentToken = 0;
                  this.listLength = 0;
                  this.listTypeParameterLength = 0;
                  this.endPosition = 0;
                  this.endStatementPosition = 0;
                  return element;
            }
            if (this.compilationUnit.currentPackage != null){
                  this.lastCheckPoint = this.compilationUnit.currentPackage.declarationSourceEnd+1;
            }
            if (this.compilationUnit.imports != null){
                  this.lastCheckPoint = this.compilationUnit.imports[this.compilationUnit.imports.length -1].declarationSourceEnd+1;            
            }
      } else {
            if (this.referenceContext instanceof AbstractMethodDeclaration){
                  element = new RecoveredMethod((AbstractMethodDeclaration) this.referenceContext, null, 0, this);
                  this.lastCheckPoint = ((AbstractMethodDeclaration) this.referenceContext).bodyStart;
            } else {
                  /* Initializer bodies are parsed in the context of the type declaration, we must thus search it inside */
                  if (this.referenceContext instanceof TypeDeclaration){
                        TypeDeclaration type = (TypeDeclaration) this.referenceContext;
                        for (int i = 0; i < type.fields.length; i++){
                              FieldDeclaration field = type.fields[i];                          
                              if (field != null
                                    && field.getKind() == AbstractVariableDeclaration.INITIALIZER
                                    && field.declarationSourceStart <= this.scanner.initialPosition
                                    && this.scanner.initialPosition <= field.declarationSourceEnd
                                    && this.scanner.eofPosition <= field.declarationSourceEnd+1){
                                    element = new RecoveredInitializer(field, null, 1, this);
                                    this.lastCheckPoint = field.declarationSourceStart;                           
                                    break;
                              }
                        }
                  } 
            }
      }

      if (element == null) return element;
      
      for(int i = 0; i <= this.astPtr; i++){
            ASTNode node = this.astStack[i];
            if (node instanceof AbstractMethodDeclaration){
                  AbstractMethodDeclaration method = (AbstractMethodDeclaration) node;
                  if (method.declarationSourceEnd == 0){
                        element = element.add(method, 0);
                        this.lastCheckPoint = method.bodyStart;
                  } else {
                        element = element.add(method, 0);
                        this.lastCheckPoint = method.declarationSourceEnd + 1;
                  }
                  continue;
            }
            if (node instanceof Initializer){
                  Initializer initializer = (Initializer) node;
                  if (initializer.declarationSourceEnd == 0){
                        element = element.add(initializer, 1);
                        this.lastCheckPoint = initializer.sourceStart;                    
                  } else {
                        element = element.add(initializer, 0);
                        this.lastCheckPoint = initializer.declarationSourceEnd + 1;
                  }
                  continue;
            }           
            if (node instanceof FieldDeclaration){
                  FieldDeclaration field = (FieldDeclaration) node;
                  if (field.declarationSourceEnd == 0){
                        element = element.add(field, 0);
                        if (field.initialization == null){
                              this.lastCheckPoint = field.sourceEnd + 1;
                        } else {
                              this.lastCheckPoint = field.initialization.sourceEnd + 1;
                        }
                  } else {
                        element = element.add(field, 0);
                        this.lastCheckPoint = field.declarationSourceEnd + 1;
                  }
                  continue;
            }
            if (node instanceof TypeDeclaration){
                  TypeDeclaration type = (TypeDeclaration) node;
                  if (type.declarationSourceEnd == 0){
                        element = element.add(type, 0);     
                        this.lastCheckPoint = type.bodyStart;
                  } else {
                        element = element.add(type, 0);                       
                        this.lastCheckPoint = type.declarationSourceEnd + 1;
                  }
                  continue;
            }
            if (node instanceof ImportReference){
                  ImportReference importRef = (ImportReference) node;
                  element = element.add(importRef, 0);
                  this.lastCheckPoint = importRef.declarationSourceEnd + 1;
            }
      }
      return element;
}

protected void checkAndSetModifiers(int flag){
      /*modify the current modifiers buffer.
      When the startPosition of the modifiers is 0
      it means that the modifier being parsed is the first
      of a list of several modifiers. The startPosition
      is zeroed when a copy of modifiers-buffer is push
      onto the this.astStack. */

      if ((this.modifiers & flag) != 0){ // duplicate modifier
            this.modifiers |= AccAlternateModifierProblem;
      }
      this.modifiers |= flag;
                  
      if (this.modifiersSourceStart < 0) this.modifiersSourceStart = this.scanner.startPosition;
}
public void checkComment() {

      // discard obsolete comments while inside methods or fields initializer (see bug 74369)
      if (!(this.diet && this.dietInt==0) && this.scanner.commentPtr >= 0) {
            flushCommentsDefinedPriorTo(this.endStatementPosition);
      }
      
      int lastComment = this.scanner.commentPtr;
      
      if (this.modifiersSourceStart >= 0) {
            // eliminate comments located after modifierSourceStart if positionned
            while (lastComment >= 0 && this.scanner.commentStarts[lastComment] > this.modifiersSourceStart) lastComment--;
      }
      if (lastComment >= 0) {
            // consider all remaining leading comments to be part of current declaration
            this.modifiersSourceStart = this.scanner.commentStarts[0]; 
      
            // check deprecation in last comment if javadoc (can be followed by non-javadoc comments which are simply ignored)      
            while (lastComment >= 0 && this.scanner.commentStops[lastComment] < 0) lastComment--; // non javadoc comment have negative end positions
            if (lastComment >= 0 && this.javadocParser != null) {
                  int commentEnd = this.scanner.commentStops[lastComment] - 1; //stop is one over,
                  // do not report problem before last parsed comment while recovering code...
                  this.javadocParser.reportProblems = this.currentElement == null || commentEnd > this.lastJavadocEnd;
                  if (this.javadocParser.checkDeprecation(lastComment)) {
                        checkAndSetModifiers(AccDeprecated);
                  }
                  this.javadoc = this.javadocParser.docComment;   // null if check javadoc is not activated
                  if (currentElement == null) this.lastJavadocEnd = commentEnd;
            }
      }
}
protected void checkNonExternalizedStringLiteral() {
      if (this.scanner.wasNonExternalizedStringLiteral) {
            StringLiteral[] literals = this.scanner.nonNLSStrings;
            // could not reproduce, but this is the only NPE
            // added preventive null check see PR 9035
            if (literals != null) {
                  for (int i = 0, max = literals.length; i < max; i++) {
                        problemReporter().nonExternalizedStringLiteral(literals[i]);
                  }
            }
            this.scanner.wasNonExternalizedStringLiteral = false;
      }
}
protected void checkNonNLSAfterBodyEnd(int declarationEnd){
      if(this.scanner.currentPosition - 1 <= declarationEnd) {
            this.scanner.eofPosition = declarationEnd < Integer.MAX_VALUE ? declarationEnd + 1 : declarationEnd;
            try {
                  while(this.scanner.getNextToken() != TokenNameEOF){/*empty*/}
                  checkNonExternalizedStringLiteral();
            } catch (InvalidInputException e) {
                  // Nothing to do
            }
      }
}
protected void classInstanceCreation(boolean isQualified) {
      // ClassInstanceCreationExpression ::= 'new' ClassType '(' ArgumentListopt ')' ClassBodyopt

      // ClassBodyopt produces a null item on the astStak if it produces NO class body
      // An empty class body produces a 0 on the length stack.....

      AllocationExpression alloc;
      int length;
      if (((length = this.astLengthStack[this.astLengthPtr--]) == 1)
            && (this.astStack[this.astPtr] == null)) {
            //NO ClassBody
            this.astPtr--;
            if (isQualified) {
                  alloc = new QualifiedAllocationExpression();
            } else {
                  alloc = new AllocationExpression();
            }
            alloc.sourceEnd = this.endPosition; //the position has been stored explicitly

            if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
                  this.expressionPtr -= length;
                  System.arraycopy(
                        this.expressionStack, 
                        this.expressionPtr + 1, 
                        alloc.arguments = new Expression[length], 
                        0, 
                        length); 
            }
            alloc.type = getTypeReference(0);
            
            //the default constructor with the correct number of argument
            //will be created and added by the TC (see createsInternalConstructorWithBinding)
            alloc.sourceStart = this.intStack[this.intPtr--];
            pushOnExpressionStack(alloc);
      } else {
            dispatchDeclarationInto(length);
            TypeDeclaration anonymousTypeDeclaration = (TypeDeclaration)this.astStack[this.astPtr];
            anonymousTypeDeclaration.declarationSourceEnd = this.endStatementPosition;
            anonymousTypeDeclaration.bodyEnd = this.endStatementPosition;
            if (anonymousTypeDeclaration.allocation != null) {
                  anonymousTypeDeclaration.allocation.sourceEnd = this.endStatementPosition;
            }
            if (length == 0 && !containsComment(anonymousTypeDeclaration.bodyStart, anonymousTypeDeclaration.bodyEnd)) {
                  anonymousTypeDeclaration.bits |= ASTNode.UndocumentedEmptyBlockMASK;
            }
            this.astPtr--;
            this.astLengthPtr--;

            // mark initializers with local type mark if needed
            markInitializersWithLocalType(anonymousTypeDeclaration);
      }
}
protected void concatExpressionLists() {
      this.expressionLengthStack[--this.expressionLengthPtr]++;
}
protected void concatGenericsLists() {
      this.genericsLengthStack[this.genericsLengthPtr - 1] += this.genericsLengthStack[this.genericsLengthPtr--];
}
protected void concatNodeLists() {
      /*
       * This is a case where you have two sublists into the this.astStack that you want
       * to merge in one list. There is no action required on the this.astStack. The only
       * thing you need to do is merge the two lengths specified on the astStackLength.
       * The top two length are for example:
       * ... p   n
       * and you want to result in a list like:
       * ... n+p 
       * This means that the p could be equals to 0 in case there is no astNode pushed
       * on the this.astStack.
       * Look at the InterfaceMemberDeclarations for an example.
       */

      this.astLengthStack[this.astLengthPtr - 1] += this.astLengthStack[this.astLengthPtr--];
}
protected void consumeAdditionalBound() {
      pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));
}
protected void consumeAdditionalBound1() {
      // nothing to be done.
      // The reference type1 is consumed by consumeReferenceType1 method.
}
protected void consumeAdditionalBoundList() {
      concatGenericsLists();
}
protected void consumeAdditionalBoundList1() {
      concatGenericsLists();
}
protected void consumeAllocationHeader() {
      // ClassInstanceCreationExpression ::= 'new' ClassType '(' ArgumentListopt ')' ClassBodyopt

      // ClassBodyopt produces a null item on the astStak if it produces NO class body
      // An empty class body produces a 0 on the length stack.....

      if (this.currentElement == null){
            return; // should never occur, this consumeRule is only used in recovery mode
      }
      if (this.currentToken == TokenNameLBRACE){
            // beginning of an anonymous type
            TypeDeclaration anonymousType = new TypeDeclaration(this.compilationUnit.compilationResult);
            anonymousType.name = TypeDeclaration.ANONYMOUS_EMPTY_NAME;
            anonymousType.bits |= ASTNode.AnonymousAndLocalMask;
            anonymousType.sourceStart = this.intStack[this.intPtr--];
            anonymousType.sourceEnd = this.rParenPos; // closing parenthesis
            QualifiedAllocationExpression alloc = new QualifiedAllocationExpression(anonymousType);
            alloc.type = getTypeReference(0);
            alloc.sourceStart = anonymousType.sourceStart;
            alloc.sourceEnd = anonymousType.sourceEnd ;
            this.lastCheckPoint = anonymousType.bodyStart = this.scanner.currentPosition;
            this.currentElement = this.currentElement.add(anonymousType, 0);
            this.lastIgnoredToken = -1;
            this.currentToken = 0; // opening brace already taken into account
            return;
      }
      this.lastCheckPoint = this.scanner.startPosition; // force to restart at this exact position
      this.restartRecovery = true; // request to restart from here on
}
protected void consumeAnnotationAsModifier() {
      Expression expression = this.expressionStack[this.expressionPtr];
      int sourceStart = expression.sourceStart;
      if (this.modifiersSourceStart < 0) {
            this.modifiersSourceStart = sourceStart;
      }
}
protected void consumeAnnotationName() {
      if(this.currentElement != null) {
            int start = this.intStack[this.intPtr];
            int end = (int) (this.identifierPositionStack[this.identifierPtr] & 0x00000000FFFFFFFFL);
            annotationRecoveryCheckPoint(start, end);
      }
}
protected void consumeAnnotationTypeDeclaration() {
      int length;
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            //there are length declarations
            //dispatch according to the type of the declarations
            dispatchDeclarationInto(length);
      }

      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
      
      // mark initializers with local type mark if needed
      markInitializersWithLocalType(typeDecl);

      //convert constructor that do not have the type's name into methods
      typeDecl.checkConstructors(this);
      
      //always add <clinit> (will be remove at code gen time if empty)
      if (this.scanner.containsAssertKeyword) {
            typeDecl.bits |= ASTNode.AddAssertionMASK;
      }
      typeDecl.addClinit();
      typeDecl.bodyEnd = this.endStatementPosition;
      if (length == 0 && !containsComment(typeDecl.bodyStart, typeDecl.bodyEnd)) {
            typeDecl.bits |= ASTNode.UndocumentedEmptyBlockMASK;
      }
      typeDecl.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition); 
}
protected void consumeAnnotationTypeDeclarationHeader() {
      if (this.currentElement != null) {
            this.restartRecovery = true; // used to avoid branching back into the regular automaton         
      }
      // flush the comments related to the annotation type header
      this.scanner.commentPtr = -1;
}
protected void consumeAnnotationTypeDeclarationHeaderName() {
      // consumeAnnotationTypeDeclarationHeader ::= Modifiers '@' PushModifiers interface Identifier
      // consumeAnnotationTypeDeclarationHeader ::= '@' PushModifiers interface Identifier
      TypeDeclaration annotationTypeDeclaration = new TypeDeclaration(this.compilationUnit.compilationResult);
      if (this.nestedMethod[this.nestedType] == 0) {
            if (this.nestedType != 0) {
                  annotationTypeDeclaration.bits |= ASTNode.IsMemberTypeMASK;
            }
      } else {
            // Record that the block has a declaration for local types
            annotationTypeDeclaration.bits |= ASTNode.IsLocalTypeMASK;
            markEnclosingMemberWithLocalType();
            blockReal();
      }

      //highlight the name of the type
      long pos = this.identifierPositionStack[this.identifierPtr];
      annotationTypeDeclaration.sourceEnd = (int) pos;
      annotationTypeDeclaration.sourceStart = (int) (pos >>> 32);
      annotationTypeDeclaration.name = this.identifierStack[this.identifierPtr--];
      this.identifierLengthPtr--;

      //compute the declaration source too
      // 'interface' push two int positions: the beginning of the class token and its end.
      // we want to keep the beginning position but get rid of the end position
      // it is only used for the ClassLiteralAccess positions.
      this.intPtr--; // remove the start position of the interface token
      this.intPtr--; // remove the end position of the interface token

      annotationTypeDeclaration.modifiersSourceStart = this.intStack[this.intPtr--];
      annotationTypeDeclaration.modifiers = this.intStack[this.intPtr--] | AccAnnotation | AccInterface;
      if (annotationTypeDeclaration.modifiersSourceStart >= 0) {
            annotationTypeDeclaration.declarationSourceStart = annotationTypeDeclaration.modifiersSourceStart;
            this.intPtr--; // remove the position of the '@' token as we have modifiers
      } else {
            int atPosition = this.intStack[this.intPtr--];
            // remove the position of the '@' token as we don't have modifiers
            annotationTypeDeclaration.declarationSourceStart = atPosition;
      }
      // consume annotations
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            System.arraycopy(
                  this.expressionStack, 
                  (this.expressionPtr -= length) + 1, 
                  annotationTypeDeclaration.annotations = new Annotation[length], 
                  0, 
                  length); 
      }
      annotationTypeDeclaration.bodyStart = annotationTypeDeclaration.sourceEnd + 1;

      // javadoc
      annotationTypeDeclaration.javadoc = this.javadoc;
      this.javadoc = null;    
      pushOnAstStack(annotationTypeDeclaration);
      if(options.sourceLevel < ClassFileConstants.JDK1_5 &&
                  this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
            this.problemReporter().invalidUsageOfAnnotationDeclarations(annotationTypeDeclaration);
      }     
      
      // recovery
      if (this.currentElement != null){ 
            this.lastCheckPoint = annotationTypeDeclaration.bodyStart;
            this.currentElement = this.currentElement.add(annotationTypeDeclaration, 0);
            this.lastIgnoredToken = -1;
      }
}
protected void consumeAnnotationTypeMemberDeclaration() {
      // AnnotationTypeMemberDeclaration ::= AnnotationTypeMemberDeclarationHeader AnnotationTypeMemberHeaderExtendedDims DefaultValueopt ';'
      AnnotationMethodDeclaration annotationTypeMemberDeclaration = (AnnotationMethodDeclaration) this.astStack[this.astPtr];
      annotationTypeMemberDeclaration.modifiers |= AccSemicolonBody;
      // store the this.endPosition (position just before the '}') in case there is
      // a trailing comment behind the end of the method
      int declarationEndPosition = flushCommentsDefinedPriorTo(this.endStatementPosition);
      annotationTypeMemberDeclaration.bodyStart = this.endStatementPosition;
      annotationTypeMemberDeclaration.bodyEnd = declarationEndPosition;
      annotationTypeMemberDeclaration.declarationSourceEnd = declarationEndPosition;
}
protected void consumeAnnotationTypeMemberDeclarations() {
      // AnnotationTypeMemberDeclarations ::= AnnotationTypeMemberDeclarations AnnotationTypeMemberDeclaration
      concatNodeLists();
}
protected void consumeArgumentList() {
      // ArgumentList ::= ArgumentList ',' Expression
      concatExpressionLists();
}
protected void consumeArguments() {
      // Arguments ::= '(' ArgumentListopt ')' 
      // nothing to do, the expression stack is already updated
      pushOnIntStack(rParenPos);
}
protected void consumeArrayAccess(boolean unspecifiedReference) {
      // ArrayAccess ::= Name '[' Expression ']' ==> true
      // ArrayAccess ::= PrimaryNoNewArray '[' Expression ']' ==> false


      //optimize push/pop
      Expression exp;
      if (unspecifiedReference) {
            exp = 
                  this.expressionStack[this.expressionPtr] = 
                        new ArrayReference(
                              getUnspecifiedReferenceOptimized(),
                              this.expressionStack[this.expressionPtr]);
      } else {
            this.expressionPtr--;
            this.expressionLengthPtr--;
            exp = 
                  this.expressionStack[this.expressionPtr] = 
                        new ArrayReference(
                              this.expressionStack[this.expressionPtr],
                              this.expressionStack[this.expressionPtr + 1]);
      }
      exp.sourceEnd = this.endPosition;
}
protected void consumeArrayCreationExpressionWithInitializer() {
      // ArrayCreationWithArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs ArrayInitializer
      // ArrayCreationWithArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer

      int length;
      ArrayAllocationExpression aae = new ArrayAllocationExpression();
      this.expressionLengthPtr -- ;
      aae.initializer = (ArrayInitializer) this.expressionStack[this.expressionPtr--];
            
      aae.type = getTypeReference(0);
      length = (this.expressionLengthStack[this.expressionLengthPtr--]);
      this.expressionPtr -= length ;
      System.arraycopy(
            this.expressionStack,
            this.expressionPtr+1,
            aae.dimensions = new Expression[length],
            0,
            length);
      aae.sourceStart = this.intStack[this.intPtr--];
      if (aae.initializer == null) {
            aae.sourceEnd = this.endPosition;
      } else {
            aae.sourceEnd = aae.initializer.sourceEnd ;
      }
      pushOnExpressionStack(aae);
}
protected void consumeArrayCreationExpressionWithoutInitializer() {
      // ArrayCreationWithoutArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs
      // ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs

      int length;
      ArrayAllocationExpression aae = new ArrayAllocationExpression();
      aae.type = getTypeReference(0);
      length = (this.expressionLengthStack[this.expressionLengthPtr--]);
      this.expressionPtr -= length ;
      System.arraycopy(
            this.expressionStack,
            this.expressionPtr+1,
            aae.dimensions = new Expression[length],
            0,
            length);
      aae.sourceStart = this.intStack[this.intPtr--];
      if (aae.initializer == null) {
            aae.sourceEnd = this.endPosition;
      } else {
            aae.sourceEnd = aae.initializer.sourceEnd ;
      }
      pushOnExpressionStack(aae);
}
protected void consumeArrayCreationHeader() {
      // nothing to do
}
protected void consumeArrayInitializer() {
      // ArrayInitializer ::= '{' VariableInitializers '}'
      // ArrayInitializer ::= '{' VariableInitializers , '}'

      arrayInitializer(this.expressionLengthStack[this.expressionLengthPtr--]);
}
protected void consumeArrayTypeWithTypeArgumentsName() {
      this.genericsIdentifiersLengthStack[this.genericsIdentifiersLengthPtr] += this.identifierLengthStack[this.identifierLengthPtr];
      pushOnGenericsLengthStack(0); // handle type arguments
}
protected void consumeAssertStatement() {
      // AssertStatement ::= 'assert' Expression ':' Expression ';'
      this.expressionLengthPtr-=2;
      pushOnAstStack(new AssertStatement(this.expressionStack[this.expressionPtr--], this.expressionStack[this.expressionPtr--], this.intStack[this.intPtr--]));
}
protected void consumeAssignment() {
      // Assignment ::= LeftHandSide AssignmentOperator AssignmentExpression
      //optimize the push/pop

      int op = this.intStack[this.intPtr--] ; //<--the encoded operator
      
      this.expressionPtr -- ; this.expressionLengthPtr -- ;
      this.expressionStack[this.expressionPtr] =
            (op != EQUAL ) ?
                  new CompoundAssignment(
                        this.expressionStack[this.expressionPtr] ,
                        this.expressionStack[this.expressionPtr+1], 
                        op,
                        this.scanner.startPosition - 1)     :
                  new Assignment(
                        this.expressionStack[this.expressionPtr] ,
                        this.expressionStack[this.expressionPtr+1],
                        this.scanner.startPosition - 1);
}
protected void consumeAssignmentOperator(int pos) {
      // AssignmentOperator ::= '='
      // AssignmentOperator ::= '*='
      // AssignmentOperator ::= '/='
      // AssignmentOperator ::= '%='
      // AssignmentOperator ::= '+='
      // AssignmentOperator ::= '-='
      // AssignmentOperator ::= '<<='
      // AssignmentOperator ::= '>>='
      // AssignmentOperator ::= '>>>='
      // AssignmentOperator ::= '&='
      // AssignmentOperator ::= '^='
      // AssignmentOperator ::= '|='

      pushOnIntStack(pos);
}
protected void consumeBinaryExpression(int op) {
      // MultiplicativeExpression ::= MultiplicativeExpression '*' UnaryExpression
      // MultiplicativeExpression ::= MultiplicativeExpression '/' UnaryExpression
      // MultiplicativeExpression ::= MultiplicativeExpression '%' UnaryExpression
      // AdditiveExpression ::= AdditiveExpression '+' MultiplicativeExpression
      // AdditiveExpression ::= AdditiveExpression '-' MultiplicativeExpression
      // ShiftExpression ::= ShiftExpression '<<'  AdditiveExpression
      // ShiftExpression ::= ShiftExpression '>>'  AdditiveExpression
      // ShiftExpression ::= ShiftExpression '>>>' AdditiveExpression
      // RelationalExpression ::= RelationalExpression '<'  ShiftExpression
      // RelationalExpression ::= RelationalExpression '>'  ShiftExpression
      // RelationalExpression ::= RelationalExpression '<=' ShiftExpression
      // RelationalExpression ::= RelationalExpression '>=' ShiftExpression
      // AndExpression ::= AndExpression '&' EqualityExpression
      // ExclusiveOrExpression ::= ExclusiveOrExpression '^' AndExpression
      // InclusiveOrExpression ::= InclusiveOrExpression '|' ExclusiveOrExpression
      // ConditionalAndExpression ::= ConditionalAndExpression '&&' InclusiveOrExpression
      // ConditionalOrExpression ::= ConditionalOrExpression '||' ConditionalAndExpression

      //optimize the push/pop

      this.expressionPtr--;
      this.expressionLengthPtr--;
      Expression expr1 = this.expressionStack[this.expressionPtr];
      Expression expr2 = this.expressionStack[this.expressionPtr + 1];
      switch(op) {
            case OR_OR :
                  this.expressionStack[this.expressionPtr] = 
                        new OR_OR_Expression(
                              expr1, 
                              expr2, 
                              op); 
                  break;
            case AND_AND :
                  this.expressionStack[this.expressionPtr] = 
                        new AND_AND_Expression(
                              expr1, 
                              expr2, 
                              op);
                  break;
            case PLUS :
                  // look for "string1" + "string2"
                  if (this.optimizeStringLiterals) {
                        if (expr1 instanceof StringLiteral) {
                              if (expr2 instanceof CharLiteral) { // string+char
                                    this.expressionStack[this.expressionPtr] = 
                                          ((StringLiteral) expr1).extendWith((CharLiteral) expr2); 
                              } else if (expr2 instanceof StringLiteral) { //string+string
                                    this.expressionStack[this.expressionPtr] = 
                                          ((StringLiteral) expr1).extendWith((StringLiteral) expr2); 
                              } else {
                                    this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
                              }
                        } else {
                              this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
                        }
                  } else if (expr1 instanceof StringLiteral) {
                        if (expr2 instanceof StringLiteral) {
                              // string + string
                              this.expressionStack[this.expressionPtr] = 
                                    ((StringLiteral) expr1).extendsWith((StringLiteral) expr2); 
                        } else {
                              this.expressionStack[this.expressionPtr] = 
                                    new BinaryExpression(
                                          expr1, 
                                          expr2, 
                                          op);
                        }
                  } else {
                        this.expressionStack[this.expressionPtr] = 
                              new BinaryExpression(
                                    expr1, 
                                    expr2, 
                                    op);
                  }
                  break;
            case LESS :
                  this.intPtr--;
                  this.expressionStack[this.expressionPtr] = 
                        new BinaryExpression(
                              expr1, 
                              expr2, 
                              op);
                  break;
            default :
                  this.expressionStack[this.expressionPtr] = 
                        new BinaryExpression(
                              expr1, 
                              expr2, 
                              op);        
      }
}
/**
 * @param op binary operator
 */
protected void consumeBinaryExpressionWithName(int op) {
      pushOnExpressionStack(getUnspecifiedReferenceOptimized());
      this.expressionPtr--;
      this.expressionLengthPtr--;
      /*
      if (op == OR_OR) {
            this.expressionStack[this.expressionPtr] = 
                  new OR_OR_Expression(
                        this.expressionStack[this.expressionPtr + 1], 
                        this.expressionStack[this.expressionPtr], 
                        op); 
      } else {
            if (op == AND_AND) {
                  this.expressionStack[this.expressionPtr] = 
                        new AND_AND_Expression(
                              this.expressionStack[this.expressionPtr + 1], 
                              this.expressionStack[this.expressionPtr], 
                              op);
            } else {
                  // look for "string1" + "string2"
                  if ((op == PLUS) && this.optimizeStringLiterals) {
                        Expression expr1, expr2;
                        expr1 = this.expressionStack[this.expressionPtr + 1];
                        expr2 = this.expressionStack[this.expressionPtr];
                        if (expr1 instanceof StringLiteral) {
                              if (expr2 instanceof CharLiteral) { // string+char
                                    this.expressionStack[this.expressionPtr] = 
                                          ((StringLiteral) expr1).extendWith((CharLiteral) expr2); 
                              } else if (expr2 instanceof StringLiteral) { //string+string
                                    this.expressionStack[this.expressionPtr] = 
                                          ((StringLiteral) expr1).extendWith((StringLiteral) expr2); 
                              } else {
                                    this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
                              }
                        } else {
                              this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
                        }
                  } else {
                        this.expressionStack[this.expressionPtr] = 
                              new BinaryExpression(
                                    this.expressionStack[this.expressionPtr + 1], 
                                    this.expressionStack[this.expressionPtr], 
                                    op);
                  }
            }
      }
      */
      Expression expr1 = this.expressionStack[this.expressionPtr + 1];
      Expression expr2 = this.expressionStack[this.expressionPtr];
      switch(op) {
            case OR_OR :
                  this.expressionStack[this.expressionPtr] = 
                        new OR_OR_Expression(
                              expr1, 
                              expr2, 
                              op); 
                  break;
            case AND_AND :
                  this.expressionStack[this.expressionPtr] = 
                        new AND_AND_Expression(
                              expr1, 
                              expr2, 
                              op);
                  break;
            case PLUS :
                  // look for "string1" + "string2"
                  if (this.optimizeStringLiterals) {
                        if (expr1 instanceof StringLiteral) {
                              if (expr2 instanceof CharLiteral) { // string+char
                                    this.expressionStack[this.expressionPtr] = 
                                          ((StringLiteral) expr1).extendWith((CharLiteral) expr2); 
                              } else if (expr2 instanceof StringLiteral) { //string+string
                                    this.expressionStack[this.expressionPtr] = 
                                          ((StringLiteral) expr1).extendWith((StringLiteral) expr2); 
                              } else {
                                    this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
                              }
                        } else {
                              this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
                        }
                  } else if (expr1 instanceof StringLiteral) {
                        if (expr2 instanceof StringLiteral) {
                              // string + string
                              this.expressionStack[this.expressionPtr] = 
                                    ((StringLiteral) expr1).extendsWith((StringLiteral) expr2); 
                        } else {
                              this.expressionStack[this.expressionPtr] = 
                                    new BinaryExpression(
                                          expr1, 
                                          expr2, 
                                          op);
                        }
                  } else {
                        this.expressionStack[this.expressionPtr] = 
                              new BinaryExpression(
                                    expr1, 
                                    expr2, 
                                    op);
                  }
                  break;
            case LESS :
                  this.intPtr--;
                  this.expressionStack[this.expressionPtr] = 
                        new BinaryExpression(
                              expr1, 
                              expr2, 
                              op);
                  break;
            default :
                  this.expressionStack[this.expressionPtr] = 
                        new BinaryExpression(
                              expr1, 
                              expr2, 
                              op);        
      }
}
protected void consumeBlock() {
      // Block ::= OpenBlock '{' BlockStatementsopt '}'
      // simpler action for empty blocks

      int statementsLength = this.astLengthStack[this.astLengthPtr--];
      Block block;
      if (statementsLength == 0) { // empty block 
            block = new Block(0);
            block.sourceStart = this.intStack[this.intPtr--];
            block.sourceEnd = this.endStatementPosition;
            // check whether this block at least contains some comment in it
            if (!containsComment(block.sourceStart, block.sourceEnd)) {
                  block.bits |= ASTNode.UndocumentedEmptyBlockMASK;
            }
            this.realBlockPtr--; // still need to pop the block variable counter
      } else {
            block = new Block(this.realBlockStack[this.realBlockPtr--]);
            this.astPtr -= statementsLength;
            System.arraycopy(
                  this.astStack, 
                  this.astPtr + 1, 
                  block.statements = new Statement[statementsLength], 
                  0, 
                  statementsLength); 
            block.sourceStart = this.intStack[this.intPtr--];
            block.sourceEnd = this.endStatementPosition;
      }
      pushOnAstStack(block);
}
protected void consumeBlockStatements() {
      // BlockStatements ::= BlockStatements BlockStatement
      concatNodeLists();
}
protected void consumeCaseLabel() {
      // SwitchLabel ::= 'case' ConstantExpression ':'
      this.expressionLengthPtr--;
      Expression expression = this.expressionStack[this.expressionPtr--];
      pushOnAstStack(new CaseStatement(expression, expression.sourceEnd, this.intStack[this.intPtr--]));
}
protected void consumeCastExpressionLL1() {
      //CastExpression ::= '(' Expression ')' InsideCastExpressionLL1 UnaryExpressionNotPlusMinus
      // Expression is used in order to make the grammar LL1

      //optimize push/pop

      Expression cast,exp;
      this.expressionPtr--;
      this.expressionStack[this.expressionPtr] = 
            cast = new CastExpression(
                  exp=this.expressionStack[this.expressionPtr+1] ,
                  getTypeReference(this.expressionStack[this.expressionPtr]));
      this.expressionLengthPtr -- ;
      updateSourcePosition(cast);
      cast.sourceEnd=exp.sourceEnd;
}
protected void consumeCastExpressionWithGenericsArray() {
      // CastExpression ::= PushLPAREN Name TypeArguments Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus

      Expression exp, cast, castType;
      int end = this.intStack[this.intPtr--];

      int dim = this.intStack[this.intPtr--];
      pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
      
      this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = getTypeReference(dim));
      intPtr--;
      castType.sourceEnd = end - 1;
      castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;
      cast.sourceEnd = exp.sourceEnd;
}
protected void consumeCastExpressionWithNameArray() {
      // CastExpression ::= PushLPAREN Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus

      Expression exp, cast, castType;
      int end = this.intStack[this.intPtr--];
      
      // handle type arguments
      pushOnGenericsLengthStack(0);
      pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
      
      this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = getTypeReference(this.intStack[this.intPtr--]));
      castType.sourceEnd = end - 1;
      castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;
      cast.sourceEnd = exp.sourceEnd;
}
protected void consumeCastExpressionWithPrimitiveType() {
      // CastExpression ::= PushLPAREN PrimitiveType Dimsopt PushRPAREN InsideCastExpression UnaryExpression

      //this.intStack : posOfLeftParen dim posOfRightParen

      //optimize the push/pop

      Expression exp, cast, castType;
      int end = this.intStack[this.intPtr--];
      this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = getTypeReference(this.intStack[this.intPtr--]));
      castType.sourceEnd = end - 1;
      castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;
      cast.sourceEnd = exp.sourceEnd;
}
protected ParameterizedQualifiedTypeReference computeQualifiedGenericsFromRightSide(TypeReference rightSide, int dim) {
      int nameSize = this.identifierLengthStack[this.identifierLengthPtr];
      int tokensSize = nameSize;
      if (rightSide instanceof ParameterizedSingleTypeReference) {
            tokensSize ++;
      } else if (rightSide instanceof SingleTypeReference) {
            tokensSize ++;
      } else if (rightSide instanceof ParameterizedQualifiedTypeReference) {
            tokensSize += ((QualifiedTypeReference) rightSide).tokens.length;
      } else if (rightSide instanceof QualifiedTypeReference) {
            tokensSize += ((QualifiedTypeReference) rightSide).tokens.length;
      }
      TypeReference[][] typeArguments = new TypeReference[tokensSize][];
      char[][] tokens = new char[tokensSize][];
      long[] positions = new long[tokensSize];
      if (rightSide instanceof ParameterizedSingleTypeReference) {
            ParameterizedSingleTypeReference singleParameterizedTypeReference = (ParameterizedSingleTypeReference) rightSide;
            tokens[nameSize] = singleParameterizedTypeReference.token;
            positions[nameSize] = (((long) singleParameterizedTypeReference.sourceStart) << 32) + singleParameterizedTypeReference.sourceEnd;
            typeArguments[nameSize] = singleParameterizedTypeReference.typeArguments;
      } else if (rightSide instanceof SingleTypeReference) {
            SingleTypeReference singleTypeReference = (SingleTypeReference) rightSide;
            tokens[nameSize] = singleTypeReference.token;
            positions[nameSize] = (((long) singleTypeReference.sourceStart) << 32) + singleTypeReference.sourceEnd;
      } else if (rightSide instanceof ParameterizedQualifiedTypeReference) {
            ParameterizedQualifiedTypeReference parameterizedTypeReference = (ParameterizedQualifiedTypeReference) rightSide;
            TypeReference[][] rightSideTypeArguments = parameterizedTypeReference.typeArguments;
            System.arraycopy(rightSideTypeArguments, 0, typeArguments, nameSize, rightSideTypeArguments.length);
            char[][] rightSideTokens = parameterizedTypeReference.tokens;
            System.arraycopy(rightSideTokens, 0, tokens, nameSize, rightSideTokens.length);
            long[] rightSidePositions = parameterizedTypeReference.sourcePositions;
            System.arraycopy(rightSidePositions, 0, positions, nameSize, rightSidePositions.length);
      } else if (rightSide instanceof QualifiedTypeReference) {
            QualifiedTypeReference qualifiedTypeReference = (QualifiedTypeReference) rightSide;
            char[][] rightSideTokens = qualifiedTypeReference.tokens;
            System.arraycopy(rightSideTokens, 0, tokens, nameSize, rightSideTokens.length);
            long[] rightSidePositions = qualifiedTypeReference.sourcePositions;
            System.arraycopy(rightSidePositions, 0, positions, nameSize, rightSidePositions.length);
      }

      int currentTypeArgumentsLength = this.genericsLengthStack[this.genericsLengthPtr--];
      TypeReference[] currentTypeArguments = new TypeReference[currentTypeArgumentsLength];
      this.genericsPtr -= currentTypeArgumentsLength;
      System.arraycopy(this.genericsStack, this.genericsPtr + 1, currentTypeArguments, 0, currentTypeArgumentsLength);
      
      if (nameSize == 1) {
            tokens[0] = this.identifierStack[this.identifierPtr];
            positions[0] = this.identifierPositionStack[this.identifierPtr--];
            typeArguments[0] = currentTypeArguments;
      } else {
            this.identifierPtr -= nameSize;
            System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, 0, nameSize);
            System.arraycopy(this.identifierPositionStack, this.identifierPtr + 1, positions, 0, nameSize);
            typeArguments[nameSize - 1] = currentTypeArguments;
      }
      this.identifierLengthPtr--;
      return new ParameterizedQualifiedTypeReference(tokens, typeArguments, dim, positions);
}
protected void consumeCastExpressionWithQualifiedGenericsArray() {
      // CastExpression ::= PushLPAREN Name OnlyTypeArguments '.' ClassOrInterfaceType Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
      Expression exp, cast, castType;
      int end = this.intStack[this.intPtr--];

      int dim = this.intStack[this.intPtr--];
      TypeReference rightSide = getTypeReference(0);
      
      ParameterizedQualifiedTypeReference qualifiedParameterizedTypeReference = computeQualifiedGenericsFromRightSide(rightSide, dim);
      intPtr--;
      this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = qualifiedParameterizedTypeReference);
      castType.sourceEnd = end - 1;
      castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;
      cast.sourceEnd = exp.sourceEnd;
}
protected void consumeCatches() {
      // Catches ::= Catches CatchClause
      optimizedConcatNodeLists();
}
protected void consumeCatchHeader() {
      // CatchDeclaration ::= 'catch' '(' FormalParameter ')' '{'

      if (this.currentElement == null){
            return; // should never occur, this consumeRule is only used in recovery mode
      }
      // current element should be a block due to the presence of the opening brace
      if (!(this.currentElement instanceof RecoveredBlock)){
            if(!(this.currentElement instanceof RecoveredMethod)) {
                  return;
            }
            RecoveredMethod rMethod = (RecoveredMethod) this.currentElement;
            if(!(rMethod.methodBody == null && rMethod.bracketBalance > 0)) {
                  return;
            }
      }
      
      Argument arg = (Argument)this.astStack[this.astPtr--];
      // convert argument to local variable
      LocalDeclaration localDeclaration = new LocalDeclaration(arg.name, arg.sourceStart, arg.sourceEnd);
      localDeclaration.type = arg.type;
      localDeclaration.declarationSourceStart = arg.declarationSourceStart;
      localDeclaration.declarationSourceEnd = arg.declarationSourceEnd;
      
      this.currentElement = this.currentElement.add(localDeclaration, 0);
      this.lastCheckPoint = this.scanner.startPosition; // force to restart at this exact position
      this.restartRecovery = true; // request to restart from here on
      this.lastIgnoredToken = -1;
}
protected void consumeClassBodyDeclaration() {
      // ClassBodyDeclaration ::= Diet Block
      //push an Initializer
      //optimize the push/pop
      this.nestedMethod[this.nestedType]--;
      Block block = (Block) this.astStack[this.astPtr];
      if (this.diet) block.bits &= ~ASTNode.UndocumentedEmptyBlockMASK; // clear bit since was diet
      Initializer initializer = new Initializer(block, 0);
      this.intPtr--; // pop sourcestart left on the stack by consumeNestedMethod.
      initializer.bodyStart = this.intStack[this.intPtr--];
      this.realBlockPtr--; // pop the block variable counter left on the stack by consumeNestedMethod
      int javadocCommentStart = this.intStack[this.intPtr--];
      if (javadocCommentStart != -1) {
            initializer.declarationSourceStart = javadocCommentStart;
            initializer.javadoc = this.javadoc;
            this.javadoc = null;
      }
      this.astStack[this.astPtr] = initializer;
      initializer.bodyEnd = this.endPosition;
      initializer.sourceEnd = this.endStatementPosition;
      initializer.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
}
protected void consumeClassBodyDeclarations() {
      // ClassBodyDeclarations ::= ClassBodyDeclarations ClassBodyDeclaration
      concatNodeLists();
}
protected void consumeClassBodyDeclarationsopt() {
      // ClassBodyDeclarationsopt ::= NestedType ClassBodyDeclarations
      this.nestedType-- ;
}
protected void consumeAnnotationTypeMemberDeclarationsopt() {
      this.nestedType-- ;
}
protected void consumeClassBodyopt() {
      // ClassBodyopt ::= $empty
      pushOnAstStack(null);
      this.endPosition = this.rParenPos;
}
protected void consumeClassDeclaration() {
      // ClassDeclaration ::= ClassHeader ClassBody

      int length;
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            //there are length declarations
            //dispatch according to the type of the declarations
            dispatchDeclarationInto(length);
      }

      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];

      // mark initializers with local type mark if needed
      markInitializersWithLocalType(typeDecl);

      //convert constructor that do not have the type's name into methods
      boolean hasConstructor = typeDecl.checkConstructors(this);
      
      //add the default constructor when needed (interface don't have it)
      if (!hasConstructor) {
            switch(typeDecl.kind()) {
                  case IGenericType.CLASS_DECL :
                  case IGenericType.ENUM_DECL :
                        boolean insideFieldInitializer = false;
                        if (this.diet) {
                              for (int i = this.nestedType; i > 0; i--){
                                    if (this.variablesCounter[i] > 0) {
                                          insideFieldInitializer = true;
                                          break;
                                    }
                              }
                        }
                        typeDecl.createDefaultConstructor(!this.diet || insideFieldInitializer, true);
            }
      }
      //always add <clinit> (will be remove at code gen time if empty)
      if (this.scanner.containsAssertKeyword) {
            typeDecl.bits |= ASTNode.AddAssertionMASK;
      }
      typeDecl.addClinit();
      typeDecl.bodyEnd = this.endStatementPosition;
      if (length == 0 && !containsComment(typeDecl.bodyStart, typeDecl.bodyEnd)) {
            typeDecl.bits |= ASTNode.UndocumentedEmptyBlockMASK;
      }

      typeDecl.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition); 
}
protected void consumeClassHeader() {
      // ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt ClassHeaderImplementsopt

      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];      
      if (this.currentToken == TokenNameLBRACE) { 
            typeDecl.bodyStart = this.scanner.currentPosition;
      }
      if (this.currentElement != null) {
            this.restartRecovery = true; // used to avoid branching back into the regular automaton         
      }
      // flush the comments related to the class header
      this.scanner.commentPtr = -1;
}
protected void consumeClassHeaderExtends() {
      // ClassHeaderExtends ::= 'extends' ClassType
      //superclass
      TypeReference superClass = getTypeReference(0);
      // There is a class declaration on the top of stack
      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
      typeDecl.superclass = superClass;
      superClass.bits |= ASTNode.IsSuperType;
      typeDecl.bodyStart = typeDecl.superclass.sourceEnd + 1;
      // recovery
      if (this.currentElement != null){
            this.lastCheckPoint = typeDecl.bodyStart;
      }
}
protected void consumeClassHeaderImplements() {
      // ClassHeaderImplements ::= 'implements' InterfaceTypeList
      int length = this.astLengthStack[this.astLengthPtr--];
      //super interfaces
      this.astPtr -= length;
      // There is a class declaration on the top of stack
      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
      System.arraycopy(
            this.astStack, 
            this.astPtr + 1, 
            typeDecl.superInterfaces = new TypeReference[length], 
            0, 
            length); 
      for (int i = 0, max = typeDecl.superInterfaces.length; i < max; i++) {
            typeDecl.superInterfaces[i].bits |= ASTNode.IsSuperType;
      }
      typeDecl.bodyStart = typeDecl.superInterfaces[length-1].sourceEnd + 1;
      this.listLength = 0; // reset after having read super-interfaces
      // recovery
      if (this.currentElement != null) { // is recovering
            this.lastCheckPoint = typeDecl.bodyStart;
      }
}
protected void consumeClassHeaderName1() {
      // ClassHeaderName1 ::= Modifiersopt 'class' 'Identifier'
      TypeDeclaration typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
      if (this.nestedMethod[this.nestedType] == 0) {
            if (this.nestedType != 0) {
                  typeDecl.bits |= ASTNode.IsMemberTypeMASK;
            }
      } else {
            // Record that the block has a declaration for local types
            typeDecl.bits |= ASTNode.IsLocalTypeMASK;
            markEnclosingMemberWithLocalType();
            blockReal();
      }

      //highlight the name of the type
      long pos = this.identifierPositionStack[this.identifierPtr];
      typeDecl.sourceEnd = (int) pos;
      typeDecl.sourceStart = (int) (pos >>> 32);
      typeDecl.name = this.identifierStack[this.identifierPtr--];
      this.identifierLengthPtr--;

      //compute the declaration source too
      // 'class' and 'interface' push two int positions: the beginning of the class token and its end.
      // we want to keep the beginning position but get rid of the end position
      // it is only used for the ClassLiteralAccess positions.
      typeDecl.declarationSourceStart = this.intStack[this.intPtr--]; 
      this.intPtr--; // remove the end position of the class token

      typeDecl.modifiersSourceStart = this.intStack[this.intPtr--];
      typeDecl.modifiers = this.intStack[this.intPtr--];
      if (typeDecl.modifiersSourceStart >= 0) {
            typeDecl.declarationSourceStart = typeDecl.modifiersSourceStart;
      }
      // consume annotations
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            System.arraycopy(
                  this.expressionStack, 
                  (this.expressionPtr -= length) + 1, 
                  typeDecl.annotations = new Annotation[length], 
                  0, 
                  length); 
      }
      typeDecl.bodyStart = typeDecl.sourceEnd + 1;
      pushOnAstStack(typeDecl);

      this.listLength = 0; // will be updated when reading super-interfaces
      // recovery
      if (this.currentElement != null){ 
            this.lastCheckPoint = typeDecl.bodyStart;
            this.currentElement = this.currentElement.add(typeDecl, 0);
            this.lastIgnoredToken = -1;
      }
      // javadoc
      typeDecl.javadoc = this.javadoc;
      this.javadoc = null;
}
protected void consumeTypeHeaderNameWithTypeParameters() {
      // ClassHeaderName ::= ClassHeaderName1 TypeParameters
      // InterfaceHeaderName ::= InterfaceHeaderName1 TypeParameters
      TypeDeclaration typeDecl = (TypeDeclaration)this.astStack[this.astPtr];

      // consume type parameters
      int length = this.genericsLengthStack[this.genericsLengthPtr--];
      this.genericsPtr -= length;
      System.arraycopy(this.genericsStack, this.genericsPtr + 1, typeDecl.typeParameters = new TypeParameter[length], 0, length);

      typeDecl.bodyStart = typeDecl.typeParameters[length-1].declarationSourceEnd + 1;
      
      this.listTypeParameterLength = 0;
      
      if (this.currentElement != null) { // is recovering
            this.lastCheckPoint = typeDecl.bodyStart;
      }
}
protected void consumeClassInstanceCreationExpression() {
      // ClassInstanceCreationExpression ::= 'new' ClassType '(' ArgumentListopt ')' ClassBodyopt
      classInstanceCreation(false);
}
protected void consumeClassInstanceCreationExpressionName() {
      // ClassInstanceCreationExpressionName ::= Name '.'
      pushOnExpressionStack(getUnspecifiedReferenceOptimized());
}
protected void consumeClassInstanceCreationExpressionQualified() {
      // ClassInstanceCreationExpression ::= Primary '.' 'new' SimpleName '(' ArgumentListopt ')' ClassBodyopt
      // ClassInstanceCreationExpression ::= ClassInstanceCreationExpressionName 'new' SimpleName '(' ArgumentListopt ')' ClassBodyopt
      classInstanceCreation(true);

      this.expressionLengthPtr--;
      QualifiedAllocationExpression qae = 
            (QualifiedAllocationExpression) this.expressionStack[this.expressionPtr--]; 
      qae.enclosingInstance = this.expressionStack[this.expressionPtr];
      this.expressionStack[this.expressionPtr] = qae;
      qae.sourceStart = qae.enclosingInstance.sourceStart;
}
protected void consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() {
      // ClassInstanceCreationExpression ::= Primary '.' 'new' TypeArguments SimpleName '(' ArgumentListopt ')' ClassBodyopt
      // ClassInstanceCreationExpression ::= ClassInstanceCreationExpressionName 'new' TypeArguments SimpleName '(' ArgumentListopt ')' ClassBodyopt

      QualifiedAllocationExpression alloc;
      int length;
      if (((length = this.astLengthStack[this.astLengthPtr--]) == 1) && (this.astStack[this.astPtr] == null)) {
            //NO ClassBody
            this.astPtr--;
            alloc = new QualifiedAllocationExpression();
            alloc.sourceEnd = this.endPosition; //the position has been stored explicitly

            if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
                  this.expressionPtr -= length;
                  System.arraycopy(
                        this.expressionStack, 
                        this.expressionPtr + 1, 
                        alloc.arguments = new Expression[length], 
                        0, 
                        length); 
            }
            alloc.type = getTypeReference(0);

            length = this.genericsLengthStack[this.genericsLengthPtr--];
            this.genericsPtr -= length;
            System.arraycopy(this.genericsStack, this.genericsPtr + 1, alloc.typeArguments = new TypeReference[length], 0, length);
            intPtr--;

            //the default constructor with the correct number of argument
            //will be created and added by the TC (see createsInternalConstructorWithBinding)
            alloc.sourceStart = this.intStack[this.intPtr--];
            pushOnExpressionStack(alloc);
      } else {
            dispatchDeclarationInto(length);
            TypeDeclaration anonymousTypeDeclaration = (TypeDeclaration)this.astStack[this.astPtr];
            anonymousTypeDeclaration.declarationSourceEnd = this.endStatementPosition;
            anonymousTypeDeclaration.bodyEnd = this.endStatementPosition;
            if (length == 0 && !containsComment(anonymousTypeDeclaration.bodyStart, anonymousTypeDeclaration.bodyEnd)) {
                  anonymousTypeDeclaration.bits |= ASTNode.UndocumentedEmptyBlockMASK;
            }
            this.astPtr--;
            this.astLengthPtr--;

            QualifiedAllocationExpression allocationExpression = anonymousTypeDeclaration.allocation;
            if (allocationExpression != null) {
                  allocationExpression.sourceEnd = this.endStatementPosition;
                  // handle type arguments
                  length = this.genericsLengthStack[this.genericsLengthPtr--];
                  this.genericsPtr -= length;
                  System.arraycopy(this.genericsStack, this.genericsPtr + 1, allocationExpression.typeArguments = new TypeReference[length], 0, length);
                  allocationExpression.sourceStart = intStack[intPtr--];
            }
            
            // mark initializers with local type mark if needed
            markInitializersWithLocalType(anonymousTypeDeclaration);
      }

      this.expressionLengthPtr--;
      QualifiedAllocationExpression qae = 
            (QualifiedAllocationExpression) this.expressionStack[this.expressionPtr--]; 
      qae.enclosingInstance = this.expressionStack[this.expressionPtr];
      this.expressionStack[this.expressionPtr] = qae;
      qae.sourceStart = qae.enclosingInstance.sourceStart;
}
protected void consumeClassInstanceCreationExpressionWithTypeArguments() {
      // ClassInstanceCreationExpression ::= 'new' TypeArguments ClassType '(' ArgumentListopt ')' ClassBodyopt
      AllocationExpression alloc;
      int length;
      if (((length = this.astLengthStack[this.astLengthPtr--]) == 1)
            && (this.astStack[this.astPtr] == null)) {
            //NO ClassBody
            this.astPtr--;
            alloc = new AllocationExpression();
            alloc.sourceEnd = this.endPosition; //the position has been stored explicitly

            if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
                  this.expressionPtr -= length;
                  System.arraycopy(
                        this.expressionStack, 
                        this.expressionPtr + 1, 
                        alloc.arguments = new Expression[length], 
                        0, 
                        length); 
            }
            alloc.type = getTypeReference(0);

            length = this.genericsLengthStack[this.genericsLengthPtr--];
            this.genericsPtr -= length;
            System.arraycopy(this.genericsStack, this.genericsPtr + 1, alloc.typeArguments = new TypeReference[length], 0, length);
            intPtr--;
            
            //the default constructor with the correct number of argument
            //will be created and added by the TC (see createsInternalConstructorWithBinding)
            alloc.sourceStart = this.intStack[this.intPtr--];
            pushOnExpressionStack(alloc);
      } else {
            dispatchDeclarationInto(length);
            TypeDeclaration anonymousTypeDeclaration = (TypeDeclaration)this.astStack[this.astPtr];
            anonymousTypeDeclaration.declarationSourceEnd = this.endStatementPosition;
            anonymousTypeDeclaration.bodyEnd = this.endStatementPosition;
            if (length == 0 && !containsComment(anonymousTypeDeclaration.bodyStart, anonymousTypeDeclaration.bodyEnd)) {
                  anonymousTypeDeclaration.bits |= ASTNode.UndocumentedEmptyBlockMASK;
            }
            this.astPtr--;
            this.astLengthPtr--;

            QualifiedAllocationExpression allocationExpression = anonymousTypeDeclaration.allocation;
            if (allocationExpression != null) {
                  allocationExpression.sourceEnd = this.endStatementPosition;
                  // handle type arguments
                  length = this.genericsLengthStack[this.genericsLengthPtr--];
                  this.genericsPtr -= length;
                  System.arraycopy(this.genericsStack, this.genericsPtr + 1, allocationExpression.typeArguments = new TypeReference[length], 0, length);
                  allocationExpression.sourceStart = intStack[intPtr--];
            }
            
            // mark initializers with local type mark if needed
            markInitializersWithLocalType(anonymousTypeDeclaration);
      }
}
protected void consumeClassOrInterface() {
      this.genericsIdentifiersLengthStack[this.genericsIdentifiersLengthPtr] += this.identifierLengthStack[this.identifierLengthPtr];
      pushOnGenericsLengthStack(0); // handle type arguments
}
protected void consumeClassOrInterfaceName() {
      pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
      pushOnGenericsLengthStack(0); // handle type arguments
}
protected void consumeClassTypeElt() {
      // ClassTypeElt ::= ClassType
      pushOnAstStack(getTypeReference(0));
      /* if incomplete thrown exception list, this.listLength counter will not have been reset,
            indicating that some items are available on the stack */
      this.listLength++;      
}
protected void consumeClassTypeList() {
      // ClassTypeList ::= ClassTypeList ',' ClassTypeElt
      optimizedConcatNodeLists();
}
protected void consumeCompilationUnit() {
      // CompilationUnit ::= EnterCompilationUnit InternalCompilationUnit
      // do nothing by default
}
protected void consumeConditionalExpression(int op) {
      // ConditionalExpression ::= ConditionalOrExpression '?' Expression ':' ConditionalExpression
      //optimize the push/pop
      this.intPtr -= 2;//consume position of the question mark
      this.expressionPtr -= 2;
      this.expressionLengthPtr -= 2;
      this.expressionStack[this.expressionPtr] =
            new ConditionalExpression(
                  this.expressionStack[this.expressionPtr],
                  this.expressionStack[this.expressionPtr + 1],
                  this.expressionStack[this.expressionPtr + 2]);
}
/**
 * @param op
 */
protected void consumeConditionalExpressionWithName(int op) {
      // ConditionalExpression ::= Name '?' Expression ':' ConditionalExpression
      this.intPtr -= 2;//consume position of the question mark
      pushOnExpressionStack(getUnspecifiedReferenceOptimized());
      this.expressionPtr -= 2;
      this.expressionLengthPtr -= 2;
      this.expressionStack[this.expressionPtr] =
            new ConditionalExpression(
                  this.expressionStack[this.expressionPtr + 2],
                  this.expressionStack[this.expressionPtr],
                  this.expressionStack[this.expressionPtr + 1]);
}
protected void consumeConstructorBlockStatements() {
      // ConstructorBody ::= NestedMethod '{' ExplicitConstructorInvocation BlockStatements '}'
      concatNodeLists(); // explictly add the first statement into the list of statements 
}
protected void consumeConstructorBody() {
      // ConstructorBody ::= NestedMethod  '{' BlockStatementsopt '}'
      // ConstructorBody ::= NestedMethod  '{' ExplicitConstructorInvocation '}'
      this.nestedMethod[this.nestedType] --;
}
protected void consumeConstructorDeclaration() {
      // ConstructorDeclaration ::= ConstructorHeader ConstructorBody

      /*
      this.astStack : MethodDeclaration statements
      this.identifierStack : name
       ==>
      this.astStack : MethodDeclaration
      this.identifierStack :
      */

      //must provide a default constructor call when needed

      int length;

      // pop the position of the {  (body of the method) pushed in block decl
      this.intPtr--;
      this.intPtr--;

      //statements
      this.realBlockPtr--;
      ExplicitConstructorCall constructorCall = null;
      Statement[] statements = null;
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            this.astPtr -= length;
            if (this.astStack[this.astPtr + 1] instanceof ExplicitConstructorCall) {
                  //avoid a isSomeThing that would only be used here BUT what is faster between two alternatives ?
                  System.arraycopy(
                        this.astStack, 
                        this.astPtr + 2, 
                        statements = new Statement[length - 1], 
                        0, 
                        length - 1); 
                  constructorCall = (ExplicitConstructorCall) this.astStack[this.astPtr + 1];
            } else { //need to add explicitly the super();
                  System.arraycopy(
                        this.astStack, 
                        this.astPtr + 1, 
                        statements = new Statement[length], 
                        0, 
                        length); 
                  constructorCall = SuperReference.implicitSuperConstructorCall();
            }
      } else {
            boolean insideFieldInitializer = false;
            if (this.diet) {
                  for (int i = this.nestedType; i > 0; i--){
                        if (this.variablesCounter[i] > 0) {
                              insideFieldInitializer = true;
                              break;
                        }
                  }
            }
            
            if (!this.diet || insideFieldInitializer){
                  // add it only in non-diet mode, if diet_bodies, then constructor call will be added elsewhere.
                  constructorCall = SuperReference.implicitSuperConstructorCall();
            }
      }

      // now we know that the top of stack is a constructorDeclaration
      ConstructorDeclaration cd = (ConstructorDeclaration) this.astStack[this.astPtr];
      cd.constructorCall = constructorCall;
      cd.statements = statements;

      //highlight of the implicit call on the method name
      if (constructorCall != null && cd.constructorCall.sourceEnd == 0) {
            cd.constructorCall.sourceEnd = cd.sourceEnd;
            cd.constructorCall.sourceStart = cd.sourceStart;
      }

      if (!this.diet && (statements == null && constructorCall.isImplicitSuper())) {
            if (!containsComment(cd.bodyStart, this.endPosition)) {
                  cd.bits |= ASTNode.UndocumentedEmptyBlockMASK;
            }
      }

      //watch for } that could be given as a unicode ! ( u007D is '}' )
      // store the this.endPosition (position just before the '}') in case there is
      // a trailing comment behind the end of the method
      cd.bodyEnd = this.endPosition;
      cd.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition); 
}
protected void consumeConstructorHeader() {
      // ConstructorHeader ::= ConstructorHeaderName MethodHeaderParameters MethodHeaderThrowsClauseopt

      AbstractMethodDeclaration method = (AbstractMethodDeclaration)this.astStack[this.astPtr];

      if (this.currentToken == TokenNameLBRACE){ 
            method.bodyStart = this.scanner.currentPosition;
      }
      // recovery
      if (this.currentElement != null){
            if (this.currentToken == TokenNameSEMICOLON){ // for invalid constructors
                  method.modifiers |= AccSemicolonBody;                 
                  method.declarationSourceEnd = this.scanner.currentPosition-1;
                  method.bodyEnd = this.scanner.currentPosition-1;
                  if (this.currentElement.parseTree() == method && this.currentElement.parent != null) {
                        this.currentElement = this.currentElement.parent;
                  }
            }           
            this.restartRecovery = true; // used to avoid branching back into the regular automaton
      }           
}
protected void consumeConstructorHeaderName() {

      /* recovering - might be an empty message send */
      if (this.currentElement != null){
            if (this.lastIgnoredToken == TokenNamenew){ // was an allocation expression
                  this.lastCheckPoint = this.scanner.startPosition; // force to restart at this exact position                      
                  this.restartRecovery = true;
                  return;
            }
      }
      
      // ConstructorHeaderName ::=  Modifiersopt 'Identifier' '('
      ConstructorDeclaration cd = new ConstructorDeclaration(this.compilationUnit.compilationResult);

      //name -- this is not really revelant but we do .....
      cd.selector = this.identifierStack[this.identifierPtr];
      long selectorSource = this.identifierPositionStack[this.identifierPtr--];
      this.identifierLengthPtr--;

      //modifiers
      cd.declarationSourceStart = this.intStack[this.intPtr--];
      cd.modifiers = this.intStack[this.intPtr--];
      // consume annotations
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            System.arraycopy(
                  this.expressionStack, 
                  (this.expressionPtr -= length) + 1, 
                  cd.annotations = new Annotation[length], 
                  0, 
                  length); 
      }     
      // javadoc
      cd.javadoc = this.javadoc;
      this.javadoc = null;

      //highlight starts at the selector starts
      cd.sourceStart = (int) (selectorSource >>> 32);
      pushOnAstStack(cd);
      cd.sourceEnd = this.lParenPos;
      cd.bodyStart = this.lParenPos+1;
      this.listLength = 0; // initialize this.listLength before reading parameters/throws

      // recovery
      if (this.currentElement != null){
            this.lastCheckPoint = cd.bodyStart;
            if ((this.currentElement instanceof RecoveredType && this.lastIgnoredToken != TokenNameDOT)
                  || cd.modifiers != 0){
                  this.currentElement = this.currentElement.add(cd, 0);
                  this.lastIgnoredToken = -1;
            }
      }     
}
protected void consumeConstructorHeaderNameWithTypeParameters() {

      /* recovering - might be an empty message send */
      if (this.currentElement != null){
            if (this.lastIgnoredToken == TokenNamenew){ // was an allocation expression
                  this.lastCheckPoint = this.scanner.startPosition; // force to restart at this exact position                      
                  this.restartRecovery = true;
                  return;
            }
      }
      
      // ConstructorHeaderName ::=  Modifiersopt TypeParameters 'Identifier' '('
      ConstructorDeclaration cd = new ConstructorDeclaration(this.compilationUnit.compilationResult);

      //name -- this is not really revelant but we do .....
      cd.selector = this.identifierStack[this.identifierPtr];
      long selectorSource = this.identifierPositionStack[this.identifierPtr--];
      this.identifierLengthPtr--;

      // consume type parameters
      int length = this.genericsLengthStack[this.genericsLengthPtr--];
      this.genericsPtr -= length;
      System.arraycopy(this.genericsStack, this.genericsPtr + 1, cd.typeParameters = new TypeParameter[length], 0, length);
      
      //modifiers
      cd.declarationSourceStart = this.intStack[this.intPtr--];
      cd.modifiers = this.intStack[this.intPtr--];
      // consume annotations
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            System.arraycopy(
                  this.expressionStack, 
                  (this.expressionPtr -= length) + 1, 
                  cd.annotations = new Annotation[length], 
                  0, 
                  length); 
      }
      // javadoc
      cd.javadoc = this.javadoc;
      this.javadoc = null;

      //highlight starts at the selector starts
      cd.sourceStart = (int) (selectorSource >>> 32);
      pushOnAstStack(cd);
      cd.sourceEnd = this.lParenPos;
      cd.bodyStart = this.lParenPos+1;
      this.listLength = 0; // initialize this.listLength before reading parameters/throws

      // recovery
      if (this.currentElement != null){
            this.lastCheckPoint = cd.bodyStart;
            if ((this.currentElement instanceof RecoveredType && this.lastIgnoredToken != TokenNameDOT)
                  || cd.modifiers != 0){
                  this.currentElement = this.currentElement.add(cd, 0);
                  this.lastIgnoredToken = -1;
            }
      }     
}
protected void consumeDefaultLabel() {
      // SwitchLabel ::= 'default' ':'
      pushOnAstStack(new CaseStatement(null, this.intStack[this.intPtr--], this.intStack[this.intPtr--]));
}
protected void consumeDefaultModifiers() {
      checkComment(); // might update modifiers with AccDeprecated
      pushOnIntStack(this.modifiers); // modifiers
      pushOnIntStack(
            this.modifiersSourceStart >= 0 ? this.modifiersSourceStart : this.scanner.startPosition); 
      resetModifiers();
      pushOnExpressionStackLengthStack(0); // no annotation
}
protected void consumeDiet() {
      // Diet ::= $empty
      checkComment();
      pushOnIntStack(this.modifiersSourceStart); // push the start position of a javadoc comment if there is one
      resetModifiers();
      jumpOverMethodBody();
}
protected void consumeDims() {
      // Dims ::= DimsLoop
      pushOnIntStack(this.dimensions);
      this.dimensions = 0;
}
protected void consumeDimWithOrWithOutExpr() {
      // DimWithOrWithOutExpr ::= '[' ']'
      pushOnExpressionStack(null);
      
      if(this.currentElement != null && this.currentToken == TokenNameLBRACE) {
            this.ignoreNextOpeningBrace = true;
            this.currentElement.bracketBalance++; 
      }
}
protected void consumeDimWithOrWithOutExprs() {
      // DimWithOrWithOutExprs ::= DimWithOrWithOutExprs DimWithOrWithOutExpr
      concatExpressionLists();
}
protected void consumeEmptyAnnotationTypeMemberDeclarationsopt() {
      // AnnotationTypeMemberDeclarationsopt ::= $empty
      pushOnAstLengthStack(0);
}
protected void consumeEmptyArgumentListopt() {
      // ArgumentListopt ::= $empty
      pushOnExpressionStackLengthStack(0);
}
protected void consumeEmptyArguments() {
      // Argumentsopt ::= $empty
      final FieldDeclaration fieldDeclaration = (FieldDeclaration) this.astStack[this.astPtr];
      pushOnIntStack(fieldDeclaration.sourceEnd);
      pushOnExpressionStackLengthStack(0);
}
protected void consumeEmptyArrayInitializer() {
      // ArrayInitializer ::= '{' ,opt '}'
      arrayInitializer(0);
}
protected void consumeEmptyArrayInitializeropt() {
      // ArrayInitializeropt ::= $empty
      pushOnExpressionStackLengthStack(0);
}
protected void consumeEmptyBlockStatementsopt() {
      // BlockStatementsopt ::= $empty
      pushOnAstLengthStack(0);
}
protected void consumeEmptyCatchesopt() {
      // Catchesopt ::= $empty
      pushOnAstLengthStack(0);
}
protected void consumeEmptyClassBodyDeclarationsopt() {
      // ClassBodyDeclarationsopt ::= $empty
      pushOnAstLengthStack(0);
}
protected void consumeEmptyClassMemberDeclaration() {
      // ClassMemberDeclaration ::= ';'
      pushOnAstLengthStack(0);
      problemReporter().superfluousSemicolon(this.endPosition+1, this.endStatementPosition);
      flushCommentsDefinedPriorTo(this.endStatementPosition);
}
protected void consumeEmptyMethodHeaderDefaultValue() {
      // DefaultValueopt ::= $empty
      AbstractMethodDeclaration method = (AbstractMethodDeclaration)this.astStack[this.astPtr];
      if(method.isAnnotationMethod()) { //'method' can be a MethodDeclaration when recovery is started
            pushOnExpressionStackLengthStack(0);
      }
}
protected void consumeEmptyDimsopt() {
      // Dimsopt ::= $empty
      pushOnIntStack(0);
}
protected void consumeEmptyEnumDeclarations() {
      // EnumBodyDeclarationsopt ::= $empty
      pushOnAstLengthStack(0);
}
protected void consumeEmptyExpression() {
      // Expressionopt ::= $empty
      pushOnExpressionStackLengthStack(0);
}
protected void consumeEmptyForInitopt() {
      // ForInitopt ::= $empty
      pushOnAstLengthStack(0);
}
protected void consumeEmptyForUpdateopt() {
      // ForUpdateopt ::= $empty
      pushOnExpressionStackLengthStack(0);
}
protected void consumeEmptyInterfaceMemberDeclaration() {
      // InterfaceMemberDeclaration ::= ';'
      pushOnAstLengthStack(0);
}
protected void consumeEmptyInterfaceMemberDeclarationsopt() {
      // InterfaceMemberDeclarationsopt ::= $empty
      pushOnAstLengthStack(0);
}
protected void consumeEmptyInternalCompilationUnit() {
      // InternalCompilationUnit ::= $empty
      // nothing to do by default
}
protected void consumeEmptyMemberValuePairsopt() {
      // MemberValuePairsopt ::= $empty
      pushOnAstLengthStack(0);
}
protected void consumeEmptyMemberValueArrayInitializer() {
      // MemberValueArrayInitializer ::= '{' ',' '}'
      // MemberValueArrayInitializer ::= '{' '}'
      arrayInitializer(0);
}
protected void consumeEmptyStatement() {
      // EmptyStatement ::= ';'
      if (this.scanner.source[this.endStatementPosition] == ';') {
            pushOnAstStack(new EmptyStatement(this.endStatementPosition, this.endStatementPosition));
      } else {
            // we have a Unicode for the ';' (/u003B)
            pushOnAstStack(new EmptyStatement(this.endStatementPosition - 5, this.endStatementPosition));
      }
}
protected void consumeEmptySwitchBlock() {
      // SwitchBlock ::= '{' '}'
      pushOnAstLengthStack(0);
}
protected void consumeEmptyTypeDeclaration() {
      // TypeDeclaration ::= ';' 
      pushOnAstLengthStack(0);
      problemReporter().superfluousSemicolon(this.endPosition+1, this.endStatementPosition);
      flushCommentsDefinedPriorTo(this.endStatementPosition);
}
protected void consumeEnhancedForStatementHeader(boolean hasModifiers){
      // EnhancedForStatementHeader ::= 'for' '(' Type PushModifiers Identifier Dimsopt ':' Expression ')'
      // EnhancedForStatementHeader ::= 'for' '(' Modifiers Type PushRealModifiers Identifier Dimsopt ':' Expression ')'
      TypeReference type;

      char[] identifierName = this.identifierStack[this.identifierPtr];
      long namePosition = this.identifierPositionStack[this.identifierPtr];
      
      LocalDeclaration localDeclaration = createLocalDeclaration(identifierName, (int) (namePosition >>> 32), (int) namePosition);
      localDeclaration.declarationSourceEnd = localDeclaration.declarationEnd;
      
      int extraDims = this.intStack[this.intPtr--];
      this.identifierPtr--;
      this.identifierLengthPtr--;
      // remove fake modifiers/modifiers start
      int declarationSourceStart = 0;
      int modifiersValue  = 0;
      if (hasModifiers) {
            declarationSourceStart = this.intStack[this.intPtr--];
            modifiersValue = this.intStack[this.intPtr--];
      } else {
            this.intPtr-=2;
      }

      //updates are on the expression stack
      this.expressionLengthPtr--;
      Expression collection = this.expressionStack[this.expressionPtr--];
      
      type = getTypeReference(this.intStack[this.intPtr--] + extraDims); // type dimension

      // consume annotations
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--])!= 0) {
            System.arraycopy(
                  this.expressionStack, 
                  (this.expressionPtr -= length) + 1, 
                  localDeclaration.annotations = new Annotation[length], 
                  0, 
                  length); 
      }
      if (hasModifiers) {
            localDeclaration.declarationSourceStart = declarationSourceStart;
            localDeclaration.modifiers = modifiersValue;
      } else {
            localDeclaration.declarationSourceStart = type.sourceStart;
      }
      localDeclaration.type = type;

      ForeachStatement iteratorForStatement =
            new ForeachStatement(
                  localDeclaration,
                  collection,
                  this.intStack[this.intPtr--]); 
      pushOnAstStack(iteratorForStatement);
      
      if(options.sourceLevel < ClassFileConstants.JDK1_5 &&
                  this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
            this.problemReporter().invalidUsageOfForeachStatements(localDeclaration, collection);
      }
}
protected void consumeEnhancedForStatement() {
      // EnhancedForStatement ::= EnhancedForStatementHeader Statement
      // EnhancedForStatementNoShortIf ::= EnhancedForStatementHeader StatementNoShortIf

      //statements
      this.astLengthPtr--;
      Statement statement = (Statement) this.astStack[this.astPtr--];

      // foreach statement is on the ast stack
      ForeachStatement foreachStatement = (ForeachStatement) this.astStack[this.astPtr];
      foreachStatement.action = statement;
      // remember useful empty statement
      if (statement instanceof EmptyStatement) statement.bits |= ASTNode.IsUsefulEmptyStatementMASK;
      
      foreachStatement.sourceEnd = this.endStatementPosition;
}
protected void consumeEnterAnonymousClassBody() {
      // EnterAnonymousClassBody ::= $empty
      TypeReference typeReference = getTypeReference(0);

      TypeDeclaration anonymousType = new TypeDeclaration(this.compilationUnit.compilationResult); 
      anonymousType.name = TypeDeclaration.ANONYMOUS_EMPTY_NAME;
      anonymousType.bits |= ASTNode.AnonymousAndLocalMask;
      QualifiedAllocationExpression alloc = new QualifiedAllocationExpression(anonymousType); 
      markEnclosingMemberWithLocalType();
      pushOnAstStack(anonymousType);

      alloc.sourceEnd = this.rParenPos; //the position has been stored explicitly
      int argumentLength;
      if ((argumentLength = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            this.expressionPtr -= argumentLength;
            System.arraycopy(
                  this.expressionStack, 
                  this.expressionPtr + 1, 
                  alloc.arguments = new Expression[argumentLength], 
                  0, 
                  argumentLength); 
      }
      alloc.type = typeReference;

      anonymousType.sourceEnd = alloc.sourceEnd;
      //position at the type while it impacts the anonymous declaration
      anonymousType.sourceStart = anonymousType.declarationSourceStart = alloc.type.sourceStart;
      alloc.sourceStart = this.intStack[this.intPtr--];
      pushOnExpressionStack(alloc);

      anonymousType.bodyStart = this.scanner.currentPosition;     
      this.listLength = 0; // will be updated when reading super-interfaces
      
      // flush the comments related to the anonymous
      this.scanner.commentPtr = -1;
      
      // recovery
      if (this.currentElement != null){ 
            this.lastCheckPoint = anonymousType.bodyStart;        
            this.currentElement = this.currentElement.add(anonymousType, 0);
            this.currentToken = 0; // opening brace already taken into account
            this.lastIgnoredToken = -1;
      }     
}
protected void consumeEnterCompilationUnit() {
      // EnterCompilationUnit ::= $empty
      // do nothing by default
}
protected void consumeEnterMemberValue() {
      // EnterMemberValue ::= $empty
      if(this.currentElement != null && this.currentToken == TokenNameLBRACE) {
            this.ignoreNextOpeningBrace = true;
            this.currentElement.bracketBalance++; 
      }
}
protected void consumeEnterVariable() {
      // EnterVariable ::= $empty
      // do nothing by default

      char[] identifierName = this.identifierStack[this.identifierPtr];
      long namePosition = this.identifierPositionStack[this.identifierPtr];
      int extendedDimension = this.intStack[this.intPtr--];
      AbstractVariableDeclaration declaration;
      // create the ast node
      boolean isLocalDeclaration = this.nestedMethod[this.nestedType] != 0; 
      if (isLocalDeclaration) {
            // create the local variable declarations
            declaration = 
                  this.createLocalDeclaration(identifierName, (int) (namePosition >>> 32), (int) namePosition);
      } else {
            // create the field declaration
            declaration = 
                  this.createFieldDeclaration(identifierName, (int) (namePosition >>> 32), (int) namePosition); 
      }
      
      this.identifierPtr--;
      this.identifierLengthPtr--;
      TypeReference type;
      int variableIndex = this.variablesCounter[this.nestedType];
      int typeDim = 0;
      if (variableIndex == 0) {
            // first variable of the declaration (FieldDeclaration or LocalDeclaration)
            if (isLocalDeclaration) {
                  declaration.declarationSourceStart = this.intStack[this.intPtr--];
                  declaration.modifiers = this.intStack[this.intPtr--];
                  // consume annotations
                  int length;
                  if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
                        System.arraycopy(
                              this.expressionStack, 
                              (this.expressionPtr -= length) + 1, 
                              declaration.annotations = new Annotation[length], 
                              0, 
                              length); 
                  }     
                  type = getTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension
                  if (declaration.declarationSourceStart == -1) {
                        // this is true if there is no modifiers for the local variable declaration
                        declaration.declarationSourceStart = type.sourceStart;
                  }
                  pushOnAstStack(type);
            } else {
                  type = getTypeReference(typeDim = this.intStack[this.intPtr--]); // type dimension
                  pushOnAstStack(type);
                  declaration.declarationSourceStart = this.intStack[this.intPtr--];
                  declaration.modifiers = this.intStack[this.intPtr--];
                  // consume annotations
                  int length;
                  if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
                        System.arraycopy(
                              this.expressionStack, 
                              (this.expressionPtr -= length) + 1, 
                              declaration.annotations = new Annotation[length], 
                              0, 
                              length); 
                  }                 
                  // Store javadoc only on first declaration as it is the same for all ones
                  FieldDeclaration fieldDeclaration = (FieldDeclaration) declaration;
                  fieldDeclaration.javadoc = this.javadoc;
                  this.javadoc = null;
            }
      } else {
            type = (TypeReference) this.astStack[this.astPtr - variableIndex];
            typeDim = type.dimensions();
            AbstractVariableDeclaration previousVariable = 
                  (AbstractVariableDeclaration) this.astStack[this.astPtr]; 
            declaration.declarationSourceStart = previousVariable.declarationSourceStart;
            declaration.modifiers = previousVariable.modifiers;
      }

      if (extendedDimension == 0) {
            declaration.type = type;
      } else {
            int dimension = typeDim + extendedDimension;
            declaration.type = this.copyDims(type, dimension);
      }
      this.variablesCounter[this.nestedType]++;
      pushOnAstStack(declaration);
      // recovery
      if (this.currentElement != null) {
            if (!(this.currentElement instanceof RecoveredType)
                  && (this.currentToken == TokenNameDOT
                        //|| declaration.modifiers != 0
                        || (this.scanner.getLineNumber(declaration.type.sourceStart)
                                    != this.scanner.getLineNumber((int) (namePosition >>> 32))))){
                  this.lastCheckPoint = (int) (namePosition >>> 32);
                  this.restartRecovery = true;
                  return;
            }
            if (isLocalDeclaration){
                  LocalDeclaration localDecl = (LocalDeclaration) this.astStack[this.astPtr];
                  this.lastCheckPoint = localDecl.sourceEnd + 1;
                  this.currentElement = this.currentElement.add(localDecl, 0);
            } else {
                  FieldDeclaration fieldDecl = (FieldDeclaration) this.astStack[this.astPtr];
                  this.lastCheckPoint = fieldDecl.sourceEnd + 1;
                  this.currentElement = this.currentElement.add(fieldDecl, 0);
            }
            this.lastIgnoredToken = -1;
      }
}
protected void consumeEnumBodyNoConstants() {
      // nothing to do
      // The 0 on the astLengthStack has been pushed by EnumBodyDeclarationsopt
}
protected void consumeEnumBodyWithConstants() {
      // merge the constants values with the class body
      concatNodeLists();
}
protected void consumeEnumConstantHeaderName() {
      if (this.currentElement != null) {
            if (!(this.currentElement instanceof RecoveredType
                              || (this.currentElement instanceof RecoveredField && ((RecoveredField)currentElement).fieldDeclaration.type == null))
                        || (this.lastIgnoredToken == TokenNameDOT)) {
                  this.lastCheckPoint = this.scanner.startPosition;
                  this.restartRecovery = true;
                  return;
            }
      }
   long namePosition = this.identifierPositionStack[this.identifierPtr];
   char[] constantName = this.identifierStack[this.identifierPtr];
   final int sourceEnd = (int) namePosition;
   FieldDeclaration enumConstant = createFieldDeclaration(constantName, (int) (namePosition >>> 32), sourceEnd);
   this.identifierPtr--;
   this.identifierLengthPtr--;
   enumConstant.modifiersSourceStart = this.intStack[this.intPtr--];
   enumConstant.modifiers = this.intStack[this.intPtr--];
   enumConstant.declarationSourceStart = enumConstant.modifiersSourceStart;
   // consume annotations
   int length;
   if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
      System.arraycopy(
         this.expressionStack, 
         (this.expressionPtr -= length) + 1, 
         enumConstant.annotations = new Annotation[length], 
         0, 
         length); 
   }
   pushOnAstStack(enumConstant);
      if (this.currentElement != null){
            this.lastCheckPoint = enumConstant.sourceEnd + 1;
            this.currentElement = this.currentElement.add(enumConstant, 0);         
      }
      // javadoc
      enumConstant.javadoc = this.javadoc;
      this.javadoc = null;
}
protected void consumeEnumConstantHeader() {
   FieldDeclaration enumConstant = (FieldDeclaration) this.astStack[this.astPtr];
   boolean foundOpeningBrace = this.currentToken == TokenNameLBRACE;
   if (foundOpeningBrace){
      // qualified allocation expression
      TypeDeclaration anonymousType = new TypeDeclaration(this.compilationUnit.compilationResult);
      anonymousType.name = TypeDeclaration.ANONYMOUS_EMPTY_NAME;
      anonymousType.bits |= ASTNode.AnonymousAndLocalMask;
      final int start = this.scanner.startPosition;
      anonymousType.declarationSourceStart = start;
      anonymousType.sourceStart = start;
      anonymousType.sourceEnd = start; // closing parenthesis
      anonymousType.modifiers = 0;
      anonymousType.bodyStart = this.scanner.currentPosition;
      markEnclosingMemberWithLocalType();
      pushOnAstStack(anonymousType);
      QualifiedAllocationExpression allocationExpression = new QualifiedAllocationExpression(anonymousType);
      allocationExpression.enumConstant = enumConstant;
      
      // fill arguments if needed
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
         this.expressionPtr -= length;
         System.arraycopy(
               this.expressionStack, 
               this.expressionPtr + 1, 
               allocationExpression.arguments = new Expression[length], 
               0, 
               length); 
      }
      enumConstant.initialization = allocationExpression;
   } else {
      AllocationExpression allocationExpression = new AllocationExpression();
      allocationExpression.enumConstant = enumConstant;
      // fill arguments if needed
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
         this.expressionPtr -= length;
         System.arraycopy(
               this.expressionStack, 
               this.expressionPtr + 1, 
               allocationExpression.arguments = new Expression[length], 
               0, 
               length); 
      }
      enumConstant.initialization = allocationExpression;
   }
   
   // recovery
   if (this.currentElement != null) {
        if(foundOpeningBrace) {
            TypeDeclaration anonymousType = (TypeDeclaration) this.astStack[this.astPtr];
            this.currentElement = this.currentElement.add(anonymousType, 0);
            this.lastCheckPoint = anonymousType.bodyStart;
        this.lastIgnoredToken = -1;
        this.currentToken = 0; // opening brace already taken into account
        } else {
              if(this.currentToken == TokenNameSEMICOLON) {
                  RecoveredType currentType = this.currentRecoveryType();
                  if(currentType != null) {
                        currentType.insideEnumConstantPart = false;
                  }
              }
            if (!(this.currentElement instanceof RecoveredType)
                  && (this.currentToken == TokenNameDOT)){
               this.lastCheckPoint = enumConstant.sourceStart;
               this.restartRecovery = true;
               return;
            }
              this.lastCheckPoint = this.scanner.startPosition; // force to restart at this exact position
            this.lastIgnoredToken = -1;
            this.restartRecovery = true;
        }
   }
}
protected void consumeEnumConstantNoClassBody() {
      // set declarationEnd and declarationSourceEnd
      int endOfEnumConstant = intStack[intPtr--];
      final FieldDeclaration fieldDeclaration = (FieldDeclaration) this.astStack[this.astPtr];
      fieldDeclaration.declarationEnd = endOfEnumConstant;
      fieldDeclaration.declarationSourceEnd = endOfEnumConstant;
}
protected void consumeEnumConstants() {
      concatNodeLists();
}
protected void consumeEnumConstantWithClassBody() {
   dispatchDeclarationInto(this.astLengthStack[this.astLengthPtr--]);
   TypeDeclaration anonymousType = (TypeDeclaration) this.astStack[this.astPtr--]; // pop type
   this.astLengthPtr--;
   anonymousType.bodyEnd = this.endPosition;
   anonymousType.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
   final FieldDeclaration fieldDeclaration = ((FieldDeclaration) this.astStack[this.astPtr]);
   fieldDeclaration.declarationEnd = this.endStatementPosition;
   fieldDeclaration.declarationSourceEnd = anonymousType.declarationSourceEnd;
   intPtr --; // remove end position of the arguments
}
protected void consumeEnumDeclaration() {
      // EnumDeclaration ::= EnumHeader ClassHeaderImplementsopt EnumBody
      int length;
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            //there are length declarations
            //dispatch according to the type of the declarations
            dispatchDeclarationIntoEnumDeclaration(length);
      }

      TypeDeclaration enumDeclaration = (TypeDeclaration) this.astStack[this.astPtr];

      // mark initializers with local type mark if needed
      markInitializersWithLocalType(enumDeclaration);

      //convert constructor that do not have the type's name into methods
      boolean hasConstructor = enumDeclaration.checkConstructors(this);
      
      //add the default constructor when needed
      if (!hasConstructor) {
            boolean insideFieldInitializer = false;
            if (this.diet) {
                  for (int i = this.nestedType; i > 0; i--){
                        if (this.variablesCounter[i] > 0) {
                              insideFieldInitializer = true;
                              break;
                        }
                  }
            }
            enumDeclaration.createDefaultConstructor(!this.diet || insideFieldInitializer, true);
      }

      //always add <clinit> (will be remove at code gen time if empty)
      if (this.scanner.containsAssertKeyword) {
            enumDeclaration.bits |= ASTNode.AddAssertionMASK;
      }
      enumDeclaration.addClinit();
      enumDeclaration.bodyEnd = this.endStatementPosition;
      if (length == 0 && !containsComment(enumDeclaration.bodyStart, enumDeclaration.bodyEnd)) {
            enumDeclaration.bits |= ASTNode.UndocumentedEmptyBlockMASK;
      }

      enumDeclaration.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition); 
}
protected void consumeEnumDeclarations() {
      // Do nothing by default
}
protected void consumeEnumHeader() {
      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];      
      if (this.currentToken == TokenNameLBRACE) { 
            typeDecl.bodyStart = this.scanner.currentPosition;
      }

      if (this.currentElement != null) {
            this.restartRecovery = true; // used to avoid branching back into the regular automaton         
      }
      
      // flush the comments related to the enum header
      this.scanner.commentPtr = -1;
}
protected void consumeEnumHeaderName() {
      // EnumHeaderName ::= Modifiersopt 'enum' Identifier
      TypeDeclaration enumDeclaration = new TypeDeclaration(this.compilationUnit.compilationResult);
      if (this.nestedMethod[this.nestedType] == 0) {
            if (this.nestedType != 0) {
                  enumDeclaration.bits |= ASTNode.IsMemberTypeMASK;
            }           
      } else {
            // Record that the block has a declaration for local types
//          markEnclosingMemberWithLocalType();
            blockReal();
      }
      //highlight the name of the type
      long pos = this.identifierPositionStack[this.identifierPtr];
      enumDeclaration.sourceEnd = (int) pos;
      enumDeclaration.sourceStart = (int) (pos >>> 32);
      enumDeclaration.name = this.identifierStack[this.identifierPtr--];
      this.identifierLengthPtr--;

      //compute the declaration source too
      // 'class' and 'interface' push two int positions: the beginning of the class token and its end.
      // we want to keep the beginning position but get rid of the end position
      // it is only used for the ClassLiteralAccess positions.
      enumDeclaration.declarationSourceStart = this.intStack[this.intPtr--]; 
      this.intPtr--; // remove the end position of the class token

      enumDeclaration.modifiersSourceStart = this.intStack[this.intPtr--];
      enumDeclaration.modifiers = this.intStack[this.intPtr--] | AccEnum;
      if (enumDeclaration.modifiersSourceStart >= 0) {
            enumDeclaration.declarationSourceStart = enumDeclaration.modifiersSourceStart;
      }
      // consume annotations
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            System.arraycopy(
                  this.expressionStack, 
                  (this.expressionPtr -= length) + 1, 
                  enumDeclaration.annotations = new Annotation[length], 
                  0, 
                  length); 
      }
//    if (this.currentToken == TokenNameLBRACE) { 
//          enumDeclaration.bodyStart = this.scanner.currentPosition;
//    }
      enumDeclaration.bodyStart = enumDeclaration.sourceEnd + 1;
      pushOnAstStack(enumDeclaration);

      this.listLength = 0; // will be updated when reading super-interfaces
      
      if(options.sourceLevel < ClassFileConstants.JDK1_5 &&
                  this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
            //TODO this code will be never run while 'enum' is an identifier in 1.3 scanner 
            this.problemReporter().invalidUsageOfEnumDeclarations(enumDeclaration);
      }
      
      // recovery
      if (this.currentElement != null){ 
            this.lastCheckPoint = enumDeclaration.bodyStart;
            this.currentElement = this.currentElement.add(enumDeclaration, 0);
            this.lastIgnoredToken = -1;
      }
      // javadoc
      enumDeclaration.javadoc = this.javadoc;
      this.javadoc = null;
}
protected void consumeEqualityExpression(int op) {
      // EqualityExpression ::= EqualityExpression '==' RelationalExpression
      // EqualityExpression ::= EqualityExpression '!=' RelationalExpression

      //optimize the push/pop

      this.expressionPtr--;
      this.expressionLengthPtr--;
      this.expressionStack[this.expressionPtr] =
            new EqualExpression(
                  this.expressionStack[this.expressionPtr],
                  this.expressionStack[this.expressionPtr + 1],
                  op);
}
/*
 * @param op
 */
protected void consumeEqualityExpressionWithName(int op) {
      // EqualityExpression ::= Name '==' RelationalExpression
      // EqualityExpression ::= Name '!=' RelationalExpression
      pushOnExpressionStack(getUnspecifiedReferenceOptimized());
      this.expressionPtr--;
      this.expressionLengthPtr--;
      this.expressionStack[this.expressionPtr] =
            new EqualExpression(
                  this.expressionStack[this.expressionPtr + 1],
                  this.expressionStack[this.expressionPtr],
                  op);
}
protected void consumeExitMemberValue() {
      // ExitMemberValue ::= $empty
      // do nothing by default
}
protected void consumeExitTryBlock() {
      //ExitTryBlock ::= $empty
      if(this.currentElement != null) {
            this.restartRecovery = true;
      }
}
protected void consumeExitVariableWithInitialization() {
      // ExitVariableWithInitialization ::= $empty
      // do nothing by default
      this.expressionLengthPtr--;
      AbstractVariableDeclaration variableDecl = (AbstractVariableDeclaration) this.astStack[this.astPtr];
      variableDecl.initialization = this.expressionStack[this.expressionPtr--];
      // we need to update the declarationSourceEnd of the local variable declaration to the
      // source end position of the initialization expression
      variableDecl.declarationSourceEnd = variableDecl.initialization.sourceEnd;
      variableDecl.declarationEnd = variableDecl.initialization.sourceEnd;
      
      this.recoveryExitFromVariable();
}
protected void consumeExitVariableWithoutInitialization() {
      // ExitVariableWithoutInitialization ::= $empty
      // do nothing by default
      
      AbstractVariableDeclaration variableDecl = (AbstractVariableDeclaration) this.astStack[this.astPtr];
      variableDecl.declarationSourceEnd = variableDecl.declarationEnd;
      if(this.currentElement != null && this.currentElement instanceof RecoveredField) {
            if(this.endStatementPosition > variableDecl.sourceEnd) {
                  this.currentElement.updateSourceEndIfNecessary(this.endStatementPosition);
            }
      }
      this.recoveryExitFromVariable();
}
protected void consumeExplicitConstructorInvocation(int flag, int recFlag) {

      /* flag allows to distinguish 3 cases :
      (0) :   
      ExplicitConstructorInvocation ::= 'this' '(' ArgumentListopt ')' ';'
      ExplicitConstructorInvocation ::= 'super' '(' ArgumentListopt ')' ';'
      (1) :
      ExplicitConstructorInvocation ::= Primary '.' 'super' '(' ArgumentListopt ')' ';'
      ExplicitConstructorInvocation ::= Primary '.' 'this' '(' ArgumentListopt ')' ';'
      (2) :
      ExplicitConstructorInvocation ::= Name '.' 'super' '(' ArgumentListopt ')' ';'
      ExplicitConstructorInvocation ::= Name '.' 'this' '(' ArgumentListopt ')' ';'
      */
      int startPosition = this.intStack[this.intPtr--];
      ExplicitConstructorCall ecc = new ExplicitConstructorCall(recFlag);
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            this.expressionPtr -= length;
            System.arraycopy(this.expressionStack, this.expressionPtr + 1, ecc.arguments = new Expression[length], 0, length);
      }
      switch (flag) {
            case 0 :
                  ecc.sourceStart = startPosition;
                  break;
            case 1 :
                  this.expressionLengthPtr--;
                  ecc.sourceStart = (ecc.qualification = this.expressionStack[this.expressionPtr--]).sourceStart;
                  break;
            case 2 :
                  ecc.sourceStart = (ecc.qualification = getUnspecifiedReferenceOptimized()).sourceStart;
                  break;
      }
      pushOnAstStack(ecc);
      ecc.sourceEnd = this.endPosition;
}
protected void consumeExplicitConstructorInvocationWithTypeArguments(int flag, int recFlag) {

      /* flag allows to distinguish 3 cases :
      (0) :   
      ExplicitConstructorInvocation ::= TypeArguments 'this' '(' ArgumentListopt ')' ';'
      ExplicitConstructorInvocation ::= TypeArguments 'super' '(' ArgumentListopt ')' ';'
      (1) :
      ExplicitConstructorInvocation ::= Primary '.' TypeArguments 'super' '(' ArgumentListopt ')' ';'
      ExplicitConstructorInvocation ::= Primary '.' TypeArguments 'this' '(' ArgumentListopt ')' ';'
      (2) :
      ExplicitConstructorInvocation ::= Name '.' TypeArguments 'super' '(' ArgumentListopt ')' ';'
      ExplicitConstructorInvocation ::= Name '.' TypeArguments 'this' '(' ArgumentListopt ')' ';'
      */
      int startPosition = this.intStack[this.intPtr--];
      ExplicitConstructorCall ecc = new ExplicitConstructorCall(recFlag);
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            this.expressionPtr -= length;
            System.arraycopy(this.expressionStack, this.expressionPtr + 1, ecc.arguments = new Expression[length], 0, length);
      }
      length = this.genericsLengthStack[this.genericsLengthPtr--];
      this.genericsPtr -= length;
      System.arraycopy(this.genericsStack, this.genericsPtr + 1, ecc.typeArguments = new TypeReference[length], 0, length);
      ecc.typeArgumentsSourceStart = this.intStack[intPtr--];

      switch (flag) {
            case 0 :
                  ecc.sourceStart = startPosition;
                  break;
            case 1 :
                  this.expressionLengthPtr--;
                  ecc.sourceStart = (ecc.qualification = this.expressionStack[this.expressionPtr--]).sourceStart;
                  break;
            case 2 :
                  ecc.sourceStart = (ecc.qualification = getUnspecifiedReferenceOptimized()).sourceStart;
                  break;
      }
      
      pushOnAstStack(ecc);
      ecc.sourceEnd = this.endPosition;
}
protected void consumeExpressionStatement() {
      // ExpressionStatement ::= StatementExpression ';'
      this.expressionLengthPtr--;
      pushOnAstStack(this.expressionStack[this.expressionPtr--]);
}
protected void consumeFieldAccess(boolean isSuperAccess) {
      // FieldAccess ::= Primary '.' 'Identifier'
      // FieldAccess ::= 'super' '.' 'Identifier'

      FieldReference fr =
            new FieldReference(
                  this.identifierStack[this.identifierPtr],
                  this.identifierPositionStack[this.identifierPtr--]);
      this.identifierLengthPtr--;
      if (isSuperAccess) {
            //considerates the fieldReference beginning at the 'super' ....   
            fr.sourceStart = this.intStack[this.intPtr--];
            fr.receiver = new SuperReference(fr.sourceStart, this.endPosition);
            pushOnExpressionStack(fr);
      } else {
            //optimize push/pop
            fr.receiver = this.expressionStack[this.expressionPtr];
            //fieldreference begins at the receiver
            fr.sourceStart = fr.receiver.sourceStart;
            this.expressionStack[this.expressionPtr] = fr;
      }
}
protected void consumeFieldDeclaration() {
      // See consumeLocalVariableDeclarationDefaultModifier() in case of change: duplicated code
      // FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';'

      /*
      this.astStack : 
      this.expressionStack: Expression Expression ...... Expression
      this.identifierStack : type  identifier identifier ...... identifier
      this.intStack : typeDim      dim        dim               dim
       ==>
      this.astStack : FieldDeclaration FieldDeclaration ...... FieldDeclaration
      this.expressionStack :
      this.identifierStack : 
      this.intStack : 
        
      */
      int variableDeclaratorsCounter = this.astLengthStack[this.astLengthPtr];

      for (int i = variableDeclaratorsCounter - 1; i >= 0; i--) {
            FieldDeclaration fieldDeclaration = (FieldDeclaration) this.astStack[this.astPtr - i];
            fieldDeclaration.declarationSourceEnd = this.endStatementPosition; 
            fieldDeclaration.declarationEnd = this.endStatementPosition;      // semi-colon included
      }
      
      updateSourceDeclarationParts(variableDeclaratorsCounter);
      int endPos = flushCommentsDefinedPriorTo(this.endStatementPosition);
      if (endPos != this.endStatementPosition) {
            for (int i = 0; i < variableDeclaratorsCounter; i++) {
                  FieldDeclaration fieldDeclaration = (FieldDeclaration) this.astStack[this.astPtr - i];
                  fieldDeclaration.declarationSourceEnd = endPos;
            }
      }
      // update the this.astStack, this.astPtr and this.astLengthStack
      int startIndex = this.astPtr - this.variablesCounter[this.nestedType] + 1;
      System.arraycopy(
            this.astStack, 
            startIndex, 
            this.astStack, 
            startIndex - 1, 
            variableDeclaratorsCounter); 
      this.astPtr--; // remove the type reference
      this.astLengthStack[--this.astLengthPtr] = variableDeclaratorsCounter;

      // recovery
      if (this.currentElement != null) {
            this.lastCheckPoint = endPos + 1;
            if (this.currentElement.parent != null && this.currentElement instanceof RecoveredField){
                  if (!(this.currentElement instanceof RecoveredInitializer)) {
                        this.currentElement = this.currentElement.parent;
                  }
            }
            this.restartRecovery = true;
      }
      this.variablesCounter[this.nestedType] = 0;
}
protected void consumeForceNoDiet() {
      // ForceNoDiet ::= $empty
      this.dietInt++;
}
protected void consumeForInit() {
      // ForInit ::= StatementExpressionList
      pushOnAstLengthStack(-1);
}
protected void consumeFormalParameter(boolean isVarArgs) {
      // FormalParameter ::= Type VariableDeclaratorId ==> false
      // FormalParameter ::= Modifiers Type VariableDeclaratorId ==> true
      /*
      this.astStack : 
      this.identifierStack : type identifier
      this.intStack : dim dim
       ==>
      this.astStack : Argument
      this.identifierStack :   
      this.intStack :  
      */

      this.identifierLengthPtr--;
      char[] identifierName = this.identifierStack[this.identifierPtr];
      long namePositions = this.identifierPositionStack[this.identifierPtr--];
      int extendedDimensions = this.intStack[this.intPtr--];
      int endOfEllipsis = 0;
      if (isVarArgs) {
            endOfEllipsis = this.intStack[this.intPtr--];
      }
      int firstDimensions = this.intStack[this.intPtr--];
      final int typeDimensions = firstDimensions + extendedDimensions;
      TypeReference type = getTypeReference(typeDimensions);
      if (isVarArgs) {
            type = copyDims(type, typeDimensions + 1);
            if (extendedDimensions == 0) {
                  type.sourceEnd = endOfEllipsis;
            }
            type.bits |= ASTNode.IsVarArgs; // set isVarArgs
      }
      int modifierPositions = this.intStack[this.intPtr--];
      this.intPtr--;
      Argument arg = 
            new Argument(
                  identifierName, 
                  namePositions, 
                  type, 
                  this.intStack[this.intPtr + 1] & ~AccDeprecated); // modifiers
      arg.declarationSourceStart = modifierPositions;
      // consume annotations
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            System.arraycopy(
                  this.expressionStack, 
                  (this.expressionPtr -= length) + 1, 
                  arg.annotations = new Annotation[length], 
                  0, 
                  length); 
      }
      pushOnAstStack(arg);

      /* if incomplete method header, this.listLength counter will not have been reset,
            indicating that some arguments are available on the stack */
      this.listLength++;      
      
      if(isVarArgs) {
            if (options.sourceLevel < ClassFileConstants.JDK1_5 &&
                        this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
                        this.problemReporter().invalidUsageOfVarargs(arg);
            } else if (extendedDimensions > 0) {
                  this.problemReporter().illegalExtendedDimensions(arg);
            }
      }
}
protected void consumeFormalParameterList() {
      // FormalParameterList ::= FormalParameterList ',' FormalParameter
      optimizedConcatNodeLists();
}
protected void consumeFormalParameterListopt() {
      // FormalParameterListopt ::= $empty
      pushOnAstLengthStack(0);
}
protected void consumeGenericType() {
      // nothing to do
      // Will be consume by a getTypeRefence call
}
protected void consumeGenericTypeArrayType() {
      // nothing to do
      // Will be consume by a getTypeRefence call
}
protected void consumeGenericTypeNameArrayType() {
      // nothing to do
      // Will be consume by a getTypeRefence call
}
protected void consumeImportDeclaration() {
      // SingleTypeImportDeclaration ::= SingleTypeImportDeclarationName ';'
      ImportReference impt = (ImportReference) this.astStack[this.astPtr];
      // flush annotations defined prior to import statements
      impt.declarationEnd = this.endStatementPosition;
      impt.declarationSourceEnd = 
            this.flushCommentsDefinedPriorTo(impt.declarationSourceEnd); 

      // recovery
      if (this.currentElement != null) {
            this.lastCheckPoint = impt.declarationSourceEnd + 1;
            this.currentElement = this.currentElement.add(impt, 0);
            this.lastIgnoredToken = -1;
            this.restartRecovery = true; 
            // used to avoid branching back into the regular automaton
      }
}
protected void consumeImportDeclarations() {
      // ImportDeclarations ::= ImportDeclarations ImportDeclaration 
      optimizedConcatNodeLists();
}
protected void consumeInsideCastExpression() {
      // InsideCastExpression ::= $empty
}
protected void consumeInsideCastExpressionLL1() {
      // InsideCastExpressionLL1 ::= $empty
      pushOnExpressionStack(getUnspecifiedReferenceOptimized());
}
protected void consumeInsideCastExpressionWithQualifiedGenerics() {
      // InsideCastExpressionWithQualifiedGenerics ::= $empty
}
protected void consumeInstanceOfExpression(int op) {
      // RelationalExpression ::= RelationalExpression 'instanceof' ReferenceType
      //optimize the push/pop

      //by construction, no base type may be used in getTypeReference
      Expression exp;
      this.expressionStack[this.expressionPtr] = exp =
            new InstanceOfExpression(
                  this.expressionStack[this.expressionPtr],
                  getTypeReference(this.intStack[this.intPtr--]),
                  op);
      if (exp.sourceEnd == 0) {
            //array on base type....
            exp.sourceEnd = this.scanner.startPosition - 1;
      }
      //the scanner is on the next token already....
}
/**
 * @param op
 */
protected void consumeInstanceOfExpressionWithName(int op) {
      // RelationalExpression_NotName ::= Name instanceof ReferenceType
      //optimize the push/pop

      //by construction, no base type may be used in getTypeReference
      TypeReference reference = getTypeReference(this.intStack[this.intPtr--]);
      pushOnExpressionStack(getUnspecifiedReferenceOptimized());
      Expression exp;
      this.expressionStack[this.expressionPtr] = exp =
            new InstanceOfExpression(
                  this.expressionStack[this.expressionPtr],
                  reference,
                  op);
      if (exp.sourceEnd == 0) {
            //array on base type....
            exp.sourceEnd = this.scanner.startPosition - 1;
      }
      //the scanner is on the next token already....
}
protected void consumeInterfaceDeclaration() {
      // see consumeClassDeclaration in case of changes: duplicated code
      // InterfaceDeclaration ::= InterfaceHeader InterfaceBody
      int length;
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            //there are length declarations
            //dispatch.....according to the type of the declarations
            dispatchDeclarationInto(length);
      }

      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
      
      // mark initializers with local type mark if needed
      markInitializersWithLocalType(typeDecl);

      //convert constructor that do not have the type's name into methods
      typeDecl.checkConstructors(this);
      
      //always add <clinit> (will be remove at code gen time if empty)
      if (this.scanner.containsAssertKeyword) {
            typeDecl.bits |= ASTNode.AddAssertionMASK;
      }
      typeDecl.addClinit();
      typeDecl.bodyEnd = this.endStatementPosition;
      if (length == 0 && !containsComment(typeDecl.bodyStart, typeDecl.bodyEnd)) {
            typeDecl.bits |= ASTNode.UndocumentedEmptyBlockMASK;
      }
      typeDecl.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition); 
}
protected void consumeInterfaceHeader() {
      // InterfaceHeader ::= InterfaceHeaderName InterfaceHeaderExtendsopt

      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];      
      if (this.currentToken == TokenNameLBRACE){ 
            typeDecl.bodyStart = this.scanner.currentPosition;
      }
      if (this.currentElement != null){
            this.restartRecovery = true; // used to avoid branching back into the regular automaton         
      }
      // flush the comments related to the interface header
      this.scanner.commentPtr = -1; 
}
protected void consumeInterfaceHeaderExtends() {
      // InterfaceHeaderExtends ::= 'extends' InterfaceTypeList
      int length = this.astLengthStack[this.astLengthPtr--];
      //super interfaces
      this.astPtr -= length;
      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
      System.arraycopy(
            this.astStack, 
            this.astPtr + 1, 
            typeDecl.superInterfaces = new TypeReference[length], 
            0, 
            length); 
      for (int i = 0, max = typeDecl.superInterfaces.length; i < max; i++) {
            typeDecl.superInterfaces[i].bits |= ASTNode.IsSuperType;
      }
      typeDecl.bodyStart = typeDecl.superInterfaces[length-1].sourceEnd + 1;        
      this.listLength = 0; // reset after having read super-interfaces        
      // recovery
      if (this.currentElement != null) { 
            this.lastCheckPoint = typeDecl.bodyStart;
      }
}
protected void consumeInterfaceHeaderName1() {
      // InterfaceHeaderName ::= Modifiersopt 'interface' 'Identifier'
      TypeDeclaration typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);

      if (this.nestedMethod[this.nestedType] == 0) {
            if (this.nestedType != 0) {
                  typeDecl.bits |= ASTNode.IsMemberTypeMASK;
            }
      } else {
            // Record that the block has a declaration for local types
            typeDecl.bits |= ASTNode.IsLocalTypeMASK;
            markEnclosingMemberWithLocalType();
            blockReal();
      }

      //highlight the name of the type
      long pos = this.identifierPositionStack[this.identifierPtr];
      typeDecl.sourceEnd = (int) pos;
      typeDecl.sourceStart = (int) (pos >>> 32);
      typeDecl.name = this.identifierStack[this.identifierPtr--];
      this.identifierLengthPtr--;

      //compute the declaration source too
      // 'class' and 'interface' push two int positions: the beginning of the class token and its end.
      // we want to keep the beginning position but get rid of the end position
      // it is only used for the ClassLiteralAccess positions.
      typeDecl.declarationSourceStart = this.intStack[this.intPtr--];
      this.intPtr--; // remove the end position of the class token
      typeDecl.modifiersSourceStart = this.intStack[this.intPtr--];
      typeDecl.modifiers = this.intStack[this.intPtr--] | AccInterface;
      if (typeDecl.modifiersSourceStart >= 0) {
            typeDecl.declarationSourceStart = typeDecl.modifiersSourceStart;
      }
      // consume annotations
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            System.arraycopy(
                  this.expressionStack, 
                  (this.expressionPtr -= length) + 1, 
                  typeDecl.annotations = new Annotation[length], 
                  0, 
                  length); 
      }
      typeDecl.bodyStart = typeDecl.sourceEnd + 1;
      pushOnAstStack(typeDecl);
      this.listLength = 0; // will be updated when reading super-interfaces
      // recovery
      if (this.currentElement != null){ // is recovering
            this.lastCheckPoint = typeDecl.bodyStart;
            this.currentElement = this.currentElement.add(typeDecl, 0);
            this.lastIgnoredToken = -1;         
      }
      // javadoc
      typeDecl.javadoc = this.javadoc;
      this.javadoc = null;
}
protected void consumeInterfaceMemberDeclarations() {
      // InterfaceMemberDeclarations ::= InterfaceMemberDeclarations InterfaceMemberDeclaration
      concatNodeLists();
}
protected void consumeInterfaceMemberDeclarationsopt() {
      // InterfaceMemberDeclarationsopt ::= NestedType InterfaceMemberDeclarations
      this.nestedType--;
}
protected void consumeInterfaceType() {
      // InterfaceType ::= ClassOrInterfaceType
      pushOnAstStack(getTypeReference(0));
      /* if incomplete type header, this.listLength counter will not have been reset,
            indicating that some interfaces are available on the stack */
      this.listLength++;      
}
protected void consumeInterfaceTypeList() {
      // InterfaceTypeList ::= InterfaceTypeList ',' InterfaceType
      optimizedConcatNodeLists();
}
protected void consumeInternalCompilationUnit() {
      // InternalCompilationUnit ::= PackageDeclaration
      // InternalCompilationUnit ::= PackageDeclaration ImportDeclarations ReduceImports
      // InternalCompilationUnit ::= ImportDeclarations ReduceImports
      if (this.compilationUnit.isPackageInfo()) {
            this.compilationUnit.types = new TypeDeclaration[1];
            // create a fake interface declaration
            TypeDeclaration declaration = new TypeDeclaration(compilationUnit.compilationResult);
            declaration.name = TypeConstants.PACKAGE_INFO_NAME;
            declaration.modifiers = AccDefault | AccInterface;
            this.compilationUnit.types[0] = declaration;
      }
}
protected void consumeInternalCompilationUnitWithTypes() {
      // InternalCompilationUnit ::= PackageDeclaration ImportDeclarations ReduceImports TypeDeclarations
      // InternalCompilationUnit ::= PackageDeclaration TypeDeclarations
      // InternalCompilationUnit ::= TypeDeclarations
      // InternalCompilationUnit ::= ImportDeclarations ReduceImports TypeDeclarations
      // consume type declarations
      int length;
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            if (this.compilationUnit.isPackageInfo()) {
                  this.compilationUnit.types = new TypeDeclaration[length + 1];
                  this.astPtr -= length;
                  System.arraycopy(this.astStack, this.astPtr + 1, this.compilationUnit.types, 1, length);
                  // create a fake interface declaration
                  TypeDeclaration declaration = new TypeDeclaration(compilationUnit.compilationResult);
                  declaration.name = TypeConstants.PACKAGE_INFO_NAME;
                  declaration.modifiers = AccDefault | AccInterface;
                  this.compilationUnit.types[0] = declaration;
            } else {
                  this.compilationUnit.types = new TypeDeclaration[length];
                  this.astPtr -= length;
                  System.arraycopy(this.astStack, this.astPtr + 1, this.compilationUnit.types, 0, length);
            }
      }
}
protected void consumeInvalidAnnotationTypeDeclaration() {
      // BlockStatement ::= AnnotationTypeDeclaration
      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
      problemReporter().illegalLocalTypeDeclaration(typeDecl);
      // remove the ast node created in interface header
      this.astPtr--;
      pushOnAstLengthStack(-1);
      concatNodeLists();
}
protected void consumeInvalidConstructorDeclaration() {
      // ConstructorDeclaration ::= ConstructorHeader ';'
      // now we know that the top of stack is a constructorDeclaration
      ConstructorDeclaration cd = (ConstructorDeclaration) this.astStack[this.astPtr];

      cd.bodyEnd = this.endPosition; // position just before the trailing semi-colon
      cd.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition); 
      // report the problem and continue the parsing - narrowing the problem onto the method
      
      cd.modifiers |= AccSemicolonBody; // remember semi-colon body
}
protected void consumeInvalidConstructorDeclaration(boolean hasBody) {
      // InvalidConstructorDeclaration ::= ConstructorHeader ConstructorBody ==> true
      // InvalidConstructorDeclaration ::= ConstructorHeader ';' ==> false

      /*
      this.astStack : modifiers arguments throws statements
      this.identifierStack : name
       ==>
      this.astStack : MethodDeclaration
      this.identifierStack :
      */
      if (hasBody) {
            // pop the position of the {  (body of the method) pushed in block decl
            this.intPtr--;
      }

      //statements
      if (hasBody) {
            this.realBlockPtr--;
      }

      int length;
      if (hasBody && ((length = this.astLengthStack[this.astLengthPtr--]) != 0)) {
            this.astPtr -= length;
      }
      ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) this.astStack[this.astPtr];
      constructorDeclaration.bodyEnd = this.endStatementPosition;
      constructorDeclaration.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
      if (!hasBody) {
            constructorDeclaration.modifiers |= AccSemicolonBody;
      }
}
protected void consumeInvalidInterfaceDeclaration() {
      // BlockStatement ::= InvalidInterfaceDeclaration
      //InterfaceDeclaration ::= Modifiersopt 'interface' 'Identifier' ExtendsInterfacesopt InterfaceHeader InterfaceBody
      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
      problemReporter().illegalLocalTypeDeclaration(typeDecl);
      // remove the ast node created in interface header
      this.astPtr--;
      pushOnAstLengthStack(-1);
      concatNodeLists();
}
protected void consumeInvalidEnumDeclaration() {
      // BlockStatement ::= EnumDeclaration
      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
      problemReporter().illegalLocalTypeDeclaration(typeDecl);
      // remove the ast node created in interface header
      this.astPtr--;
      pushOnAstLengthStack(-1);
      concatNodeLists();
}
protected void consumeInvalidMethodDeclaration() {
      // InterfaceMemberDeclaration ::= InvalidMethodDeclaration

      /*
      this.astStack : modifiers arguments throws statements
      this.identifierStack : type name
      this.intStack : dim dim dim
       ==>
      this.astStack : MethodDeclaration
      this.identifierStack :
      this.intStack : 
      */

      // pop the position of the {  (body of the method) pushed in block decl
      this.intPtr--;
      // retrieve end position of method declarator

      //statements
      this.realBlockPtr--;
      int length;
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            this.astPtr -= length;
      }

      //watch for } that could be given as a unicode ! ( u007D is '}' )
      MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];
      md.bodyEnd = this.endPosition;
      md.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);

      // report the problem and continue the parsing - narrowing the problem onto the method
      problemReporter().abstractMethodNeedingNoBody(md);
}
protected void consumeLeftParen() {
      // PushLPAREN ::= '('
      pushOnIntStack(this.lParenPos);
}
protected void consumeLocalVariableDeclaration() {
      // LocalVariableDeclaration ::= Modifiers Type VariableDeclarators ';'

      /*
      this.astStack : 
      this.expressionStack: Expression Expression ...... Expression
      this.identifierStack : type  identifier identifier ...... identifier
      this.intStack : typeDim      dim        dim               dim
       ==>
      this.astStack : FieldDeclaration FieldDeclaration ...... FieldDeclaration
      this.expressionStack :
      this.identifierStack : 
      this.intStack : 
        
      */
      int variableDeclaratorsCounter = this.astLengthStack[this.astLengthPtr];

      // update the this.astStack, this.astPtr and this.astLengthStack
      int startIndex = this.astPtr - this.variablesCounter[this.nestedType] + 1;
      System.arraycopy(
            this.astStack, 
            startIndex, 
            this.astStack, 
            startIndex - 1, 
            variableDeclaratorsCounter); 
      this.astPtr--; // remove the type reference
      this.astLengthStack[--this.astLengthPtr] = variableDeclaratorsCounter;
      this.variablesCounter[this.nestedType] = 0;
}
protected void consumeLocalVariableDeclarationStatement() {
      // LocalVariableDeclarationStatement ::= LocalVariableDeclaration ';'
      // see blockReal in case of change: duplicated code
      // increment the amount of declared variables for this block
      this.realBlockStack[this.realBlockPtr]++;
      
      // update source end to include the semi-colon
      int variableDeclaratorsCounter = this.astLengthStack[this.astLengthPtr];
      for (int i = variableDeclaratorsCounter - 1; i >= 0; i--) {
            LocalDeclaration localDeclaration = (LocalDeclaration) this.astStack[this.astPtr - i];
            localDeclaration.declarationSourceEnd = this.endStatementPosition; 
            localDeclaration.declarationEnd = this.endStatementPosition;      // semi-colon included
      }

}
protected void consumeMarkerAnnotation() {
      // MarkerAnnotation ::= '@' Name
      MarkerAnnotation markerAnnotation = null;
      TypeReference typeReference = this.getAnnotationType();
      markerAnnotation = new MarkerAnnotation(typeReference, this.intStack[this.intPtr--]);
      markerAnnotation.declarationSourceEnd = markerAnnotation.sourceEnd;
      pushOnExpressionStack(markerAnnotation);
      if(options.sourceLevel < ClassFileConstants.JDK1_5 &&
                  this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
            this.problemReporter().invalidUsageOfAnnotation(markerAnnotation);
      }
}
protected void consumeMemberValueArrayInitializer() {
      // MemberValueArrayInitializer ::= '{' MemberValues ',' '}'
      // MemberValueArrayInitializer ::= '{' MemberValues '}'
      arrayInitializer(this.expressionLengthStack[this.expressionLengthPtr--]);
}
protected void consumeMemberValueAsName() {
      pushOnExpressionStack(getUnspecifiedReferenceOptimized());  
}
protected void consumeMemberValuePair() {
      // MemberValuePair ::= SimpleName '=' MemberValue
      char[] simpleName = this.identifierStack[this.identifierPtr];
      long position = this.identifierPositionStack[this.identifierPtr--];
      this.identifierLengthPtr--;
      int end = (int) position;
      int start = (int) (position >>> 32);
      Expression value = this.expressionStack[this.expressionPtr--];
      this.expressionLengthPtr--;
      MemberValuePair memberValuePair = new MemberValuePair(simpleName, start, end, value);
      pushOnAstStack(memberValuePair);
}
protected void consumeMemberValuePairs() {
      // MemberValuePairs ::= MemberValuePairs ',' MemberValuePair
      concatNodeLists();
}
protected void consumeMemberValues() {
      // MemberValues ::= MemberValues ',' MemberValue
      concatExpressionLists();
}
protected void consumeMethodBody() {
      // MethodBody ::= NestedMethod '{' BlockStatementsopt '}' 
      this.nestedMethod[this.nestedType] --;
}
protected void consumeMethodDeclaration(boolean isNotAbstract) {
      // MethodDeclaration ::= MethodHeader MethodBody
      // AbstractMethodDeclaration ::= MethodHeader ';'

      /*
      this.astStack : modifiers arguments throws statements
      this.identifierStack : type name
      this.intStack : dim dim dim
       ==>
      this.astStack : MethodDeclaration
      this.identifierStack :
      this.intStack : 
      */

      int length;
      if (isNotAbstract) {
            // pop the position of the {  (body of the method) pushed in block decl
            this.intPtr--;
            this.intPtr--;
      }

      int explicitDeclarations = 0;
      Statement[] statements = null;
      if (isNotAbstract) {
            //statements
            explicitDeclarations = this.realBlockStack[this.realBlockPtr--];
            if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
                  System.arraycopy(
                        this.astStack, 
                        (this.astPtr -= length) + 1, 
                        statements = new Statement[length], 
                        0, 
                        length); 
            }
      }

      // now we know that we have a method declaration at the top of the ast stack
      MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];
      md.statements = statements;
      md.explicitDeclarations = explicitDeclarations;

      // cannot be done in consumeMethodHeader because we have no idea whether or not there
      // is a body when we reduce the method header
      if (!isNotAbstract) { //remember the fact that the method has a semicolon body
            md.modifiers |= AccSemicolonBody;
      } else {
            if (!this.diet && statements == null) {
                  if (!containsComment(md.bodyStart, this.endPosition)) {
                        md.bits |= ASTNode.UndocumentedEmptyBlockMASK;
                  }
            }
      }
      // store the this.endPosition (position just before the '}') in case there is
      // a trailing comment behind the end of the method
      md.bodyEnd = this.endPosition;
      md.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
}
protected void consumeMethodHeader() {
      // MethodHeader ::= MethodHeaderName MethodHeaderParameters MethodHeaderExtendedDims ThrowsClauseopt
      // AnnotationMethodHeader ::= AnnotationMethodHeaderName FormalParameterListopt MethodHeaderRightParen MethodHeaderExtendedDims AnnotationMethodHeaderDefaultValueopt
      // RecoveryMethodHeader ::= RecoveryMethodHeaderName FormalParameterListopt MethodHeaderRightParen MethodHeaderExtendedDims AnnotationMethodHeaderDefaultValueopt
      // RecoveryMethodHeader ::= RecoveryMethodHeaderName FormalParameterListopt MethodHeaderRightParen MethodHeaderExtendedDims MethodHeaderThrowsClause
      
      // retrieve end position of method declarator
      AbstractMethodDeclaration method = (AbstractMethodDeclaration)this.astStack[this.astPtr];

      if (this.currentToken == TokenNameLBRACE){ 
            method.bodyStart = this.scanner.currentPosition;
      }
      // recovery
      if (this.currentElement != null){
//          if(method.isAnnotationMethod()) {
//                method.modifiers |= AccSemicolonBody;
//                method.declarationSourceEnd = this.scanner.currentPosition-1;
//                method.bodyEnd = this.scanner.currentPosition-1;
//                this.currentElement = this.currentElement.parent;
//          } else 
            if (this.currentToken == TokenNameSEMICOLON /*&& !method.isAnnotationMethod()*/){
                  method.modifiers |= AccSemicolonBody;                 
                  method.declarationSourceEnd = this.scanner.currentPosition-1;
                  method.bodyEnd = this.scanner.currentPosition-1;
                  if (this.currentElement.parseTree() == method && this.currentElement.parent != null) {
                        this.currentElement = this.currentElement.parent;
                  }
            }           
            this.restartRecovery = true; // used to avoid branching back into the regular automaton
      }           
}
protected void consumeMethodHeaderDefaultValue() {
      // MethodHeaderDefaultValue ::= DefaultValue
      MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];

      
      int length = this.expressionLengthStack[this.expressionLengthPtr--];
      if (length == 1) {
            intPtr--; // we get rid of the position of the default keyword
            intPtr--; // we get rid of the position of the default keyword
            if(md.isAnnotationMethod()) {
                  ((AnnotationMethodDeclaration)md).defaultValue = this.expressionStack[this.expressionPtr];
                  md.modifiers |=  AccAnnotationDefault;
            }
            this.expressionPtr--;
      }

      if(this.currentElement != null) {
            if(md.isAnnotationMethod()) {
                  this.currentElement.updateSourceEndIfNecessary(((AnnotationMethodDeclaration)md).defaultValue.sourceEnd);
            }
      }
}
protected void consumeMethodHeaderExtendedDims() {
      // MethodHeaderExtendedDims ::= Dimsopt
      // now we update the returnType of the method
      MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];
      int extendedDims = this.intStack[this.intPtr--];
      if(md.isAnnotationMethod()) {
            ((AnnotationMethodDeclaration)md).extendedDimensions = extendedDims;
      }
      if (extendedDims != 0) {
            TypeReference returnType = md.returnType;
            md.sourceEnd = this.endPosition;
            int dims = returnType.dimensions() + extendedDims;
            md.returnType = this.copyDims(returnType, dims);
            if (this.currentToken == TokenNameLBRACE){ 
                  md.bodyStart = this.endPosition + 1;
            }
            // recovery
            if (this.currentElement != null){
                  this.lastCheckPoint = md.bodyStart;
            }           
      }
}
protected void consumeMethodHeaderName(boolean isAnnotationMethod) {
      // MethodHeaderName ::= Modifiersopt Type 'Identifier' '('
      // AnnotationMethodHeaderName ::= Modifiersopt Type 'Identifier' '('
      // RecoveryMethodHeaderName ::= Modifiersopt Type 'Identifier' '('
      MethodDeclaration md = null;
      if(isAnnotationMethod) {
            md = new AnnotationMethodDeclaration(this.compilationUnit.compilationResult);
      } else {
            md = new MethodDeclaration(this.compilationUnit.compilationResult);
      }

      //name
      md.selector = this.identifierStack[this.identifierPtr];
      long selectorSource = this.identifierPositionStack[this.identifierPtr--];
      this.identifierLengthPtr--;
      //type
      md.returnType = getTypeReference(this.intStack[this.intPtr--]);
      //modifiers
      md.declarationSourceStart = this.intStack[this.intPtr--];
      md.modifiers = this.intStack[this.intPtr--];
      // consume annotations
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            System.arraycopy(
                  this.expressionStack, 
                  (this.expressionPtr -= length) + 1, 
                  md.annotations = new Annotation[length], 
                  0, 
                  length); 
      }
      // javadoc
      md.javadoc = this.javadoc;
      this.javadoc = null;

      //highlight starts at selector start
      md.sourceStart = (int) (selectorSource >>> 32);
      pushOnAstStack(md);
      md.sourceEnd = this.lParenPos;
      md.bodyStart = this.lParenPos+1;
      this.listLength = 0; // initialize this.listLength before reading parameters/throws
      
      // recovery
      if (this.currentElement != null){
            if (this.currentElement instanceof RecoveredType 
                  //|| md.modifiers != 0
                  || (this.scanner.getLineNumber(md.returnType.sourceStart)
                              == this.scanner.getLineNumber(md.sourceStart))){
                  this.lastCheckPoint = md.bodyStart;
                  this.currentElement = this.currentElement.add(md, 0);
                  this.lastIgnoredToken = -1;
            } else {
                  this.lastCheckPoint = md.sourceStart;
                  this.restartRecovery = true;
            }
      }           
}
protected void consumeMethodHeaderNameWithTypeParameters(boolean isAnnotationMethod) {
      // MethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
      // AnnotationMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
      // RecoveryMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
      MethodDeclaration md = null;
      if(isAnnotationMethod) {
            md = new AnnotationMethodDeclaration(this.compilationUnit.compilationResult);
      } else {
            md = new MethodDeclaration(this.compilationUnit.compilationResult);
      }

      //name
      md.selector = this.identifierStack[this.identifierPtr];
      long selectorSource = this.identifierPositionStack[this.identifierPtr--];
      this.identifierLengthPtr--;
      //type
      md.returnType = getTypeReference(this.intStack[this.intPtr--]);
      
      // consume type parameters
      int length = this.genericsLengthStack[this.genericsLengthPtr--];
      this.genericsPtr -= length;
      System.arraycopy(this.genericsStack, this.genericsPtr + 1, md.typeParameters = new TypeParameter[length], 0, length);
      
      //modifiers
      md.declarationSourceStart = this.intStack[this.intPtr--];
      md.modifiers = this.intStack[this.intPtr--];
      // consume annotations
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            System.arraycopy(
                  this.expressionStack, 
                  (this.expressionPtr -= length) + 1, 
                  md.annotations = new Annotation[length], 
                  0, 
                  length); 
      }     
      // javadoc
      md.javadoc = this.javadoc;
      this.javadoc = null;

      //highlight starts at selector start
      md.sourceStart = (int) (selectorSource >>> 32);
      pushOnAstStack(md);
      md.sourceEnd = this.lParenPos;
      md.bodyStart = this.lParenPos+1;
      this.listLength = 0; // initialize this.listLength before reading parameters/throws
      
      // recovery
      if (this.currentElement != null){
            if (this.currentElement instanceof RecoveredType 
                  //|| md.modifiers != 0
                  || (this.scanner.getLineNumber(md.returnType.sourceStart)
                              == this.scanner.getLineNumber(md.sourceStart))){
                  this.lastCheckPoint = md.bodyStart;
                  this.currentElement = this.currentElement.add(md, 0);
                  this.lastIgnoredToken = -1;
            } else {
                  this.lastCheckPoint = md.sourceStart;
                  this.restartRecovery = true;
            }
      }           
}
protected void consumeMethodHeaderRightParen() {
      // MethodHeaderParameters ::= FormalParameterListopt ')'
      int length = this.astLengthStack[this.astLengthPtr--];
      this.astPtr -= length;
      AbstractMethodDeclaration md = (AbstractMethodDeclaration) this.astStack[this.astPtr];
      md.sourceEnd =    this.rParenPos;
      //arguments
      if (length != 0) {
            System.arraycopy(
                  this.astStack, 
                  this.astPtr + 1, 
                  md.arguments = new Argument[length], 
                  0, 
                  length); 
      }
      md.bodyStart = this.rParenPos+1;
      this.listLength = 0; // reset this.listLength after having read all parameters
      // recovery
      if (this.currentElement != null){
            this.lastCheckPoint = md.bodyStart;
            if (this.currentElement.parseTree() == md) return;

            // might not have been attached yet - in some constructor scenarii
            if (md.isConstructor()){
                  if ((length != 0)
                        || (this.currentToken == TokenNameLBRACE) 
                        || (this.currentToken == TokenNamethrows)){
                        this.currentElement = this.currentElement.add(md, 0);
                        this.lastIgnoredToken = -1;
                  }     
            }     
      }     
}
protected void consumeMethodHeaderThrowsClause() {
      // MethodHeaderThrowsClause ::= 'throws' ClassTypeList
      int length = this.astLengthStack[this.astLengthPtr--];
      this.astPtr -= length;
      AbstractMethodDeclaration md = (AbstractMethodDeclaration) this.astStack[this.astPtr];
      System.arraycopy(
            this.astStack, 
            this.astPtr + 1, 
            md.thrownExceptions = new TypeReference[length], 
            0, 
            length);
      md.sourceEnd = md.thrownExceptions[length-1].sourceEnd;
      md.bodyStart = md.thrownExceptions[length-1].sourceEnd + 1;
      this.listLength = 0; // reset this.listLength after having read all thrown exceptions     
      // recovery
      if (this.currentElement != null){
            this.lastCheckPoint = md.bodyStart;
      }
}
protected void consumeMethodInvocationName() {
      // MethodInvocation ::= Name '(' ArgumentListopt ')'

      // when the name is only an identifier...we have a message send to "this" (implicit)

      MessageSend m = newMessageSend();
      m.sourceEnd = this.rParenPos;
      m.sourceStart = 
            (int) ((m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr]) >>> 32); 
      m.selector = this.identifierStack[this.identifierPtr--];
      if (this.identifierLengthStack[this.identifierLengthPtr] == 1) {
            m.receiver = ThisReference.implicitThis();
            this.identifierLengthPtr--;
      } else {
            this.identifierLengthStack[this.identifierLengthPtr]--;
            m.receiver = getUnspecifiedReference();
            m.sourceStart = m.receiver.sourceStart;         
      }
      pushOnExpressionStack(m);
}
protected void consumeMethodInvocationNameWithTypeArguments() {
      // MethodInvocation ::= Name '.' TypeArguments 'Identifier' '(' ArgumentListopt ')'

      // when the name is only an identifier...we have a message send to "this" (implicit)

      MessageSend m = newMessageSendWithTypeArguments();
      m.sourceEnd = this.rParenPos;
      m.sourceStart = 
            (int) ((m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr]) >>> 32); 
      m.selector = this.identifierStack[this.identifierPtr--];
      this.identifierLengthPtr--;

      // handle type arguments
      int length = this.genericsLengthStack[this.genericsLengthPtr--];
      this.genericsPtr -= length;
      System.arraycopy(this.genericsStack, this.genericsPtr + 1, m.typeArguments = new TypeReference[length], 0, length);
      intPtr--;
      
      m.receiver = getUnspecifiedReference();
      m.sourceStart = m.receiver.sourceStart;         
      pushOnExpressionStack(m);
}
protected void consumeMethodInvocationPrimary() {
      //optimize the push/pop
      //MethodInvocation ::= Primary '.' 'Identifier' '(' ArgumentListopt ')'

      MessageSend m = newMessageSend();
      m.sourceStart = 
            (int) ((m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr]) >>> 32); 
      m.selector = this.identifierStack[this.identifierPtr--];
      this.identifierLengthPtr--;
      m.receiver = this.expressionStack[this.expressionPtr];
      m.sourceStart = m.receiver.sourceStart;
      m.sourceEnd = this.rParenPos;
      this.expressionStack[this.expressionPtr] = m;
}
protected void consumeMethodInvocationPrimaryWithTypeArguments() {
      //optimize the push/pop
      //MethodInvocation ::= Primary '.' TypeArguments 'Identifier' '(' ArgumentListopt ')'

      MessageSend m = newMessageSendWithTypeArguments();
      m.sourceStart = 
            (int) ((m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr]) >>> 32); 
      m.selector = this.identifierStack[this.identifierPtr--];
      this.identifierLengthPtr--;
      
      // handle type arguments
      int length = this.genericsLengthStack[this.genericsLengthPtr--];
      this.genericsPtr -= length;
      System.arraycopy(this.genericsStack, this.genericsPtr + 1, m.typeArguments = new TypeReference[length], 0, length);
      intPtr--;

      m.receiver = this.expressionStack[this.expressionPtr];
      m.sourceStart = m.receiver.sourceStart;
      m.sourceEnd = this.rParenPos;
      this.expressionStack[this.expressionPtr] = m;
}
protected void consumeMethodInvocationSuper() {
      // MethodInvocation ::= 'super' '.' 'Identifier' '(' ArgumentListopt ')'

      MessageSend m = newMessageSend();
      m.sourceStart = this.intStack[this.intPtr--];
      m.sourceEnd = this.rParenPos;
      m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr];
      m.selector = this.identifierStack[this.identifierPtr--];
      this.identifierLengthPtr--;
      m.receiver = new SuperReference(m.sourceStart, this.endPosition);
      pushOnExpressionStack(m);
}
protected void consumeMethodInvocationSuperWithTypeArguments() {
      // MethodInvocation ::= 'super' '.' TypeArguments 'Identifier' '(' ArgumentListopt ')'

      MessageSend m = newMessageSendWithTypeArguments();
      m.sourceStart = this.intStack[this.intPtr--];
      m.sourceEnd = this.rParenPos;
      m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr];
      m.selector = this.identifierStack[this.identifierPtr--];
      this.identifierLengthPtr--;
      
      // handle type arguments
      int length = this.genericsLengthStack[this.genericsLengthPtr--];
      this.genericsPtr -= length;
      System.arraycopy(this.genericsStack, this.genericsPtr + 1, m.typeArguments = new TypeReference[length], 0, length);
      intPtr--;

      m.receiver = new SuperReference(m.sourceStart, this.endPosition);
      pushOnExpressionStack(m);
}
protected void consumeModifiers() {
      int savedModifiersSourceStart = this.modifiersSourceStart;  
      checkComment(); // might update modifiers with AccDeprecated
      pushOnIntStack(this.modifiers); // modifiers
      if (this.modifiersSourceStart >= savedModifiersSourceStart) {
            this.modifiersSourceStart = savedModifiersSourceStart;
      }
      pushOnIntStack(this.modifiersSourceStart);
      resetModifiers();
}
protected void consumeModifiers2() {
      this.expressionLengthStack[this.expressionLengthPtr - 1] += this.expressionLengthStack[this.expressionLengthPtr--];
}
protected void consumeNameArrayType() {
      pushOnGenericsLengthStack(0); // handle type arguments
      pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
}
protected void consumeNestedMethod() {
      // NestedMethod ::= $empty
      jumpOverMethodBody();
      this.nestedMethod[this.nestedType] ++;
      pushOnIntStack(this.scanner.currentPosition);
      consumeOpenBlock();
}
protected void consumeNestedType() {
      // NestedType ::= $empty
      int length = this.nestedMethod.length;
      if (++this.nestedType >= length) {
            System.arraycopy(
                  this.nestedMethod, 0,
                  this.nestedMethod = new int[length + 30], 0,
                  length);
            // increase the size of the variablesCounter as well. It has to be consistent with the size of the nestedMethod collection
            System.arraycopy(
                  this.variablesCounter, 0,
                  this.variablesCounter = new int[length + 30], 0,
                  length);
      }
      this.nestedMethod[this.nestedType] = 0;
      this.variablesCounter[this.nestedType] = 0;
}
protected void consumeNormalAnnotation() {
      // NormalAnnotation ::= '@' Name '(' MemberValuePairsopt ')'
      NormalAnnotation normalAnnotation = null;
      TypeReference typeReference = this.getAnnotationType();
      normalAnnotation = new NormalAnnotation(typeReference, this.intStack[this.intPtr--]);
      int length;
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            System.arraycopy(
                  this.astStack, 
                  (this.astPtr -= length) + 1, 
                  normalAnnotation.memberValuePairs = new MemberValuePair[length], 
                  0, 
                  length); 
      }
      normalAnnotation.declarationSourceEnd = this.rParenPos;
      pushOnExpressionStack(normalAnnotation);
      
      if(this.currentElement != null) {
            annotationRecoveryCheckPoint(normalAnnotation.sourceStart, normalAnnotation.declarationSourceEnd);
      }
      
      if(options.sourceLevel < ClassFileConstants.JDK1_5 &&
                  this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
            this.problemReporter().invalidUsageOfAnnotation(normalAnnotation);
      }
}
protected void consumeOneDimLoop() {
      // OneDimLoop ::= '[' ']'
      this.dimensions++;
}
protected void consumeOnlySynchronized() {
      // OnlySynchronized ::= 'synchronized'
      pushOnIntStack(this.synchronizedBlockSourceStart);
      resetModifiers();
      this.expressionLengthPtr--;
}
protected void consumeOnlyTypeArguments() {
      if(options.sourceLevel < ClassFileConstants.JDK1_5 &&
                  this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
            int length = this.genericsLengthStack[this.genericsLengthPtr];
            this.problemReporter().invalidUsageOfTypeArguments(
                  (TypeReference)this.genericsStack[this.genericsPtr - length + 1],
                  (TypeReference)this.genericsStack[this.genericsPtr]);
      }
}
protected void consumeOnlyTypeArgumentsForCastExpression() {
      // OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments
}
protected void consumeOpenBlock() {
      // OpenBlock ::= $empty

      pushOnIntStack(this.scanner.startPosition);
      int stackLength = this.realBlockStack.length;
      if (++this.realBlockPtr >= stackLength) {
            System.arraycopy(
                  this.realBlockStack, 0,
                  this.realBlockStack = new int[stackLength + StackIncrement], 0,
                  stackLength);
      }
      this.realBlockStack[this.realBlockPtr] = 0;
}
protected void consumePackageComment() {
      // get possible comment for syntax since 1.5
      if(options.sourceLevel >= ClassFileConstants.JDK1_5) {
            checkComment();
            resetModifiers();
      }
}
protected void consumePackageDeclaration() {
      // PackageDeclaration ::= 'package' Name ';'
      /* build an ImportRef build from the last name 
      stored in the identifier stack. */

      ImportReference impt = this.compilationUnit.currentPackage;
      this.compilationUnit.javadoc = this.javadoc;
      this.javadoc = null;
      // flush comments defined prior to import statements
      impt.declarationEnd = this.endStatementPosition;
      impt.declarationSourceEnd = this.flushCommentsDefinedPriorTo(impt.declarationSourceEnd);
}
protected void consumePackageDeclarationName() {
      // PackageDeclarationName ::= 'package' Name
      /* build an ImportRef build from the last name 
      stored in the identifier stack. */

      ImportReference impt;
      int length;
      char[][] tokens = 
            new char[length = this.identifierLengthStack[this.identifierLengthPtr--]][]; 
      this.identifierPtr -= length;
      long[] positions = new long[length];
      System.arraycopy(this.identifierStack, ++this.identifierPtr, tokens, 0, length);
      System.arraycopy(
            this.identifierPositionStack, 
            this.identifierPtr--, 
            positions, 
            0, 
            length);
      
      impt = new ImportReference(tokens, positions, true, AccDefault);
      this.compilationUnit.currentPackage = impt; 

      if (this.currentToken == TokenNameSEMICOLON){
            impt.declarationSourceEnd = this.scanner.currentPosition - 1;
      } else {
            impt.declarationSourceEnd = impt.sourceEnd;
      }
      impt.declarationEnd = impt.declarationSourceEnd;
      //this.endPosition is just before the ;
      impt.declarationSourceStart = this.intStack[this.intPtr--];

      // get possible comment source start
      if(this.javadoc != null) {
            impt.declarationSourceStart = this.javadoc.sourceStart;
      }

      // recovery
      if (this.currentElement != null){
            this.lastCheckPoint = impt.declarationSourceEnd+1;
            this.restartRecovery = true; // used to avoid branching back into the regular automaton         
      }     
}
protected void consumePackageDeclarationNameWithModifiers() {
      // PackageDeclarationName ::= Modifiers 'package' Name
      /* build an ImportRef build from the last name 
      stored in the identifier stack. */

      ImportReference impt;
      int length;
      char[][] tokens = 
            new char[length = this.identifierLengthStack[this.identifierLengthPtr--]][]; 
      this.identifierPtr -= length;
      long[] positions = new long[length];
      System.arraycopy(this.identifierStack, ++this.identifierPtr, tokens, 0, length);
      System.arraycopy(
            this.identifierPositionStack, 
            this.identifierPtr--, 
            positions, 
            0, 
            length);
      
      int packageModifiersSourceStart = this.intStack[this.intPtr--]; // we don't need the modifiers start
      int packageModifiers = this.intStack[this.intPtr--];

      impt = new ImportReference(tokens, positions, true, packageModifiers);
      this.compilationUnit.currentPackage = impt; 
      // consume annotations
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            System.arraycopy(
                  this.expressionStack, 
                  (this.expressionPtr -= length) + 1, 
                  impt.annotations = new Annotation[length], 
                  0, 
                  length);
            impt.declarationSourceStart = packageModifiersSourceStart;
            intPtr--; // we don't need the position of the 'package keyword
      } else {
            impt.declarationSourceStart = this.intStack[this.intPtr--];
            // get possible comment source start
            if (this.javadoc != null) {
                  impt.declarationSourceStart = this.javadoc.sourceStart;
            }
      }
            
      if (this.currentToken == TokenNameSEMICOLON){
            impt.declarationSourceEnd = this.scanner.currentPosition - 1;
      } else {
            impt.declarationSourceEnd = impt.sourceEnd;
      }
      impt.declarationEnd = impt.declarationSourceEnd;

      // recovery
      if (this.currentElement != null){
            this.lastCheckPoint = impt.declarationSourceEnd+1;
            this.restartRecovery = true; // used to avoid branching back into the regular automaton         
      }     
}
protected void consumePostfixExpression() {
      // PostfixExpression ::= Name
      pushOnExpressionStack(getUnspecifiedReferenceOptimized());
}
protected void consumePrimaryNoNewArray() {
      // PrimaryNoNewArray ::=  PushLPAREN Expression PushRPAREN 
      final Expression parenthesizedExpression = this.expressionStack[this.expressionPtr];
      updateSourcePosition(parenthesizedExpression);
      int numberOfParenthesis = (parenthesizedExpression.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT;
      parenthesizedExpression.bits &= ~ASTNode.ParenthesizedMASK;
      parenthesizedExpression.bits |= (numberOfParenthesis + 1) << ASTNode.ParenthesizedSHIFT;
}
protected void consumePrimaryNoNewArrayArrayType() {
      // PrimaryNoNewArray ::= Name Dims '.' 'class'
      this.intPtr--; // remove the class start position

      pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
      pushOnGenericsLengthStack(0);

      pushOnExpressionStack(
            new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(this.intStack[this.intPtr--])));
}
protected void consumePrimaryNoNewArrayName() {
      // PrimaryNoNewArray ::= Name '.' 'class'
      this.intPtr--; // remove the class start position

      // handle type arguments
      pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
      pushOnGenericsLengthStack(0);
      TypeReference typeReference = getTypeReference(0);
      
      pushOnExpressionStack(
            new ClassLiteralAccess(this.intStack[this.intPtr--], typeReference));
}
protected void consumePrimaryNoNewArrayNameSuper() {
      // PrimaryNoNewArray ::= Name '.' 'super'
      // handle type arguments
      pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
      pushOnGenericsLengthStack(0);
      TypeReference typeReference = getTypeReference(0);

      pushOnExpressionStack(
            new QualifiedSuperReference(
                  typeReference,
                  this.intStack[this.intPtr--],
                  this.endPosition));
}
protected void consumePrimaryNoNewArrayNameThis() {
      // PrimaryNoNewArray ::= Name '.' 'this'
      // handle type arguments
      pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
      pushOnGenericsLengthStack(0); // handle type arguments

      TypeReference typeReference = getTypeReference(0);
      
      pushOnExpressionStack(
            new QualifiedThisReference(
                  typeReference,
                  this.intStack[this.intPtr--],
                  this.endPosition));
}
protected void consumePrimaryNoNewArrayPrimitiveArrayType() {
      // PrimaryNoNewArray ::= PrimitiveType Dims '.' 'class'
      this.intPtr--; // remove the class start position
      pushOnExpressionStack(
            new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(this.intStack[this.intPtr--])));
}
protected void consumePrimaryNoNewArrayPrimitiveType() {
      // PrimaryNoNewArray ::= PrimitiveType '.' 'class'
      this.intPtr--; // remove the class start position
      pushOnExpressionStack(
            new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(0)));
}
protected void consumePrimaryNoNewArrayThis() {
      // PrimaryNoNewArray ::= 'this'
      pushOnExpressionStack(new ThisReference(this.intStack[this.intPtr--], this.endPosition));
}
protected void consumePrimaryNoNewArrayWithName() {
      // PrimaryNoNewArray ::=  PushLPAREN Expression PushRPAREN 
      pushOnExpressionStack(getUnspecifiedReferenceOptimized());
      final Expression parenthesizedExpression = this.expressionStack[this.expressionPtr];
      updateSourcePosition(parenthesizedExpression);
      int numberOfParenthesis = (parenthesizedExpression.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT;
      parenthesizedExpression.bits &= ~ASTNode.ParenthesizedMASK;
      parenthesizedExpression.bits |= (numberOfParenthesis + 1) << ASTNode.ParenthesizedSHIFT;
}
protected void consumePrimitiveArrayType() {
      // nothing to do
      // Will be consume by a getTypeRefence call
}
protected void consumePrimitiveType() {
      // Type ::= PrimitiveType
      pushOnIntStack(0);
}
protected void consumePushLeftBrace() {
      pushOnIntStack(this.endPosition); // modifiers
}
protected void consumePushRealModifiers() {
      checkComment(); // might update modifiers with AccDeprecated
      pushOnIntStack(this.modifiers); // modifiers
      pushOnIntStack(this.modifiersSourceStart);
      resetModifiers();
}
protected void consumePushModifiers() {
      pushOnIntStack(this.modifiers); // modifiers
      pushOnIntStack(this.modifiersSourceStart);
      resetModifiers();
      pushOnExpressionStackLengthStack(0);
}
protected void consumePushModifiersForHeader() {
      checkComment(); // might update modifiers with AccDeprecated
      pushOnIntStack(this.modifiers); // modifiers
      pushOnIntStack(this.modifiersSourceStart);
      resetModifiers();
      pushOnExpressionStackLengthStack(0);
}
protected void consumePushPosition() {
      // for source managment purpose
      // PushPosition ::= $empty
      pushOnIntStack(this.endPosition);
}
protected void consumeQualifiedName() {
      // QualifiedName ::= Name '.' SimpleName 
      /*back from the recursive loop of QualifiedName.
      Updates identifier length into the length stack*/

      this.identifierLengthStack[--this.identifierLengthPtr]++;
}
protected void consumeRecoveryMethodHeaderName() {
      // this method is call only inside recovery
      boolean isAnnotationMethod = false;
      if(this.currentElement instanceof RecoveredType) {
            isAnnotationMethod = (((RecoveredType)this.currentElement).typeDeclaration.modifiers & AccAnnotation) != 0;
      } else {
            RecoveredType recoveredType = this.currentElement.enclosingType();
            if(recoveredType != null) {
                  isAnnotationMethod = (recoveredType.typeDeclaration.modifiers & AccAnnotation) != 0;
            }
      }
      this.consumeMethodHeaderName(isAnnotationMethod);
}
protected void consumeRecoveryMethodHeaderNameWithTypeParameters() {
      // this method is call only inside recovery
      boolean isAnnotationMethod = false;
      if(this.currentElement instanceof RecoveredType) {
            isAnnotationMethod = (((RecoveredType)this.currentElement).typeDeclaration.modifiers & AccAnnotation) != 0;
      } else {
            RecoveredType recoveredType = this.currentElement.enclosingType();
            if(recoveredType != null) {
                  isAnnotationMethod = (recoveredType.typeDeclaration.modifiers & AccAnnotation) != 0;
            }
      }
      this.consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod);
}
protected void consumeReduceImports() {
      // Consume imports
      int length;
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            this.astPtr -= length;
            System.arraycopy(
                  this.astStack,
                  this.astPtr + 1,
                  this.compilationUnit.imports = new ImportReference[length],
                  0,
                  length);
      }
}
protected void consumeReferenceType() {
      pushOnIntStack(0); // handle array type
}
protected void consumeReferenceType1() {
      pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));    
}
protected void consumeReferenceType2() {
      pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));    
}
protected void consumeReferenceType3() {
      pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));    
}
protected void consumeRestoreDiet() {
      // RestoreDiet ::= $empty
      this.dietInt--;
}
protected void consumeRightParen() {
      // PushRPAREN ::= ')'
      pushOnIntStack(this.rParenPos);
}
// This method is part of an automatic generation : do NOT edit-modify  
protected void consumeRule(int act) {
  switch ( act ) {
    case 29 : if (DEBUG) { System.out.println("Type ::= PrimitiveType"); }  //$NON-NLS-1$
                consumePrimitiveType();  
                  break;
 
    case 43 : if (DEBUG) { System.out.println("ReferenceType ::= ClassOrInterfaceType"); }  //$NON-NLS-1$
                consumeReferenceType();   
                  break;
 
    case 47 : if (DEBUG) { System.out.println("ClassOrInterface ::= Name"); }  //$NON-NLS-1$
                consumeClassOrInterfaceName();   
                  break;
 
    case 48 : if (DEBUG) { System.out.println("ClassOrInterface ::= GenericType DOT Name"); }  //$NON-NLS-1$
                consumeClassOrInterface();   
                  break;
 
    case 49 : if (DEBUG) { System.out.println("GenericType ::= ClassOrInterface TypeArguments"); }  //$NON-NLS-1$
                consumeGenericType();   
                  break;
 
    case 50 : if (DEBUG) { System.out.println("ArrayTypeWithTypeArgumentsName ::= GenericType DOT Name"); }  //$NON-NLS-1$
                consumeArrayTypeWithTypeArgumentsName();   
                  break;
 
    case 51 : if (DEBUG) { System.out.println("ArrayType ::= PrimitiveType Dims"); }  //$NON-NLS-1$
                consumePrimitiveArrayType();   
                  break;
 
    case 52 : if (DEBUG) { System.out.println("ArrayType ::= Name Dims"); }  //$NON-NLS-1$
                consumeNameArrayType();   
                  break;
 
    case 53 : if (DEBUG) { System.out.println("ArrayType ::= ArrayTypeWithTypeArgumentsName Dims"); }  //$NON-NLS-1$
                consumeGenericTypeNameArrayType();   
                  break;
 
    case 54 : if (DEBUG) { System.out.println("ArrayType ::= GenericType Dims"); }  //$NON-NLS-1$
                consumeGenericTypeArrayType();   
                  break;
 
    case 59 : if (DEBUG) { System.out.println("QualifiedName ::= Name DOT SimpleName"); }  //$NON-NLS-1$
                consumeQualifiedName();  
                  break;
 
    case 60 : if (DEBUG) { System.out.println("CompilationUnit ::= EnterCompilationUnit..."); }  //$NON-NLS-1$
                consumeCompilationUnit();  
                  break;
 
    case 61 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration"); }  //$NON-NLS-1$
                consumeInternalCompilationUnit();  
                  break;
 
    case 62 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); }  //$NON-NLS-1$
                consumeInternalCompilationUnit();  
                  break;
 
    case 63 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); }  //$NON-NLS-1$
                consumeInternalCompilationUnitWithTypes();  
                  break;
 
    case 64 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); }  //$NON-NLS-1$
                consumeInternalCompilationUnitWithTypes();  
                  break;
 
    case 65 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); }  //$NON-NLS-1$
                consumeInternalCompilationUnit();  
                  break;
 
    case 66 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= TypeDeclarations"); }  //$NON-NLS-1$
                consumeInternalCompilationUnitWithTypes();  
                  break;
 
    case 67 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); }  //$NON-NLS-1$
                consumeInternalCompilationUnitWithTypes();  
                  break;
 
    case 68 : if (DEBUG) { System.out.println("InternalCompilationUnit ::="); }  //$NON-NLS-1$
                consumeEmptyInternalCompilationUnit();  
                  break;
 
    case 69 : if (DEBUG) { System.out.println("ReduceImports ::="); }  //$NON-NLS-1$
                consumeReduceImports();  
                  break;
 
    case 70 : if (DEBUG) { System.out.println("EnterCompilationUnit ::="); }  //$NON-NLS-1$
                consumeEnterCompilationUnit();  
                  break;
 
    case 86 : if (DEBUG) { System.out.println("CatchHeader ::= catch LPAREN FormalParameter RPAREN..."); }  //$NON-NLS-1$
                consumeCatchHeader();  
                  break;
 
    case 88 : if (DEBUG) { System.out.println("ImportDeclarations ::= ImportDeclarations..."); }  //$NON-NLS-1$
                consumeImportDeclarations();  
                  break;
 
    case 90 : if (DEBUG) { System.out.println("TypeDeclarations ::= TypeDeclarations TypeDeclaration"); }  //$NON-NLS-1$
                consumeTypeDeclarations();  
                  break;
 
    case 91 : if (DEBUG) { System.out.println("PackageDeclaration ::= PackageDeclarationName SEMICOLON"); }  //$NON-NLS-1$
                 consumePackageDeclaration();  
                  break;
 
    case 92 : if (DEBUG) { System.out.println("PackageDeclarationName ::= Modifiers package..."); }  //$NON-NLS-1$
                 consumePackageDeclarationNameWithModifiers();  
                  break;
 
    case 93 : if (DEBUG) { System.out.println("PackageDeclarationName ::= PackageComment package Name"); }  //$NON-NLS-1$
                 consumePackageDeclarationName();  
                  break;
 
    case 94 : if (DEBUG) { System.out.println("PackageComment ::="); }  //$NON-NLS-1$
                 consumePackageComment();  
                  break;
 
    case 99 : if (DEBUG) { System.out.println("SingleTypeImportDeclaration ::=..."); }  //$NON-NLS-1$
                consumeImportDeclaration();  
                  break;
 
    case 100 : if (DEBUG) { System.out.println("SingleTypeImportDeclarationName ::= import Name"); }  //$NON-NLS-1$
                consumeSingleTypeImportDeclarationName();  
                  break;
 
    case 101 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclaration ::=..."); }  //$NON-NLS-1$
                consumeImportDeclaration();  
                  break;
 
    case 102 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclarationName ::= import Name DOT..."); }  //$NON-NLS-1$
                consumeTypeImportOnDemandDeclarationName();  
                  break;
 
     case 105 : if (DEBUG) { System.out.println("TypeDeclaration ::= SEMICOLON"); }  //$NON-NLS-1$
                consumeEmptyTypeDeclaration();  
                  break;
 
    case 109 : if (DEBUG) { System.out.println("Modifiers ::= Modifiers Modifier"); }  //$NON-NLS-1$
                consumeModifiers2();  
                  break;
 
    case 121 : if (DEBUG) { System.out.println("Modifier ::= Annotation"); }  //$NON-NLS-1$
                consumeAnnotationAsModifier();  
                  break;
 
    case 122 : if (DEBUG) { System.out.println("ClassDeclaration ::= ClassHeader ClassBody"); }  //$NON-NLS-1$
                consumeClassDeclaration();  
                  break;
 
    case 123 : if (DEBUG) { System.out.println("ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt..."); }  //$NON-NLS-1$
                consumeClassHeader();  
                  break;
 
    case 124 : if (DEBUG) { System.out.println("ClassHeaderName ::= ClassHeaderName1 TypeParameters"); }  //$NON-NLS-1$
                consumeTypeHeaderNameWithTypeParameters();  
                  break;
 
    case 126 : if (DEBUG) { System.out.println("ClassHeaderName1 ::= Modifiersopt class Identifier"); }  //$NON-NLS-1$
                consumeClassHeaderName1();  
                  break;
 
    case 127 : if (DEBUG) { System.out.println("ClassHeaderExtends ::= extends ClassType"); }  //$NON-NLS-1$
                consumeClassHeaderExtends();  
                  break;
 
    case 128 : if (DEBUG) { System.out.println("ClassHeaderImplements ::= implements InterfaceTypeList"); }  //$NON-NLS-1$
                consumeClassHeaderImplements();  
                  break;
 
    case 130 : if (DEBUG) { System.out.println("InterfaceTypeList ::= InterfaceTypeList COMMA..."); }  //$NON-NLS-1$
                consumeInterfaceTypeList();  
                  break;
 
    case 131 : if (DEBUG) { System.out.println("InterfaceType ::= ClassOrInterfaceType"); }  //$NON-NLS-1$
                consumeInterfaceType();  
                  break;
 
    case 134 : if (DEBUG) { System.out.println("ClassBodyDeclarations ::= ClassBodyDeclarations..."); }  //$NON-NLS-1$
                consumeClassBodyDeclarations();  
                  break;
 
    case 138 : if (DEBUG) { System.out.println("ClassBodyDeclaration ::= Diet NestedMethod Block"); }  //$NON-NLS-1$
                consumeClassBodyDeclaration();  
                  break;
 
    case 139 : if (DEBUG) { System.out.println("Diet ::="); }  //$NON-NLS-1$
                consumeDiet();  
                  break;

    case 140 : if (DEBUG) { System.out.println("Initializer ::= Diet NestedMethod Block"); }  //$NON-NLS-1$
                consumeClassBodyDeclaration();  
                  break;
 
    case 147 : if (DEBUG) { System.out.println("ClassMemberDeclaration ::= SEMICOLON"); }  //$NON-NLS-1$
                consumeEmptyClassMemberDeclaration();  
                  break;

    case 150 : if (DEBUG) { System.out.println("FieldDeclaration ::= Modifiersopt Type..."); }  //$NON-NLS-1$
                consumeFieldDeclaration();  
                  break;
 
    case 152 : if (DEBUG) { System.out.println("VariableDeclarators ::= VariableDeclarators COMMA..."); }  //$NON-NLS-1$
                consumeVariableDeclarators();  
                  break;
 
    case 155 : if (DEBUG) { System.out.println("EnterVariable ::="); }  //$NON-NLS-1$
                consumeEnterVariable();  
                  break;
 
    case 156 : if (DEBUG) { System.out.println("ExitVariableWithInitialization ::="); }  //$NON-NLS-1$
                consumeExitVariableWithInitialization();  
                  break;
 
    case 157 : if (DEBUG) { System.out.println("ExitVariableWithoutInitialization ::="); }  //$NON-NLS-1$
                consumeExitVariableWithoutInitialization();  
                  break;
 
    case 158 : if (DEBUG) { System.out.println("ForceNoDiet ::="); }  //$NON-NLS-1$
                consumeForceNoDiet();  
                  break;
 
    case 159 : if (DEBUG) { System.out.println("RestoreDiet ::="); }  //$NON-NLS-1$
                consumeRestoreDiet();  
                  break;
 
    case 164 : if (DEBUG) { System.out.println("MethodDeclaration ::= MethodHeader MethodBody"); }  //$NON-NLS-1$
                // set to true to consume a method with a body
  consumeMethodDeclaration(true);   
                  break;
 
    case 165 : if (DEBUG) { System.out.println("AbstractMethodDeclaration ::= MethodHeader SEMICOLON"); }  //$NON-NLS-1$
                // set to false to consume a method without body
  consumeMethodDeclaration(false);  
                  break;
 
    case 166 : if (DEBUG) { System.out.println("MethodHeader ::= MethodHeaderName FormalParameterListopt"); }  //$NON-NLS-1$
                consumeMethodHeader();  
                  break;
 
    case 167 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt TypeParameters Type..."); }  //$NON-NLS-1$
                consumeMethodHeaderNameWithTypeParameters(false);  
                  break;
 
    case 168 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt Type Identifier LPAREN"); }  //$NON-NLS-1$
                consumeMethodHeaderName(false);  
                  break;
 
    case 169 : if (DEBUG) { System.out.println("MethodHeaderRightParen ::= RPAREN"); }  //$NON-NLS-1$
                consumeMethodHeaderRightParen();  
                  break;
 
    case 170 : if (DEBUG) { System.out.println("MethodHeaderExtendedDims ::= Dimsopt"); }  //$NON-NLS-1$
                consumeMethodHeaderExtendedDims();  
                  break;
 
    case 171 : if (DEBUG) { System.out.println("MethodHeaderThrowsClause ::= throws ClassTypeList"); }  //$NON-NLS-1$
                consumeMethodHeaderThrowsClause();  
                  break;
 
    case 172 : if (DEBUG) { System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); }  //$NON-NLS-1$
                consumeConstructorHeader();  
                  break;
 
    case 173 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt TypeParameters..."); }  //$NON-NLS-1$
                consumeConstructorHeaderNameWithTypeParameters();  
                  break;
 
    case 174 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt Identifier LPAREN"); }  //$NON-NLS-1$
                consumeConstructorHeaderName();  
                  break;
 
    case 176 : if (DEBUG) { System.out.println("FormalParameterList ::= FormalParameterList COMMA..."); }  //$NON-NLS-1$
                consumeFormalParameterList();  
                  break;
 
    case 177 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Type..."); }  //$NON-NLS-1$
                consumeFormalParameter(false);  
                  break;
 
    case 178 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Type ELLIPSIS..."); }  //$NON-NLS-1$
                consumeFormalParameter(true);  
                  break;
 
    case 180 : if (DEBUG) { System.out.println("ClassTypeList ::= ClassTypeList COMMA ClassTypeElt"); }  //$NON-NLS-1$
                consumeClassTypeList();  
                  break;
 
    case 181 : if (DEBUG) { System.out.println("ClassTypeElt ::= ClassType"); }  //$NON-NLS-1$
                consumeClassTypeElt();  
                  break;
 
    case 182 : if (DEBUG) { System.out.println("MethodBody ::= NestedMethod LBRACE BlockStatementsopt..."); }  //$NON-NLS-1$
                consumeMethodBody();  
                  break;
 
    case 183 : if (DEBUG) { System.out.println("NestedMethod ::="); }  //$NON-NLS-1$
                consumeNestedMethod();  
                  break;
 
    case 184 : if (DEBUG) { System.out.println("StaticInitializer ::= StaticOnly Block"); }  //$NON-NLS-1$
                consumeStaticInitializer();  
                  break;

    case 185 : if (DEBUG) { System.out.println("StaticOnly ::= static"); }  //$NON-NLS-1$
                consumeStaticOnly();  
                  break;
 
    case 186 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader MethodBody"); }  //$NON-NLS-1$
                consumeConstructorDeclaration() ;  
                  break;
 
    case 187 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader SEMICOLON"); }  //$NON-NLS-1$
                consumeInvalidConstructorDeclaration() ;  
                  break;
 
    case 188 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= this LPAREN..."); }  //$NON-NLS-1$
                consumeExplicitConstructorInvocation(0, THIS_CALL);  
                  break;
 
    case 189 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments this"); }  //$NON-NLS-1$
                consumeExplicitConstructorInvocationWithTypeArguments(0,THIS_CALL);  
                  break;
 
    case 190 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= super LPAREN..."); }  //$NON-NLS-1$
                consumeExplicitConstructorInvocation(0,SUPER_CALL);  
                  break;
 
    case 191 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments..."); }  //$NON-NLS-1$
                consumeExplicitConstructorInvocationWithTypeArguments(0,SUPER_CALL);  
                  break;
 
    case 192 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT super..."); }  //$NON-NLS-1$
                consumeExplicitConstructorInvocation(1, SUPER_CALL);  
                  break;
 
    case 193 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); }  //$NON-NLS-1$
                consumeExplicitConstructorInvocationWithTypeArguments(1, SUPER_CALL);  
                  break;
 
    case 194 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT super LPAREN"); }  //$NON-NLS-1$
                consumeExplicitConstructorInvocation(2, SUPER_CALL);  
                  break;
 
    case 195 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); }  //$NON-NLS-1$
                consumeExplicitConstructorInvocationWithTypeArguments(2, SUPER_CALL);  
                  break;
 
    case 196 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT this..."); }  //$NON-NLS-1$
                consumeExplicitConstructorInvocation(1, THIS_CALL);  
                  break;
 
    case 197 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); }  //$NON-NLS-1$
                consumeExplicitConstructorInvocationWithTypeArguments(1, THIS_CALL);  
                  break;
 
    case 198 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT this LPAREN"); }  //$NON-NLS-1$
                consumeExplicitConstructorInvocation(2, THIS_CALL);  
                  break;
 
    case 199 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); }  //$NON-NLS-1$
                consumeExplicitConstructorInvocationWithTypeArguments(2, THIS_CALL);  
                  break;
 
    case 200 : if (DEBUG) { System.out.println("InterfaceDeclaration ::= InterfaceHeader InterfaceBody"); }  //$NON-NLS-1$
                consumeInterfaceDeclaration();  
                  break;
 
    case 201 : if (DEBUG) { System.out.println("InterfaceHeader ::= InterfaceHeaderName..."); }  //$NON-NLS-1$
                consumeInterfaceHeader();  
                  break;
 
    case 202 : if (DEBUG) { System.out.println("InterfaceHeaderName ::= InterfaceHeaderName1..."); }  //$NON-NLS-1$
                consumeTypeHeaderNameWithTypeParameters();  
                  break;
 
    case 204 : if (DEBUG) { System.out.println("InterfaceHeaderName1 ::= Modifiersopt interface..."); }  //$NON-NLS-1$
                consumeInterfaceHeaderName1();  
                  break;
 
    case 205 : if (DEBUG) { System.out.println("InterfaceHeaderExtends ::= extends InterfaceTypeList"); }  //$NON-NLS-1$
                consumeInterfaceHeaderExtends();  
                  break;
 
    case 208 : if (DEBUG) { System.out.println("InterfaceMemberDeclarations ::=..."); }  //$NON-NLS-1$
                consumeInterfaceMemberDeclarations();  
                  break;
 
    case 209 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= SEMICOLON"); }  //$NON-NLS-1$
                consumeEmptyInterfaceMemberDeclaration();  
                  break;
 
    case 211 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= MethodHeader MethodBody"); }  //$NON-NLS-1$
                consumeInvalidMethodDeclaration();  
                  break;
 
    case 212 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); }  //$NON-NLS-1$
                consumeInvalidConstructorDeclaration(true);   
                  break;
 
    case 213 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); }  //$NON-NLS-1$
                consumeInvalidConstructorDeclaration(false);   
                  break;
 
    case 221 : if (DEBUG) { System.out.println("PushLeftBrace ::="); }  //$NON-NLS-1$
                consumePushLeftBrace();  
                  break;
 
    case 222 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace ,opt RBRACE"); }  //$NON-NLS-1$
                consumeEmptyArrayInitializer();  
                  break;
 
    case 223 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); }  //$NON-NLS-1$
                consumeArrayInitializer();  
                  break;
 
    case 224 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); }  //$NON-NLS-1$
                consumeArrayInitializer();  
                  break;
 
    case 226 : if (DEBUG) { System.out.println("VariableInitializers ::= VariableInitializers COMMA..."); }  //$NON-NLS-1$
                consumeVariableInitializers();  
                  break;
 
    case 227 : if (DEBUG) { System.out.println("Block ::= OpenBlock LBRACE BlockStatementsopt RBRACE"); }  //$NON-NLS-1$
                consumeBlock();  
                  break;
 
    case 228 : if (DEBUG) { System.out.println("OpenBlock ::="); }  //$NON-NLS-1$
                consumeOpenBlock() ;  
                  break;
 
    case 230 : if (DEBUG) { System.out.println("BlockStatements ::= BlockStatements BlockStatement"); }  //$NON-NLS-1$
                consumeBlockStatements() ;  
                  break;
 
    case 234 : if (DEBUG) { System.out.println("BlockStatement ::= InterfaceDeclaration"); }  //$NON-NLS-1$
                consumeInvalidInterfaceDeclaration();  
                  break;
 
    case 235 : if (DEBUG) { System.out.println("BlockStatement ::= AnnotationTypeDeclaration"); }  //$NON-NLS-1$
                consumeInvalidAnnotationTypeDeclaration();  
                  break;
 
    case 236 : if (DEBUG) { System.out.println("BlockStatement ::= EnumDeclaration"); }  //$NON-NLS-1$
                consumeInvalidEnumDeclaration();  
                  break;
 
    case 237 : if (DEBUG) { System.out.println("LocalVariableDeclarationStatement ::=..."); }  //$NON-NLS-1$
                consumeLocalVariableDeclarationStatement();  
                  break;
 
    case 238 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Type PushModifiers..."); }  //$NON-NLS-1$
                consumeLocalVariableDeclaration();  
                  break;
 
    case 239 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Modifiers Type..."); }  //$NON-NLS-1$
                consumeLocalVariableDeclaration();  
                  break;
 
    case 240 : if (DEBUG) { System.out.println("PushModifiers ::="); }  //$NON-NLS-1$
                consumePushModifiers();  
                  break;
 
    case 241 : if (DEBUG) { System.out.println("PushModifiersForHeader ::="); }  //$NON-NLS-1$
                consumePushModifiersForHeader();  
                  break;
 
    case 242 : if (DEBUG) { System.out.println("PushRealModifiers ::="); }  //$NON-NLS-1$
                consumePushRealModifiers();  
                  break;
 
    case 268 : if (DEBUG) { System.out.println("EmptyStatement ::= SEMICOLON"); }  //$NON-NLS-1$
                consumeEmptyStatement();  
                  break;
 
    case 269 : if (DEBUG) { System.out.println("LabeledStatement ::= Identifier COLON Statement"); }  //$NON-NLS-1$
                consumeStatementLabel() ;  
                  break;
 
    case 270 : if (DEBUG) { System.out.println("LabeledStatementNoShortIf ::= Identifier COLON..."); }  //$NON-NLS-1$
                consumeStatementLabel() ;  
                  break;
 
     case 271 : if (DEBUG) { System.out.println("ExpressionStatement ::= StatementExpression SEMICOLON"); }  //$NON-NLS-1$
                consumeExpressionStatement();  
                  break;
 
    case 280 : if (DEBUG) { System.out.println("IfThenStatement ::= if LPAREN Expression RPAREN..."); }  //$NON-NLS-1$
                consumeStatementIfNoElse();  
                  break;
 
    case 281 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); }  //$NON-NLS-1$
                consumeStatementIfWithElse();  
                  break;
 
    case 282 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); }  //$NON-NLS-1$
                consumeStatementIfWithElse();  
                  break;
 
    case 283 : if (DEBUG) { System.out.println("SwitchStatement ::= switch LPAREN Expression RPAREN..."); }  //$NON-NLS-1$
                consumeStatementSwitch() ;  
                  break;
 
    case 284 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE RBRACE"); }  //$NON-NLS-1$
                consumeEmptySwitchBlock() ;  
                  break;
 
    case 287 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE SwitchBlockStatements..."); }  //$NON-NLS-1$
                consumeSwitchBlock() ;  
                  break;
 
    case 289 : if (DEBUG) { System.out.println("SwitchBlockStatements ::= SwitchBlockStatements..."); }  //$NON-NLS-1$
                consumeSwitchBlockStatements() ;  
                  break;
 
    case 290 : if (DEBUG) { System.out.println("SwitchBlockStatement ::= SwitchLabels BlockStatements"); }  //$NON-NLS-1$
                consumeSwitchBlockStatement() ;  
                  break;
 
    case 292 : if (DEBUG) { System.out.println("SwitchLabels ::= SwitchLabels SwitchLabel"); }  //$NON-NLS-1$
                consumeSwitchLabels() ;  
                  break;
 
     case 293 : if (DEBUG) { System.out.println("SwitchLabel ::= case ConstantExpression COLON"); }  //$NON-NLS-1$
                consumeCaseLabel();  
                  break;
 
     case 294 : if (DEBUG) { System.out.println("SwitchLabel ::= default COLON"); }  //$NON-NLS-1$
                consumeDefaultLabel();  
                  break;
 
    case 295 : if (DEBUG) { System.out.println("WhileStatement ::= while LPAREN Expression RPAREN..."); }  //$NON-NLS-1$
                consumeStatementWhile() ;  
                  break;
 
    case 296 : if (DEBUG) { System.out.println("WhileStatementNoShortIf ::= while LPAREN Expression..."); }  //$NON-NLS-1$
                consumeStatementWhile() ;  
                  break;
 
    case 297 : if (DEBUG) { System.out.println("DoStatement ::= do Statement while LPAREN Expression..."); }  //$NON-NLS-1$
                consumeStatementDo() ;  
                  break;
 
    case 298 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInitopt SEMICOLON..."); }  //$NON-NLS-1$
                consumeStatementFor() ;  
                  break;
 
    case 299 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInitopt..."); }  //$NON-NLS-1$
                consumeStatementFor() ;  
                  break;
 
    case 300 : if (DEBUG) { System.out.println("ForInit ::= StatementExpressionList"); }  //$NON-NLS-1$
                consumeForInit() ;  
                  break;
 
    case 304 : if (DEBUG) { System.out.println("StatementExpressionList ::= StatementExpressionList..."); }  //$NON-NLS-1$
                consumeStatementExpressionList() ;  
                  break;
 
    case 305 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression SEMICOLON"); }  //$NON-NLS-1$
                consumeSimpleAssertStatement() ;  
                  break;
 
    case 306 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression COLON Expression"); }  //$NON-NLS-1$
                consumeAssertStatement() ;  
                  break;
 
    case 307 : if (DEBUG) { System.out.println("BreakStatement ::= break SEMICOLON"); }  //$NON-NLS-1$
                consumeStatementBreak() ;  
                  break;
 
    case 308 : if (DEBUG) { System.out.println("BreakStatement ::= break Identifier SEMICOLON"); }  //$NON-NLS-1$
                consumeStatementBreakWithLabel() ;  
                  break;
 
    case 309 : if (DEBUG) { System.out.println("ContinueStatement ::= continue SEMICOLON"); }  //$NON-NLS-1$
                consumeStatementContinue() ;  
                  break;
 
    case 310 : if (DEBUG) { System.out.println("ContinueStatement ::= continue Identifier SEMICOLON"); }  //$NON-NLS-1$
                consumeStatementContinueWithLabel() ;  
                  break;
 
    case 311 : if (DEBUG) { System.out.println("ReturnStatement ::= return Expressionopt SEMICOLON"); }  //$NON-NLS-1$
                consumeStatementReturn() ;  
                  break;
 
    case 312 : if (DEBUG) { System.out.println("ThrowStatement ::= throw Expression SEMICOLON"); }  //$NON-NLS-1$
                consumeStatementThrow();  
                  break;
 
    case 313 : if (DEBUG) { System.out.println("SynchronizedStatement ::= OnlySynchronized LPAREN..."); }  //$NON-NLS-1$
                consumeStatementSynchronized();  
                  break;
 
    case 314 : if (DEBUG) { System.out.println("OnlySynchronized ::= synchronized"); }  //$NON-NLS-1$
                consumeOnlySynchronized();  
                  break;
 
    case 315 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catches"); }  //$NON-NLS-1$
                consumeStatementTry(false);  
                  break;
 
    case 316 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catchesopt Finally"); }  //$NON-NLS-1$
                consumeStatementTry(true);  
                  break;
 
    case 318 : if (DEBUG) { System.out.println("ExitTryBlock ::="); }  //$NON-NLS-1$
                consumeExitTryBlock();  
                  break;
 
    case 320 : if (DEBUG) { System.out.println("Catches ::= Catches CatchClause"); }  //$NON-NLS-1$
                consumeCatches();  
                  break;
 
    case 321 : if (DEBUG) { System.out.println("CatchClause ::= catch LPAREN FormalParameter RPAREN..."); }  //$NON-NLS-1$
                consumeStatementCatch() ;  
                  break;
 
    case 323 : if (DEBUG) { System.out.println("PushLPAREN ::= LPAREN"); }  //$NON-NLS-1$
                consumeLeftParen();  
                  break;
 
    case 324 : if (DEBUG) { System.out.println("PushRPAREN ::= RPAREN"); }  //$NON-NLS-1$
                consumeRightParen();  
                  break;
 
    case 329 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= this"); }  //$NON-NLS-1$
                consumePrimaryNoNewArrayThis();  
                  break;
 
    case 330 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Expression_NotName..."); }  //$NON-NLS-1$
                consumePrimaryNoNewArray();  
                  break;
 
    case 331 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Name PushRPAREN"); }  //$NON-NLS-1$
                consumePrimaryNoNewArrayWithName();  
                  break;
 
    case 334 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT this"); }  //$NON-NLS-1$
                consumePrimaryNoNewArrayNameThis();  
                  break;
 
    case 335 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT super"); }  //$NON-NLS-1$
                consumePrimaryNoNewArrayNameSuper();  
                  break;
 
    case 336 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT class"); }  //$NON-NLS-1$
                consumePrimaryNoNewArrayName();  
                  break;
 
    case 337 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name Dims DOT class"); }  //$NON-NLS-1$
                consumePrimaryNoNewArrayArrayType();  
                  break;
 
    case 338 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType Dims DOT class"); }  //$NON-NLS-1$
                consumePrimaryNoNewArrayPrimitiveArrayType();  
                  break;
 
    case 339 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType DOT class"); }  //$NON-NLS-1$
                consumePrimaryNoNewArrayPrimitiveType();  
                  break;
 
    case 342 : if (DEBUG) { System.out.println("AllocationHeader ::= new ClassType LPAREN..."); }  //$NON-NLS-1$
                consumeAllocationHeader();  
                  break;
 
    case 343 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new..."); }  //$NON-NLS-1$
                consumeClassInstanceCreationExpressionWithTypeArguments();  
                  break;
 
    case 344 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new ClassType LPAREN"); }  //$NON-NLS-1$
                consumeClassInstanceCreationExpression();  
                  break;
 
    case 345 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); }  //$NON-NLS-1$
                consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;  
                  break;
 
    case 346 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); }  //$NON-NLS-1$
                consumeClassInstanceCreationExpressionQualified() ;  
                  break;
 
    case 347 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); }  //$NON-NLS-1$
                consumeClassInstanceCreationExpressionQualified() ;  
                  break;
 
    case 348 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); }  //$NON-NLS-1$
                consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;  
                  break;
 
    case 349 : if (DEBUG) { System.out.println("ClassInstanceCreationExpressionName ::= Name DOT"); }  //$NON-NLS-1$
                consumeClassInstanceCreationExpressionName() ;  
                  break;
 
    case 350 : if (DEBUG) { System.out.println("ClassBodyopt ::="); }  //$NON-NLS-1$
                consumeClassBodyopt();  
                  break;
 
    case 352 : if (DEBUG) { System.out.println("EnterAnonymousClassBody ::="); }  //$NON-NLS-1$
                consumeEnterAnonymousClassBody();  
                  break;
 
    case 354 : if (DEBUG) { System.out.println("ArgumentList ::= ArgumentList COMMA Expression"); }  //$NON-NLS-1$
                consumeArgumentList();  
                  break;
 
    case 355 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new PrimitiveType..."); }  //$NON-NLS-1$
                consumeArrayCreationHeader();  
                  break;
 
    case 356 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new ClassOrInterfaceType..."); }  //$NON-NLS-1$
                consumeArrayCreationHeader();  
                  break;
 
    case 357 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); }  //$NON-NLS-1$
                consumeArrayCreationExpressionWithoutInitializer();  
                  break;
 
    case 358 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new PrimitiveType"); }  //$NON-NLS-1$
                consumeArrayCreationExpressionWithInitializer();  
                  break;
 
    case 359 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); }  //$NON-NLS-1$
                consumeArrayCreationExpressionWithoutInitializer();  
                  break;
 
    case 360 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); }  //$NON-NLS-1$
                consumeArrayCreationExpressionWithInitializer();  
                  break;
 
    case 362 : if (DEBUG) { System.out.println("DimWithOrWithOutExprs ::= DimWithOrWithOutExprs..."); }  //$NON-NLS-1$
                consumeDimWithOrWithOutExprs();  
                  break;
 
     case 364 : if (DEBUG) { System.out.println("DimWithOrWithOutExpr ::= LBRACKET RBRACKET"); }  //$NON-NLS-1$
                consumeDimWithOrWithOutExpr();  
                  break;
 
     case 365 : if (DEBUG) { System.out.println("Dims ::= DimsLoop"); }  //$NON-NLS-1$
                consumeDims();  
                  break;
 
     case 368 : if (DEBUG) { System.out.println("OneDimLoop ::= LBRACKET RBRACKET"); }  //$NON-NLS-1$
                consumeOneDimLoop();  
                  break;
 
    case 369 : if (DEBUG) { System.out.println("FieldAccess ::= Primary DOT Identifier"); }  //$NON-NLS-1$
                consumeFieldAccess(false);  
                  break;
 
    case 370 : if (DEBUG) { System.out.println("FieldAccess ::= super DOT Identifier"); }  //$NON-NLS-1$
                consumeFieldAccess(true);  
                  break;
 
    case 371 : if (DEBUG) { System.out.println("MethodInvocation ::= Name LPAREN ArgumentListopt RPAREN"); }  //$NON-NLS-1$
                consumeMethodInvocationName();  
                  break;
 
    case 372 : if (DEBUG) { System.out.println("MethodInvocation ::= Name DOT OnlyTypeArguments..."); }  //$NON-NLS-1$
                consumeMethodInvocationNameWithTypeArguments();  
                  break;
 
    case 373 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT OnlyTypeArguments..."); }  //$NON-NLS-1$
                consumeMethodInvocationPrimaryWithTypeArguments();  
                  break;
 
    case 374 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT Identifier LPAREN..."); }  //$NON-NLS-1$
                consumeMethodInvocationPrimary();  
                  break;
 
    case 375 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT OnlyTypeArguments..."); }  //$NON-NLS-1$
                consumeMethodInvocationSuperWithTypeArguments();  
                  break;
 
    case 376 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT Identifier LPAREN..."); }  //$NON-NLS-1$
                consumeMethodInvocationSuper();  
                  break;
 
    case 377 : if (DEBUG) { System.out.println("ArrayAccess ::= Name LBRACKET Expression RBRACKET"); }  //$NON-NLS-1$
                consumeArrayAccess(true);  
                  break;
 
    case 378 : if (DEBUG) { System.out.println("ArrayAccess ::= PrimaryNoNewArray LBRACKET Expression..."); }  //$NON-NLS-1$
                consumeArrayAccess(false);  
                  break;
 
    case 379 : if (DEBUG) { System.out.println("ArrayAccess ::= ArrayCreationWithArrayInitializer..."); }  //$NON-NLS-1$
                consumeArrayAccess(false);  
                  break;
 
    case 381 : if (DEBUG) { System.out.println("PostfixExpression ::= Name"); }  //$NON-NLS-1$
                consumePostfixExpression();  
                  break;
 
    case 384 : if (DEBUG) { System.out.println("PostIncrementExpression ::= PostfixExpression PLUS_PLUS"); }  //$NON-NLS-1$
                consumeUnaryExpression(OperatorIds.PLUS,true);  
                  break;
 
    case 385 : if (DEBUG) { System.out.println("PostDecrementExpression ::= PostfixExpression..."); }  //$NON-NLS-1$
                consumeUnaryExpression(OperatorIds.MINUS,true);  
                  break;
 
    case 386 : if (DEBUG) { System.out.println("PushPosition ::="); }  //$NON-NLS-1$
                consumePushPosition();  
                  break;
 
    case 389 : if (DEBUG) { System.out.println("UnaryExpression ::= PLUS PushPosition UnaryExpression"); }  //$NON-NLS-1$
                consumeUnaryExpression(OperatorIds.PLUS);  
                  break;
 
    case 390 : if (DEBUG) { System.out.println("UnaryExpression ::= MINUS PushPosition UnaryExpression"); }  //$NON-NLS-1$
                consumeUnaryExpression(OperatorIds.MINUS);  
                  break;
 
    case 392 : if (DEBUG) { System.out.println("PreIncrementExpression ::= PLUS_PLUS PushPosition..."); }  //$NON-NLS-1$
                consumeUnaryExpression(OperatorIds.PLUS,false);  
                  break;
 
    case 393 : if (DEBUG) { System.out.println("PreDecrementExpression ::= MINUS_MINUS PushPosition..."); }  //$NON-NLS-1$
                consumeUnaryExpression(OperatorIds.MINUS,false);  
                  break;
 
    case 395 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= TWIDDLE PushPosition..."); }  //$NON-NLS-1$
                consumeUnaryExpression(OperatorIds.TWIDDLE);  
                  break;
 
    case 396 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= NOT PushPosition..."); }  //$NON-NLS-1$
                consumeUnaryExpression(OperatorIds.NOT);  
                  break;
 
    case 398 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN PrimitiveType Dimsopt..."); }  //$NON-NLS-1$
                consumeCastExpressionWithPrimitiveType();  
                  break;
 
    case 399 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); }  //$NON-NLS-1$
                consumeCastExpressionWithGenericsArray();  
                  break;
 
    case 400 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); }  //$NON-NLS-1$
                consumeCastExpressionWithQualifiedGenericsArray();  
                  break;
 
    case 401 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name PushRPAREN..."); }  //$NON-NLS-1$
                consumeCastExpressionLL1();  
                  break;
 
    case 402 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name Dims PushRPAREN..."); }  //$NON-NLS-1$
                consumeCastExpressionWithNameArray();  
                  break;
 
    case 403 : if (DEBUG) { System.out.println("OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments"); }  //$NON-NLS-1$
                consumeOnlyTypeArgumentsForCastExpression();  
                  break;
 
    case 404 : if (DEBUG) { System.out.println("InsideCastExpression ::="); }  //$NON-NLS-1$
                consumeInsideCastExpression();  
                  break;
 
    case 405 : if (DEBUG) { System.out.println("InsideCastExpressionLL1 ::="); }  //$NON-NLS-1$
                consumeInsideCastExpressionLL1();  
                  break;
 
    case 406 : if (DEBUG) { System.out.println("InsideCastExpressionWithQualifiedGenerics ::="); }  //$NON-NLS-1$
                consumeInsideCastExpressionWithQualifiedGenerics();  
                  break;
 
    case 408 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.MULTIPLY);  
                  break;
 
    case 409 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.DIVIDE);  
                  break;
 
    case 410 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.REMAINDER);  
                  break;
 
    case 412 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression PLUS..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.PLUS);  
                  break;
 
    case 413 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression MINUS..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.MINUS);  
                  break;
 
    case 415 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression LEFT_SHIFT..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.LEFT_SHIFT);  
                  break;
 
    case 416 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression RIGHT_SHIFT..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);  
                  break;
 
    case 417 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression UNSIGNED_RIGHT_SHIFT"); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);  
                  break;
 
    case 419 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.LESS);  
                  break;
 
    case 420 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression GREATER..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.GREATER);  
                  break;
 
    case 421 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS_EQUAL"); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.LESS_EQUAL);  
                  break;
 
    case 422 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.GREATER_EQUAL);  
                  break;
 
    case 424 : if (DEBUG) { System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); }  //$NON-NLS-1$
                consumeInstanceOfExpression(OperatorIds.INSTANCEOF);  
                  break;
 
    case 426 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression EQUAL_EQUAL..."); }  //$NON-NLS-1$
                consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);  
                  break;
 
    case 427 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression NOT_EQUAL..."); }  //$NON-NLS-1$
                consumeEqualityExpression(OperatorIds.NOT_EQUAL);  
                  break;
 
    case 429 : if (DEBUG) { System.out.println("AndExpression ::= AndExpression AND EqualityExpression"); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.AND);  
                  break;
 
    case 431 : if (DEBUG) { System.out.println("ExclusiveOrExpression ::= ExclusiveOrExpression XOR..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.XOR);  
                  break;
 
    case 433 : if (DEBUG) { System.out.println("InclusiveOrExpression ::= InclusiveOrExpression OR..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.OR);  
                  break;
 
    case 435 : if (DEBUG) { System.out.println("ConditionalAndExpression ::= ConditionalAndExpression..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.AND_AND);  
                  break;
 
    case 437 : if (DEBUG) { System.out.println("ConditionalOrExpression ::= ConditionalOrExpression..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.OR_OR);  
                  break;
 
    case 439 : if (DEBUG) { System.out.println("ConditionalExpression ::= ConditionalOrExpression..."); }  //$NON-NLS-1$
                consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;  
                  break;
 
    case 442 : if (DEBUG) { System.out.println("Assignment ::= PostfixExpression AssignmentOperator..."); }  //$NON-NLS-1$
                consumeAssignment();  
                  break;
 
    case 444 : if (DEBUG) { System.out.println("Assignment ::= InvalidArrayInitializerAssignement"); }  //$NON-NLS-1$
                ignoreExpressionAssignment(); 
                  break;
 
    case 445 : if (DEBUG) { System.out.println("AssignmentOperator ::= EQUAL"); }  //$NON-NLS-1$
                consumeAssignmentOperator(EQUAL);  
                  break;
 
    case 446 : if (DEBUG) { System.out.println("AssignmentOperator ::= MULTIPLY_EQUAL"); }  //$NON-NLS-1$
                consumeAssignmentOperator(MULTIPLY);  
                  break;
 
    case 447 : if (DEBUG) { System.out.println("AssignmentOperator ::= DIVIDE_EQUAL"); }  //$NON-NLS-1$
                consumeAssignmentOperator(DIVIDE);  
                  break;
 
    case 448 : if (DEBUG) { System.out.println("AssignmentOperator ::= REMAINDER_EQUAL"); }  //$NON-NLS-1$
                consumeAssignmentOperator(REMAINDER);  
                  break;
 
    case 449 : if (DEBUG) { System.out.println("AssignmentOperator ::= PLUS_EQUAL"); }  //$NON-NLS-1$
                consumeAssignmentOperator(PLUS);  
                  break;
 
    case 450 : if (DEBUG) { System.out.println("AssignmentOperator ::= MINUS_EQUAL"); }  //$NON-NLS-1$
                consumeAssignmentOperator(MINUS);  
                  break;
 
    case 451 : if (DEBUG) { System.out.println("AssignmentOperator ::= LEFT_SHIFT_EQUAL"); }  //$NON-NLS-1$
                consumeAssignmentOperator(LEFT_SHIFT);  
                  break;
 
    case 452 : if (DEBUG) { System.out.println("AssignmentOperator ::= RIGHT_SHIFT_EQUAL"); }  //$NON-NLS-1$
                consumeAssignmentOperator(RIGHT_SHIFT);  
                  break;
 
    case 453 : if (DEBUG) { System.out.println("AssignmentOperator ::= UNSIGNED_RIGHT_SHIFT_EQUAL"); }  //$NON-NLS-1$
                consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT);  
                  break;
 
    case 454 : if (DEBUG) { System.out.println("AssignmentOperator ::= AND_EQUAL"); }  //$NON-NLS-1$
                consumeAssignmentOperator(AND);  
                  break;
 
    case 455 : if (DEBUG) { System.out.println("AssignmentOperator ::= XOR_EQUAL"); }  //$NON-NLS-1$
                consumeAssignmentOperator(XOR);  
                  break;
 
    case 456 : if (DEBUG) { System.out.println("AssignmentOperator ::= OR_EQUAL"); }  //$NON-NLS-1$
                consumeAssignmentOperator(OR);  
                  break;
 
    case 460 : if (DEBUG) { System.out.println("Expressionopt ::="); }  //$NON-NLS-1$
                consumeEmptyExpression();  
                  break;
 
    case 465 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::="); }  //$NON-NLS-1$
                consumeEmptyClassBodyDeclarationsopt();  
                  break;
 
    case 466 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::= NestedType..."); }  //$NON-NLS-1$
                consumeClassBodyDeclarationsopt();  
                  break;
 
     case 467 : if (DEBUG) { System.out.println("Modifiersopt ::="); }  //$NON-NLS-1$
                consumeDefaultModifiers();  
                  break;
 
    case 468 : if (DEBUG) { System.out.println("Modifiersopt ::= Modifiers"); }  //$NON-NLS-1$
                consumeModifiers();  
                  break;
 
    case 469 : if (DEBUG) { System.out.println("BlockStatementsopt ::="); }  //$NON-NLS-1$
                consumeEmptyBlockStatementsopt();  
                  break;
 
     case 471 : if (DEBUG) { System.out.println("Dimsopt ::="); }  //$NON-NLS-1$
                consumeEmptyDimsopt();  
                  break;
 
     case 473 : if (DEBUG) { System.out.println("ArgumentListopt ::="); }  //$NON-NLS-1$
                consumeEmptyArgumentListopt();  
                  break;
 
    case 477 : if (DEBUG) { System.out.println("FormalParameterListopt ::="); }  //$NON-NLS-1$
                consumeFormalParameterListopt();  
                  break;
 
     case 481 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::="); }  //$NON-NLS-1$
                consumeEmptyInterfaceMemberDeclarationsopt();  
                  break;
 
     case 482 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::= NestedType..."); }  //$NON-NLS-1$
                consumeInterfaceMemberDeclarationsopt();  
                  break;
 
    case 483 : if (DEBUG) { System.out.println("NestedType ::="); }  //$NON-NLS-1$
                consumeNestedType();  
                  break;

     case 484 : if (DEBUG) { System.out.println("ForInitopt ::="); }  //$NON-NLS-1$
                consumeEmptyForInitopt();  
                  break;
 
     case 486 : if (DEBUG) { System.out.println("ForUpdateopt ::="); }  //$NON-NLS-1$
                consumeEmptyForUpdateopt();  
                  break;
 
     case 490 : if (DEBUG) { System.out.println("Catchesopt ::="); }  //$NON-NLS-1$
                consumeEmptyCatchesopt();  
                  break;
 
     case 492 : if (DEBUG) { System.out.println("EnumDeclaration ::= EnumHeader EnumBody"); }  //$NON-NLS-1$
                consumeEnumDeclaration();  
                  break;
 
     case 493 : if (DEBUG) { System.out.println("EnumHeader ::= EnumHeaderName ClassHeaderImplementsopt"); }  //$NON-NLS-1$
                consumeEnumHeader();  
                  break;
 
     case 494 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier"); }  //$NON-NLS-1$
                consumeEnumHeaderName();  
                  break;
 
     case 495 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumBodyDeclarationsopt RBRACE"); }  //$NON-NLS-1$
                consumeEnumBodyNoConstants();  
                  break;
 
     case 496 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE COMMA EnumBodyDeclarationsopt..."); }  //$NON-NLS-1$
                consumeEnumBodyNoConstants();  
                  break;
 
     case 497 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants COMMA..."); }  //$NON-NLS-1$
                consumeEnumBodyWithConstants();  
                  break;
 
     case 498 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants..."); }  //$NON-NLS-1$
                consumeEnumBodyWithConstants();  
                  break;
 
    case 500 : if (DEBUG) { System.out.println("EnumConstants ::= EnumConstants COMMA EnumConstant"); }  //$NON-NLS-1$
                consumeEnumConstants();  
                  break;
 
    case 501 : if (DEBUG) { System.out.println("EnumConstantHeaderName ::= Modifiersopt Identifier"); }  //$NON-NLS-1$
                consumeEnumConstantHeaderName();  
                  break;
 
    case 502 : if (DEBUG) { System.out.println("EnumConstantHeader ::= EnumConstantHeaderName..."); }  //$NON-NLS-1$
                consumeEnumConstantHeader();  
                  break;
 
    case 503 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader ForceNoDiet..."); }  //$NON-NLS-1$
                consumeEnumConstantWithClassBody();  
                  break;
 
    case 504 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader"); }  //$NON-NLS-1$
                consumeEnumConstantNoClassBody();  
                  break;
 
    case 505 : if (DEBUG) { System.out.println("Arguments ::= LPAREN ArgumentListopt RPAREN"); }  //$NON-NLS-1$
                consumeArguments();  
                  break;
 
    case 506 : if (DEBUG) { System.out.println("Argumentsopt ::="); }  //$NON-NLS-1$
                consumeEmptyArguments();  
                  break;
 
    case 508 : if (DEBUG) { System.out.println("EnumDeclarations ::= SEMICOLON ClassBodyDeclarationsopt"); }  //$NON-NLS-1$
                consumeEnumDeclarations();  
                  break;
 
    case 509 : if (DEBUG) { System.out.println("EnumBodyDeclarationsopt ::="); }  //$NON-NLS-1$
                consumeEmptyEnumDeclarations();  
                  break;
 
    case 511 : if (DEBUG) { System.out.println("EnhancedForStatement ::= EnhancedForStatementHeader..."); }  //$NON-NLS-1$
                consumeEnhancedForStatement();  
                  break;
 
    case 512 : if (DEBUG) { System.out.println("EnhancedForStatementNoShortIf ::=..."); }  //$NON-NLS-1$
                consumeEnhancedForStatement();  
                  break;
 
    case 513 : if (DEBUG) { System.out.println("EnhancedForStatementHeader ::= for LPAREN Type..."); }  //$NON-NLS-1$
                consumeEnhancedForStatementHeader(false);  
                  break;
 
    case 514 : if (DEBUG) { System.out.println("EnhancedForStatementHeader ::= for LPAREN Modifiers Type"); }  //$NON-NLS-1$
                consumeEnhancedForStatementHeader(true);  
                  break;
 
    case 515 : if (DEBUG) { System.out.println("SingleStaticImportDeclaration ::=..."); }  //$NON-NLS-1$
                consumeImportDeclaration();  
                  break;
 
    case 516 : if (DEBUG) { System.out.println("SingleStaticImportDeclarationName ::= import static Name"); }  //$NON-NLS-1$
                consumeSingleStaticImportDeclarationName();  
                  break;
 
    case 517 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclaration ::=..."); }  //$NON-NLS-1$
                consumeImportDeclaration();  
                  break;
 
    case 518 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclarationName ::= import static..."); }  //$NON-NLS-1$
                consumeStaticImportOnDemandDeclarationName();  
                  break;
 
    case 519 : if (DEBUG) { System.out.println("TypeArguments ::= LESS TypeArgumentList1"); }  //$NON-NLS-1$
                consumeTypeArguments();  
                  break;
 
    case 520 : if (DEBUG) { System.out.println("OnlyTypeArguments ::= LESS TypeArgumentList1"); }  //$NON-NLS-1$
                consumeOnlyTypeArguments();  
                  break;
 
    case 522 : if (DEBUG) { System.out.println("TypeArgumentList1 ::= TypeArgumentList COMMA..."); }  //$NON-NLS-1$
                consumeTypeArgumentList1();  
                  break;
 
    case 524 : if (DEBUG) { System.out.println("TypeArgumentList ::= TypeArgumentList COMMA TypeArgument"); }  //$NON-NLS-1$
                consumeTypeArgumentList();  
                  break;
 
    case 525 : if (DEBUG) { System.out.println("TypeArgument ::= ReferenceType"); }  //$NON-NLS-1$
                consumeTypeArgument();  
                  break;
 
    case 529 : if (DEBUG) { System.out.println("ReferenceType1 ::= ReferenceType GREATER"); }  //$NON-NLS-1$
                consumeReferenceType1();  
                  break;
 
    case 530 : if (DEBUG) { System.out.println("ReferenceType1 ::= ClassOrInterface LESS..."); }  //$NON-NLS-1$
                consumeTypeArgumentReferenceType1();  
                  break;
 
    case 532 : if (DEBUG) { System.out.println("TypeArgumentList2 ::= TypeArgumentList COMMA..."); }  //$NON-NLS-1$
                consumeTypeArgumentList2();  
                  break;
 
    case 535 : if (DEBUG) { System.out.println("ReferenceType2 ::= ReferenceType RIGHT_SHIFT"); }  //$NON-NLS-1$
                consumeReferenceType2();  
                  break;
 
    case 536 : if (DEBUG) { System.out.println("ReferenceType2 ::= ClassOrInterface LESS..."); }  //$NON-NLS-1$
                consumeTypeArgumentReferenceType2();  
                  break;
 
    case 538 : if (DEBUG) { System.out.println("TypeArgumentList3 ::= TypeArgumentList COMMA..."); }  //$NON-NLS-1$
                consumeTypeArgumentList3();  
                  break;
 
    case 541 : if (DEBUG) { System.out.println("ReferenceType3 ::= ReferenceType UNSIGNED_RIGHT_SHIFT"); }  //$NON-NLS-1$
                consumeReferenceType3();  
                  break;
 
    case 542 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION"); }  //$NON-NLS-1$
                consumeWildcard();  
                  break;
 
    case 543 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION WildcardBounds"); }  //$NON-NLS-1$
                consumeWildcardWithBounds();  
                  break;
 
    case 544 : if (DEBUG) { System.out.println("WildcardBounds ::= extends ReferenceType"); }  //$NON-NLS-1$
                consumeWildcardBoundsExtends();  
                  break;
 
    case 545 : if (DEBUG) { System.out.println("WildcardBounds ::= super ReferenceType"); }  //$NON-NLS-1$
                consumeWildcardBoundsSuper();  
                  break;
 
    case 546 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION GREATER"); }  //$NON-NLS-1$
                consumeWildcard1();  
                  break;
 
    case 547 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION WildcardBounds1"); }  //$NON-NLS-1$
                consumeWildcard1WithBounds();  
                  break;
 
    case 548 : if (DEBUG) { System.out.println("WildcardBounds1 ::= extends ReferenceType1"); }  //$NON-NLS-1$
                consumeWildcardBounds1Extends();  
                  break;
 
    case 549 : if (DEBUG) { System.out.println("WildcardBounds1 ::= super ReferenceType1"); }  //$NON-NLS-1$
                consumeWildcardBounds1Super();  
                  break;
 
    case 550 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION RIGHT_SHIFT"); }  //$NON-NLS-1$
                consumeWildcard2();  
                  break;
 
    case 551 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION WildcardBounds2"); }  //$NON-NLS-1$
                consumeWildcard2WithBounds();  
                  break;
 
    case 552 : if (DEBUG) { System.out.println("WildcardBounds2 ::= extends ReferenceType2"); }  //$NON-NLS-1$
                consumeWildcardBounds2Extends();  
                  break;
 
    case 553 : if (DEBUG) { System.out.println("WildcardBounds2 ::= super ReferenceType2"); }  //$NON-NLS-1$
                consumeWildcardBounds2Super();  
                  break;
 
    case 554 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION UNSIGNED_RIGHT_SHIFT"); }  //$NON-NLS-1$
                consumeWildcard3();  
                  break;
 
    case 555 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION WildcardBounds3"); }  //$NON-NLS-1$
                consumeWildcard3WithBounds();  
                  break;
 
    case 556 : if (DEBUG) { System.out.println("WildcardBounds3 ::= extends ReferenceType3"); }  //$NON-NLS-1$
                consumeWildcardBounds3Extends();  
                  break;
 
    case 557 : if (DEBUG) { System.out.println("WildcardBounds3 ::= super ReferenceType3"); }  //$NON-NLS-1$
                consumeWildcardBounds3Super();  
                  break;
 
    case 558 : if (DEBUG) { System.out.println("TypeParameterHeader ::= Identifier"); }  //$NON-NLS-1$
                consumeTypeParameterHeader();  
                  break;
 
    case 559 : if (DEBUG) { System.out.println("TypeParameters ::= LESS TypeParameterList1"); }  //$NON-NLS-1$
                consumeTypeParameters();  
                  break;
 
    case 561 : if (DEBUG) { System.out.println("TypeParameterList ::= TypeParameterList COMMA..."); }  //$NON-NLS-1$
                consumeTypeParameterList();  
                  break;
 
    case 563 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); }  //$NON-NLS-1$
                consumeTypeParameterWithExtends();  
                  break;
 
    case 564 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); }  //$NON-NLS-1$
                consumeTypeParameterWithExtendsAndBounds();  
                  break;
 
    case 566 : if (DEBUG) { System.out.println("AdditionalBoundList ::= AdditionalBoundList..."); }  //$NON-NLS-1$
                consumeAdditionalBoundList();  
                  break;
 
    case 567 : if (DEBUG) { System.out.println("AdditionalBound ::= AND ReferenceType"); }  //$NON-NLS-1$
                consumeAdditionalBound();  
                  break;
 
    case 569 : if (DEBUG) { System.out.println("TypeParameterList1 ::= TypeParameterList COMMA..."); }  //$NON-NLS-1$
                consumeTypeParameterList1();  
                  break;
 
    case 570 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader GREATER"); }  //$NON-NLS-1$
                consumeTypeParameter1();  
                  break;
 
    case 571 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); }  //$NON-NLS-1$
                consumeTypeParameter1WithExtends();  
                  break;
 
    case 572 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); }  //$NON-NLS-1$
                consumeTypeParameter1WithExtendsAndBounds();  
                  break;
 
    case 574 : if (DEBUG) { System.out.println("AdditionalBoundList1 ::= AdditionalBoundList..."); }  //$NON-NLS-1$
                consumeAdditionalBoundList1();  
                  break;
 
    case 575 : if (DEBUG) { System.out.println("AdditionalBound1 ::= AND ReferenceType1"); }  //$NON-NLS-1$
                consumeAdditionalBound1();  
                  break;
 
    case 581 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= PLUS PushPosition..."); }  //$NON-NLS-1$
                consumeUnaryExpression(OperatorIds.PLUS);  
                  break;
 
    case 582 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= MINUS PushPosition..."); }  //$NON-NLS-1$
                consumeUnaryExpression(OperatorIds.MINUS);  
                  break;
 
    case 585 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= TWIDDLE..."); }  //$NON-NLS-1$
                consumeUnaryExpression(OperatorIds.TWIDDLE);  
                  break;
 
    case 586 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= NOT PushPosition"); }  //$NON-NLS-1$
                consumeUnaryExpression(OperatorIds.NOT);  
                  break;
 
    case 589 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.MULTIPLY);  
                  break;
 
    case 590 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name MULTIPLY..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.MULTIPLY);  
                  break;
 
    case 591 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.DIVIDE);  
                  break;
 
    case 592 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name DIVIDE..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.DIVIDE);  
                  break;
 
    case 593 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.REMAINDER);  
                  break;
 
    case 594 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name REMAINDER..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.REMAINDER);  
                  break;
 
    case 596 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.PLUS);  
                  break;
 
    case 597 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name PLUS..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.PLUS);  
                  break;
 
    case 598 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.MINUS);  
                  break;
 
    case 599 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name MINUS..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.MINUS);  
                  break;
 
    case 601 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.LEFT_SHIFT);  
                  break;
 
    case 602 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name LEFT_SHIFT..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.LEFT_SHIFT);  
                  break;
 
    case 603 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);  
                  break;
 
    case 604 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name RIGHT_SHIFT..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.RIGHT_SHIFT);  
                  break;
 
    case 605 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);  
                  break;
 
    case 606 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name UNSIGNED_RIGHT_SHIFT..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.UNSIGNED_RIGHT_SHIFT);  
                  break;
 
    case 608 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.LESS);  
                  break;
 
    case 609 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.LESS);  
                  break;
 
    case 610 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.GREATER);  
                  break;
 
    case 611 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.GREATER);  
                  break;
 
    case 612 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.LESS_EQUAL);  
                  break;
 
    case 613 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS_EQUAL..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.LESS_EQUAL);  
                  break;
 
    case 614 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.GREATER_EQUAL);  
                  break;
 
    case 615 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER_EQUAL..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.GREATER_EQUAL);  
                  break;
 
    case 617 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); }  //$NON-NLS-1$
                consumeInstanceOfExpressionWithName(OperatorIds.INSTANCEOF);  
                  break;
 
    case 618 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeInstanceOfExpression(OperatorIds.INSTANCEOF);  
                  break;
 
    case 620 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);  
                  break;
 
    case 621 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name EQUAL_EQUAL..."); }  //$NON-NLS-1$
                consumeEqualityExpressionWithName(OperatorIds.EQUAL_EQUAL);  
                  break;
 
    case 622 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeEqualityExpression(OperatorIds.NOT_EQUAL);  
                  break;
 
    case 623 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name NOT_EQUAL..."); }  //$NON-NLS-1$
                consumeEqualityExpressionWithName(OperatorIds.NOT_EQUAL);  
                  break;
 
    case 625 : if (DEBUG) { System.out.println("AndExpression_NotName ::= AndExpression_NotName AND..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.AND);  
                  break;
 
    case 626 : if (DEBUG) { System.out.println("AndExpression_NotName ::= Name AND EqualityExpression"); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.AND);  
                  break;
 
    case 628 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.XOR);  
                  break;
 
    case 629 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::= Name XOR AndExpression"); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.XOR);  
                  break;
 
    case 631 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.OR);  
                  break;
 
    case 632 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::= Name OR..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.OR);  
                  break;
 
    case 634 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.AND_AND);  
                  break;
 
    case 635 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::= Name AND_AND..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.AND_AND);  
                  break;
 
    case 637 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeBinaryExpression(OperatorIds.OR_OR);  
                  break;
 
    case 638 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::= Name OR_OR..."); }  //$NON-NLS-1$
                consumeBinaryExpressionWithName(OperatorIds.OR_OR);  
                  break;
 
    case 640 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::=..."); }  //$NON-NLS-1$
                consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;  
                  break;
 
    case 641 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::= Name QUESTION..."); }  //$NON-NLS-1$
                consumeConditionalExpressionWithName(OperatorIds.QUESTIONCOLON) ;  
                  break;
 
    case 645 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); }  //$NON-NLS-1$
                consumeAnnotationTypeDeclarationHeaderName() ;  
                  break;
 
    case 646 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); }  //$NON-NLS-1$
                consumeAnnotationTypeDeclarationHeaderName() ;  
                  break;
 
    case 647 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeader ::=..."); }  //$NON-NLS-1$
                consumeAnnotationTypeDeclarationHeader() ;  
                  break;
 
    case 648 : if (DEBUG) { System.out.println("AnnotationTypeDeclaration ::=..."); }  //$NON-NLS-1$
                consumeAnnotationTypeDeclaration() ;  
                  break;
 
    case 650 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::="); }  //$NON-NLS-1$
                consumeEmptyAnnotationTypeMemberDeclarationsopt() ;  
                  break;
 
    case 651 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::= NestedType..."); }  //$NON-NLS-1$
                consumeAnnotationTypeMemberDeclarationsopt() ;  
                  break;
 
    case 653 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarations ::=..."); }  //$NON-NLS-1$
                consumeAnnotationTypeMemberDeclarations() ;  
                  break;
 
    case 654 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt..."); }  //$NON-NLS-1$
                consumeMethodHeaderNameWithTypeParameters(true);  
                  break;
 
    case 655 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt Type..."); }  //$NON-NLS-1$
                consumeMethodHeaderName(true);  
                  break;
 
    case 656 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::="); }  //$NON-NLS-1$
                consumeEmptyMethodHeaderDefaultValue() ;  
                  break;
 
    case 657 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::= DefaultValue"); }  //$NON-NLS-1$
                consumeMethodHeaderDefaultValue();  
                  break;
 
    case 658 : if (DEBUG) { System.out.println("AnnotationMethodHeader ::= AnnotationMethodHeaderName..."); }  //$NON-NLS-1$
                consumeMethodHeader();  
                  break;
 
    case 659 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclaration ::=..."); }  //$NON-NLS-1$
                consumeAnnotationTypeMemberDeclaration() ;  
                  break;
 
    case 667 : if (DEBUG) { System.out.println("AnnotationName ::= AT Name"); }  //$NON-NLS-1$
                consumeAnnotationName() ;  
                  break;
 
    case 668 : if (DEBUG) { System.out.println("NormalAnnotation ::= AnnotationName LPAREN..."); }  //$NON-NLS-1$
                consumeNormalAnnotation() ;  
                  break;
 
    case 669 : if (DEBUG) { System.out.println("MemberValuePairsopt ::="); }  //$NON-NLS-1$
                consumeEmptyMemberValuePairsopt() ;  
                  break;
 
    case 672 : if (DEBUG) { System.out.println("MemberValuePairs ::= MemberValuePairs COMMA..."); }  //$NON-NLS-1$
                consumeMemberValuePairs() ;  
                  break;
 
    case 673 : if (DEBUG) { System.out.println("MemberValuePair ::= SimpleName EQUAL EnterMemberValue..."); }  //$NON-NLS-1$
                consumeMemberValuePair() ;  
                  break;
 
    case 674 : if (DEBUG) { System.out.println("EnterMemberValue ::="); }  //$NON-NLS-1$
                consumeEnterMemberValue() ;  
                  break;
 
    case 675 : if (DEBUG) { System.out.println("ExitMemberValue ::="); }  //$NON-NLS-1$
                consumeExitMemberValue() ;  
                  break;
 
    case 677 : if (DEBUG) { System.out.println("MemberValue ::= Name"); }  //$NON-NLS-1$
                consumeMemberValueAsName() ;  
                  break;
 
    case 680 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::= LBRACE PushLeftBrace..."); }  //$NON-NLS-1$
                consumeMemberValueArrayInitializer() ;  
                  break;
 
    case 681 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::= LBRACE PushLeftBrace..."); }  //$NON-NLS-1$
                consumeMemberValueArrayInitializer() ;  
                  break;
 
    case 682 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::= LBRACE PushLeftBrace..."); }  //$NON-NLS-1$
                consumeEmptyMemberValueArrayInitializer() ;  
                  break;
 
    case 683 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::= LBRACE PushLeftBrace..."); }  //$NON-NLS-1$
                consumeEmptyMemberValueArrayInitializer() ;  
                  break;
 
    case 685 : if (DEBUG) { System.out.println("MemberValues ::= MemberValues COMMA MemberValue"); }  //$NON-NLS-1$
                consumeMemberValues() ;  
                  break;
 
    case 686 : if (DEBUG) { System.out.println("MarkerAnnotation ::= AnnotationName"); }  //$NON-NLS-1$
                consumeMarkerAnnotation() ;  
                  break;
 
    case 687 : if (DEBUG) { System.out.println("SingleMemberAnnotation ::= AnnotationName LPAREN..."); }  //$NON-NLS-1$
                consumeSingleMemberAnnotation() ;  
                  break;
 
    case 688 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); }  //$NON-NLS-1$
                consumeRecoveryMethodHeaderNameWithTypeParameters();  
                  break;
 
    case 689 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt Type..."); }  //$NON-NLS-1$
                consumeRecoveryMethodHeaderName();  
                  break;
 
    case 690 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); }  //$NON-NLS-1$
                consumeMethodHeader();  
                  break;
 
    case 691 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); }  //$NON-NLS-1$
                consumeMethodHeader();  
                  break;
 
      }
} 
protected void consumeSimpleAssertStatement() {
      // AssertStatement ::= 'assert' Expression ';'
      this.expressionLengthPtr--;
      pushOnAstStack(new AssertStatement(this.expressionStack[this.expressionPtr--], this.intStack[this.intPtr--]));    
}
protected void consumeSingleMemberAnnotation() {
      // SingleMemberAnnotation ::= '@' Name '(' MemberValue ')'
      SingleMemberAnnotation singleMemberAnnotation = null;
      TypeReference typeReference = this.getAnnotationType();
      singleMemberAnnotation = new SingleMemberAnnotation(typeReference, this.intStack[this.intPtr--]);
      singleMemberAnnotation.memberValue = this.expressionStack[this.expressionPtr--];
      this.expressionLengthPtr--;
      singleMemberAnnotation.declarationSourceEnd = this.rParenPos;
      pushOnExpressionStack(singleMemberAnnotation);
      
      
      if(this.currentElement != null) {
            annotationRecoveryCheckPoint(singleMemberAnnotation.sourceStart, singleMemberAnnotation.declarationSourceEnd);
      }
      
      if(options.sourceLevel < ClassFileConstants.JDK1_5 &&
                  this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
            this.problemReporter().invalidUsageOfAnnotation(singleMemberAnnotation);
      }
}
protected void consumeSingleStaticImportDeclarationName() {
      // SingleTypeImportDeclarationName ::= 'import' 'static' Name
      /* push an ImportRef build from the last name 
      stored in the identifier stack. */

      ImportReference impt;
      int length;
      char[][] tokens = new char[length = this.identifierLengthStack[this.identifierLengthPtr--]][];
      this.identifierPtr -= length;
      long[] positions = new long[length];
      System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, 0, length);
      System.arraycopy(this.identifierPositionStack, this.identifierPtr + 1, positions, 0, length);
      pushOnAstStack(impt = new ImportReference(tokens, positions, false, AccStatic));

      this.modifiers = AccDefault;
      this.modifiersSourceStart = -1; // <-- see comment into modifiersFlag(int)
      
      if (this.currentToken == TokenNameSEMICOLON){
            impt.declarationSourceEnd = this.scanner.currentPosition - 1;
      } else {
            impt.declarationSourceEnd = impt.sourceEnd;
      }
      impt.declarationEnd = impt.declarationSourceEnd;
      //this.endPosition is just before the ;
      impt.declarationSourceStart = this.intStack[this.intPtr--];

      if(this.options.sourceLevel < ClassFileConstants.JDK1_5 &&
                  this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
            impt.modifiers = AccDefault; // convert the static import reference to a non-static importe reference
            this.problemReporter().invalidUsageOfStaticImports(impt);
      }
      
      // recovery
      if (this.currentElement != null){
            this.lastCheckPoint = impt.declarationSourceEnd+1;
            this.currentElement = this.currentElement.add(impt, 0);
            this.lastIgnoredToken = -1;
            this.restartRecovery = true; // used to avoid branching back into the regular automaton         
      }
}
protected void consumeSingleTypeImportDeclarationName() {
      // SingleTypeImportDeclarationName ::= 'import' Name
      /* push an ImportRef build from the last name 
      stored in the identifier stack. */

      ImportReference impt;
      int length;
      char[][] tokens = new char[length = this.identifierLengthStack[this.identifierLengthPtr--]][];
      this.identifierPtr -= length;
      long[] positions = new long[length];
      System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, 0, length);
      System.arraycopy(this.identifierPositionStack, this.identifierPtr + 1, positions, 0, length);
      pushOnAstStack(impt = new ImportReference(tokens, positions, false, AccDefault));

      if (this.currentToken == TokenNameSEMICOLON){
            impt.declarationSourceEnd = this.scanner.currentPosition - 1;
      } else {
            impt.declarationSourceEnd = impt.sourceEnd;
      }
      impt.declarationEnd = impt.declarationSourceEnd;
      //this.endPosition is just before the ;
      impt.declarationSourceStart = this.intStack[this.intPtr--];

      // recovery
      if (this.currentElement != null){
            this.lastCheckPoint = impt.declarationSourceEnd+1;
            this.currentElement = this.currentElement.add(impt, 0);
            this.lastIgnoredToken = -1;
            this.restartRecovery = true; // used to avoid branching back into the regular automaton         
      }
}
protected void consumeStatementBreak() {
      // BreakStatement ::= 'break' ';'
      // break pushs a position on this.intStack in case there is no label

      pushOnAstStack(new BreakStatement(null, this.intStack[this.intPtr--], this.endPosition));
}
protected void consumeStatementBreakWithLabel() {
      // BreakStatement ::= 'break' Identifier ';'
      // break pushs a position on this.intStack in case there is no label

      pushOnAstStack(
            new BreakStatement(
                  this.identifierStack[this.identifierPtr--],
                  this.intStack[this.intPtr--],
                  this.endPosition)); 
      this.identifierLengthPtr--;
}
protected void consumeStatementCatch() {
      // CatchClause ::= 'catch' '(' FormalParameter ')'    Block

      //catch are stored directly into the Try
      //has they always comes two by two....
      //we remove one entry from the astlengthPtr.
      //The construction of the try statement must
      //then fetch the catches using  2*i and 2*i + 1

      this.astLengthPtr--;
      this.listLength = 0; // reset formalParameter counter (incremented for catch variable)
}
protected void consumeStatementContinue() {
      // ContinueStatement ::= 'continue' ';'
      // continue pushs a position on this.intStack in case there is no label

      pushOnAstStack(
            new ContinueStatement(
                  null,
                  this.intStack[this.intPtr--],
                  this.endPosition));
}
protected void consumeStatementContinueWithLabel() {
      // ContinueStatement ::= 'continue' Identifier ';'
      // continue pushs a position on this.intStack in case there is no label

      pushOnAstStack(
            new ContinueStatement(
                  this.identifierStack[this.identifierPtr--], 
                  this.intStack[this.intPtr--], 
                  this.endPosition)); 
      this.identifierLengthPtr--;
}
protected void consumeStatementDo() {
      // DoStatement ::= 'do' Statement 'while' '(' Expression ')' ';'

      //the 'while' pushes a value on this.intStack that we need to remove
      this.intPtr--;

      Statement statement = (Statement) this.astStack[this.astPtr];
      this.expressionLengthPtr--;
      this.astStack[this.astPtr] = 
            new DoStatement(
                  this.expressionStack[this.expressionPtr--], 
                  statement, 
                  this.intStack[this.intPtr--], 
                  this.endPosition); 
}
protected void consumeStatementExpressionList() {
      // StatementExpressionList ::= StatementExpressionList ',' StatementExpression
      concatExpressionLists();
}
protected void consumeStatementFor() {
      // ForStatement ::= 'for' '(' ForInitopt ';' Expressionopt ';' ForUpdateopt ')' Statement
      // ForStatementNoShortIf ::= 'for' '(' ForInitopt ';' Expressionopt ';' ForUpdateopt ')' StatementNoShortIf

      int length;
      Expression cond = null;
      Statement[] inits, updates;
      boolean scope = true;

      //statements
      this.astLengthPtr--;
      Statement statement = (Statement) this.astStack[this.astPtr--];

      //updates are on the expresion stack
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) == 0) {
            updates = null;
      } else {
            this.expressionPtr -= length;
            System.arraycopy(
                  this.expressionStack, 
                  this.expressionPtr + 1, 
                  updates = new Statement[length], 
                  0, 
                  length); 
      }

      if (this.expressionLengthStack[this.expressionLengthPtr--] != 0)
            cond = this.expressionStack[this.expressionPtr--];

      //inits may be on two different stacks
      if ((length = this.astLengthStack[this.astLengthPtr--]) == 0) {
            inits = null;
            scope = false;
      } else {
            if (length == -1) { //on this.expressionStack
                  scope = false;
                  length = this.expressionLengthStack[this.expressionLengthPtr--];
                  this.expressionPtr -= length;
                  System.arraycopy(
                        this.expressionStack, 
                        this.expressionPtr + 1, 
                        inits = new Statement[length], 
                        0, 
                        length); 
            } else { //on this.astStack
                  this.astPtr -= length;
                  System.arraycopy(
                        this.astStack, 
                        this.astPtr + 1, 
                        inits = new Statement[length], 
                        0, 
                        length); 
            }
      }
      pushOnAstStack(
            new ForStatement(
                  inits, 
                  cond, 
                  updates, 
                  statement, 
                  scope, 
                  this.intStack[this.intPtr--], 
                  this.endStatementPosition)); 
}
protected void consumeStatementIfNoElse() {
      // IfThenStatement ::=  'if' '(' Expression ')' Statement

      //optimize the push/pop
      this.expressionLengthPtr--;
      Statement thenStatement = (Statement) this.astStack[this.astPtr];
      this.astStack[this.astPtr] = 
            new IfStatement(
                  this.expressionStack[this.expressionPtr--], 
                  thenStatement, 
                  this.intStack[this.intPtr--], 
                  this.endStatementPosition); 
}
protected void consumeStatementIfWithElse() {
      // IfThenElseStatement ::=  'if' '(' Expression ')' StatementNoShortIf 'else' Statement
      // IfThenElseStatementNoShortIf ::=  'if' '(' Expression ')' StatementNoShortIf 'else' StatementNoShortIf

      this.expressionLengthPtr--;

      // optimized {..., Then, Else } ==> {..., If }
      this.astLengthPtr--;

      //optimize the push/pop
      this.astStack[--this.astPtr] = 
            new IfStatement(
                  this.expressionStack[this.expressionPtr--], 
                  (Statement) this.astStack[this.astPtr], 
                  (Statement) this.astStack[this.astPtr + 1], 
                  this.intStack[this.intPtr--], 
                  this.endStatementPosition); 
}
protected void consumeStatementLabel() {
      // LabeledStatement ::= 'Identifier' ':' Statement
      // LabeledStatementNoShortIf ::= 'Identifier' ':' StatementNoShortIf

      //optimize push/pop
      Statement stmt = (Statement) this.astStack[this.astPtr];
      this.astStack[this.astPtr] = 
            new LabeledStatement(
                  this.identifierStack[this.identifierPtr], 
                  stmt, 
                  (int) (this.identifierPositionStack[this.identifierPtr--] >>> 32), 
                  this.endStatementPosition); 
      this.identifierLengthPtr--;
}
protected void consumeStatementReturn() {
      // ReturnStatement ::= 'return' Expressionopt ';'
      // return pushs a position on this.intStack in case there is no expression

      if (this.expressionLengthStack[this.expressionLengthPtr--] != 0) {
            pushOnAstStack(
                  new ReturnStatement(
                        this.expressionStack[this.expressionPtr--], 
                        this.intStack[this.intPtr--], 
                        this.endPosition)
            );
      } else {
            pushOnAstStack(new ReturnStatement(null, this.intStack[this.intPtr--], this.endPosition));
      }
}
protected void consumeStatementSwitch() {
      // SwitchStatement ::= 'switch' OpenBlock '(' Expression ')' SwitchBlock

      //OpenBlock just makes the semantic action blockStart()
      //the block is inlined but a scope need to be created
      //if some declaration occurs.

      int length;
      SwitchStatement switchStatement = new SwitchStatement();
      this.expressionLengthPtr--;
      switchStatement.expression = this.expressionStack[this.expressionPtr--];
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            this.astPtr -= length;
            System.arraycopy(
                  this.astStack, 
                  this.astPtr + 1, 
                  switchStatement.statements = new Statement[length], 
                  0, 
                  length); 
      }
      switchStatement.explicitDeclarations = this.realBlockStack[this.realBlockPtr--];
      pushOnAstStack(switchStatement);
      switchStatement.blockStart = this.intStack[this.intPtr--];
      switchStatement.sourceStart = this.intStack[this.intPtr--];
      switchStatement.sourceEnd = this.endStatementPosition;
      if (length == 0 && !containsComment(switchStatement.blockStart, switchStatement.sourceEnd)) {
            switchStatement.bits |= ASTNode.UndocumentedEmptyBlockMASK;
      }
}
protected void consumeStatementSynchronized() {
      // SynchronizedStatement ::= OnlySynchronized '(' Expression ')' Block
      //optimize the push/pop

      if (this.astLengthStack[this.astLengthPtr] == 0) {
            this.astLengthStack[this.astLengthPtr] = 1;
            this.expressionLengthPtr--;
            this.astStack[++this.astPtr] = 
                  new SynchronizedStatement(
                        this.expressionStack[this.expressionPtr--], 
                        null, 
                        this.intStack[this.intPtr--], 
                        this.endStatementPosition); 
      } else {
            this.expressionLengthPtr--;
            this.astStack[this.astPtr] = 
                  new SynchronizedStatement(
                        this.expressionStack[this.expressionPtr--], 
                        (Block) this.astStack[this.astPtr], 
                        this.intStack[this.intPtr--], 
                        this.endStatementPosition); 
      }
      resetModifiers();
}
protected void consumeStatementThrow() {
      // ThrowStatement ::= 'throw' Expression ';'
      this.expressionLengthPtr--;
      pushOnAstStack(new ThrowStatement(this.expressionStack[this.expressionPtr--], this.intStack[this.intPtr--]));
}
protected void consumeStatementTry(boolean withFinally) {
      //TryStatement ::= 'try'  Block Catches
      //TryStatement ::= 'try'  Block Catchesopt Finally

      int length;
      TryStatement tryStmt = new TryStatement();
      //finally
      if (withFinally) {
            this.astLengthPtr--;
            tryStmt.finallyBlock = (Block) this.astStack[this.astPtr--];
      }
      //catches are handle by two <argument-block> [see statementCatch]
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            if (length == 1) {
                  tryStmt.catchBlocks = new Block[] {(Block) this.astStack[this.astPtr--]};
                  tryStmt.catchArguments = new Argument[] {(Argument) this.astStack[this.astPtr--]};
            } else {
                  Block[] bks = (tryStmt.catchBlocks = new Block[length]);
                  Argument[] args = (tryStmt.catchArguments = new Argument[length]);
                  while (length-- > 0) {
                        bks[length] = (Block) this.astStack[this.astPtr--];
                        args[length] = (Argument) this.astStack[this.astPtr--];
                  }
            }
      }
      //try
      this.astLengthPtr--;
      tryStmt.tryBlock = (Block) this.astStack[this.astPtr--];

      //positions
      tryStmt.sourceEnd = this.endStatementPosition;
      tryStmt.sourceStart = this.intStack[this.intPtr--];
      pushOnAstStack(tryStmt);
}
protected void consumeStatementWhile() {
      // WhileStatement ::= 'while' '(' Expression ')' Statement
      // WhileStatementNoShortIf ::= 'while' '(' Expression ')' StatementNoShortIf

      this.expressionLengthPtr--;
      Statement statement = (Statement) this.astStack[this.astPtr];
      this.astStack[this.astPtr] = 
            new WhileStatement(
                  this.expressionStack[this.expressionPtr--], 
                  statement, 
                  this.intStack[this.intPtr--], 
                  this.endStatementPosition); 
}
protected void consumeStaticImportOnDemandDeclarationName() {
      // TypeImportOnDemandDeclarationName ::= 'import' 'static' Name '.' '*'
      /* push an ImportRef build from the last name 
      stored in the identifier stack. */

      ImportReference impt;
      int length;
      char[][] tokens = new char[length = this.identifierLengthStack[this.identifierLengthPtr--]][];
      this.identifierPtr -= length;
      long[] positions = new long[length];
      System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, 0, length);
      System.arraycopy(this.identifierPositionStack, this.identifierPtr + 1, positions, 0, length);
      pushOnAstStack(impt = new ImportReference(tokens, positions, true, AccStatic));

      this.modifiers = AccDefault;
      this.modifiersSourceStart = -1; // <-- see comment into modifiersFlag(int)
      
      if (this.currentToken == TokenNameSEMICOLON){
            impt.declarationSourceEnd = this.scanner.currentPosition - 1;
      } else {
            impt.declarationSourceEnd = impt.sourceEnd;
      }
      impt.declarationEnd = impt.declarationSourceEnd;
      //this.endPosition is just before the ;
      impt.declarationSourceStart = this.intStack[this.intPtr--];

      if(options.sourceLevel < ClassFileConstants.JDK1_5 &&
                  this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
            impt.modifiers = AccDefault; // convert the static import reference to a non-static importe reference
            this.problemReporter().invalidUsageOfStaticImports(impt);
      }
      
      // recovery
      if (this.currentElement != null){
            this.lastCheckPoint = impt.declarationSourceEnd+1;
            this.currentElement = this.currentElement.add(impt, 0);
            this.lastIgnoredToken = -1;
            this.restartRecovery = true; // used to avoid branching back into the regular automaton         
      }     
}
protected void consumeStaticInitializer() {
      // StaticInitializer ::=  StaticOnly Block
      //push an Initializer
      //optimize the push/pop
      Block block = (Block) this.astStack[this.astPtr];
      if (this.diet) block.bits &= ~ASTNode.UndocumentedEmptyBlockMASK; // clear bit set since was diet
      Initializer initializer = new Initializer(block, AccStatic);
      this.astStack[this.astPtr] = initializer;
      initializer.sourceEnd = this.endStatementPosition;    
      initializer.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
      this.nestedMethod[this.nestedType] --;
      initializer.declarationSourceStart = this.intStack[this.intPtr--];
      initializer.bodyStart = this.intStack[this.intPtr--];
      initializer.bodyEnd = this.endPosition;
      // doc comment
      initializer.javadoc = this.javadoc;
      this.javadoc = null;
      
      // recovery
      if (this.currentElement != null){
            this.lastCheckPoint = initializer.declarationSourceEnd;
            this.currentElement = this.currentElement.add(initializer, 0);
            this.lastIgnoredToken = -1;
      }
}
protected void consumeStaticOnly() {
      // StaticOnly ::= 'static'
      int savedModifiersSourceStart = this.modifiersSourceStart;
      checkComment(); // might update declaration source start
      if (this.modifiersSourceStart >= savedModifiersSourceStart) {
            this.modifiersSourceStart = savedModifiersSourceStart;
      }
      pushOnIntStack(this.scanner.currentPosition);
      pushOnIntStack(
            this.modifiersSourceStart >= 0 ? this.modifiersSourceStart : this.scanner.startPosition);
      jumpOverMethodBody();
      this.nestedMethod[this.nestedType]++;
      resetModifiers();
      this.expressionLengthPtr--; // remove the 0 pushed in consumeToken() for the static modifier

      // recovery
      if (this.currentElement != null){
            this.recoveredStaticInitializerStart = this.intStack[this.intPtr]; // remember start position only for static initializers
      }
}
protected void consumeSwitchBlock() {
      // SwitchBlock ::= '{' SwitchBlockStatements SwitchLabels '}'
      concatNodeLists();
}
protected void consumeSwitchBlockStatement() {
      // SwitchBlockStatement ::= SwitchLabels BlockStatements
      concatNodeLists();
}
protected void consumeSwitchBlockStatements() {
      // SwitchBlockStatements ::= SwitchBlockStatements SwitchBlockStatement
      concatNodeLists();
}
protected void consumeSwitchLabels() {
      // SwitchLabels ::= SwitchLabels SwitchLabel
      optimizedConcatNodeLists();
}
protected void consumeToken(int type) {
      /* remember the last consumed value */
      /* try to minimize the number of build values */
      checkNonExternalizedStringLiteral();
//    // clear the commentPtr of the scanner in case we read something different from a modifier
//    switch(type) {
//          case TokenNameabstract :
//          case TokenNamestrictfp :
//          case TokenNamefinal :
//          case TokenNamenative :
//          case TokenNameprivate :
//          case TokenNameprotected :
//          case TokenNamepublic :
//          case TokenNametransient :
//          case TokenNamevolatile :
//          case TokenNamestatic :
//          case TokenNamesynchronized :
//                break;
//          default:
//                this.scanner.commentPtr = -1;
//    }
      //System.out.println(this.scanner.toStringAction(type));
      switch (type) {
            case TokenNameIdentifier :
                  pushIdentifier();
                  if (this.scanner.useAssertAsAnIndentifier  &&
                              this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
                        long positions = this.identifierPositionStack[this.identifierPtr];
                        problemReporter().useAssertAsAnIdentifier((int) (positions >>> 32), (int) positions);
                  }
                  if (this.scanner.useEnumAsAnIndentifier  &&
                              this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
                        long positions = this.identifierPositionStack[this.identifierPtr];
                        problemReporter().useEnumAsAnIdentifier((int) (positions >>> 32), (int) positions);
                  }
                  break;
            case TokenNameinterface :
                  //'class' is pushing two int (positions) on the stack ==> 'interface' needs to do it too....
                  pushOnIntStack(this.scanner.currentPosition - 1);                 
                  pushOnIntStack(this.scanner.startPosition);
                  break;
            case TokenNameabstract :
                  checkAndSetModifiers(AccAbstract);
                  pushOnExpressionStackLengthStack(0);
                  break;
            case TokenNamestrictfp :
                  checkAndSetModifiers(AccStrictfp);
                  pushOnExpressionStackLengthStack(0);
                  break;
            case TokenNamefinal :
                  checkAndSetModifiers(AccFinal);
                  pushOnExpressionStackLengthStack(0);
                  break;
            case TokenNamenative :
                  checkAndSetModifiers(AccNative);
                  pushOnExpressionStackLengthStack(0);
                  break;
            case TokenNameprivate :
                  checkAndSetModifiers(AccPrivate);
                  pushOnExpressionStackLengthStack(0);
                  break;
            case TokenNameprotected :
                  checkAndSetModifiers(AccProtected);
                  pushOnExpressionStackLengthStack(0);
                  break;
            case TokenNamepublic :
                  checkAndSetModifiers(AccPublic);
                  pushOnExpressionStackLengthStack(0);
                  break;
            case TokenNametransient :
                  checkAndSetModifiers(AccTransient);
                  pushOnExpressionStackLengthStack(0);
                  break;
            case TokenNamevolatile :
                  checkAndSetModifiers(AccVolatile);
                  pushOnExpressionStackLengthStack(0);
                  break;
            case TokenNamestatic :
                  checkAndSetModifiers(AccStatic);
                  pushOnExpressionStackLengthStack(0);
                  break;
            case TokenNamesynchronized :
                  this.synchronizedBlockSourceStart = this.scanner.startPosition;   
                  checkAndSetModifiers(AccSynchronized);
                  pushOnExpressionStackLengthStack(0);
                  break;
                  //==============================
            case TokenNamevoid :
                  pushIdentifier(-T_void);
                  pushOnIntStack(this.scanner.currentPosition - 1);                       
                  pushOnIntStack(this.scanner.startPosition);
                  break;
                  //push a default dimension while void is not part of the primitive
                  //declaration baseType and so takes the place of a type without getting into
                  //regular type parsing that generates a dimension on this.intStack
            case TokenNameboolean :
                  pushIdentifier(-T_boolean);
                  pushOnIntStack(this.scanner.currentPosition - 1);                       
                  pushOnIntStack(this.scanner.startPosition);           
                  break;
            case TokenNamebyte :
                  pushIdentifier(-T_byte);
                  pushOnIntStack(this.scanner.currentPosition - 1);                       
                  pushOnIntStack(this.scanner.startPosition);                             
                  break;
            case TokenNamechar :
                  pushIdentifier(-T_char);
                  pushOnIntStack(this.scanner.currentPosition - 1);                       
                  pushOnIntStack(this.scanner.startPosition);                             
                  break;
            case TokenNamedouble :
                  pushIdentifier(-T_double);
                  pushOnIntStack(this.scanner.currentPosition - 1);                       
                  pushOnIntStack(this.scanner.startPosition);                             
                  break;
            case TokenNamefloat :
                  pushIdentifier(-T_float);
                  pushOnIntStack(this.scanner.currentPosition - 1);                       
                  pushOnIntStack(this.scanner.startPosition);                             
                  break;
            case TokenNameint :
                  pushIdentifier(-T_int);
                  pushOnIntStack(this.scanner.currentPosition - 1);                       
                  pushOnIntStack(this.scanner.startPosition);                             
                  break;
            case TokenNamelong :
                  pushIdentifier(-T_long);
                  pushOnIntStack(this.scanner.currentPosition - 1);                       
                  pushOnIntStack(this.scanner.startPosition);                             
                  break;
            case TokenNameshort :
                  pushIdentifier(-T_short);
                  pushOnIntStack(this.scanner.currentPosition - 1);                       
                  pushOnIntStack(this.scanner.startPosition);                             
                  break;
                  //==============================
            case TokenNameIntegerLiteral :
                  pushOnExpressionStack(
                        new IntLiteral(
                              this.scanner.getCurrentTokenSource(), 
                              this.scanner.startPosition, 
                              this.scanner.currentPosition - 1)); 
                  break;
            case TokenNameLongLiteral :
                  pushOnExpressionStack(
                        new LongLiteral(
                              this.scanner.getCurrentTokenSource(), 
                              this.scanner.startPosition, 
                              this.scanner.currentPosition - 1)); 
                  break;
            case TokenNameFloatingPointLiteral :
                  pushOnExpressionStack(
                        new FloatLiteral(
                              this.scanner.getCurrentTokenSource(), 
                              this.scanner.startPosition, 
                              this.scanner.currentPosition - 1)); 
                  break;
            case TokenNameDoubleLiteral :
                  pushOnExpressionStack(
                        new DoubleLiteral(
                              this.scanner.getCurrentTokenSource(), 
                              this.scanner.startPosition, 
                              this.scanner.currentPosition - 1)); 
                  break;
            case TokenNameCharacterLiteral :
                  pushOnExpressionStack(
                        new CharLiteral(
                              this.scanner.getCurrentTokenSource(), 
                              this.scanner.startPosition, 
                              this.scanner.currentPosition - 1)); 
                  break;
            case TokenNameStringLiteral :
                  StringLiteral stringLiteral = new StringLiteral(
                              this.scanner.getCurrentTokenSourceString(), 
                              this.scanner.startPosition, 
                              this.scanner.currentPosition - 1); 
                  pushOnExpressionStack(stringLiteral); 
                  break;
            case TokenNamefalse :
                  pushOnExpressionStack(
                        new FalseLiteral(this.scanner.startPosition, this.scanner.currentPosition - 1)); 
                  break;
            case TokenNametrue :
                  pushOnExpressionStack(
                        new TrueLiteral(this.scanner.startPosition, this.scanner.currentPosition - 1)); 
                  break;
            case TokenNamenull :
                  pushOnExpressionStack(
                        new NullLiteral(this.scanner.startPosition, this.scanner.currentPosition - 1)); 
                  break;
                  //============================
            case TokenNamesuper :
            case TokenNamethis :
                  this.endPosition = this.scanner.currentPosition - 1;
                  pushOnIntStack(this.scanner.startPosition);
                  break;
            case TokenNameassert :
            case TokenNameimport :
            case TokenNamepackage :
            case TokenNamethrow :
            case TokenNamedo :
            case TokenNameif :
            case TokenNamefor :
            case TokenNameswitch :
            case TokenNametry :
            case TokenNamewhile :
            case TokenNamebreak :
            case TokenNamecontinue :
            case TokenNamereturn :
            case TokenNamecase :
                  pushOnIntStack(this.scanner.startPosition);
                  break;
            case TokenNamenew :
                  // https://bugs.eclipse.org/bugs/show_bug.cgi?id=40954
                  resetModifiers();
                  pushOnIntStack(this.scanner.startPosition);
                  break;
            case TokenNameclass :
                  pushOnIntStack(this.scanner.currentPosition - 1);
                  pushOnIntStack(this.scanner.startPosition);
                  break;
            case TokenNameenum :
                  pushOnIntStack(this.scanner.currentPosition - 1);
                  pushOnIntStack(this.scanner.startPosition);
                  break;
            case TokenNamedefault :
                  pushOnIntStack(this.scanner.startPosition);
                  pushOnIntStack(this.scanner.currentPosition - 1);
                  break;
                  //let extra semantic action decide when to push
            case TokenNameRBRACKET :
                  this.endPosition = this.scanner.startPosition;
                  this.endStatementPosition = this.scanner.currentPosition - 1;
                  break;
            case TokenNameLBRACE :
                  this.endStatementPosition = this.scanner.currentPosition - 1;
            case TokenNamePLUS :
            case TokenNameMINUS :
            case TokenNameNOT :
            case TokenNameTWIDDLE :
                  this.endPosition = this.scanner.startPosition;
                  break;
            case TokenNamePLUS_PLUS :
            case TokenNameMINUS_MINUS :
                  this.endPosition = this.scanner.startPosition;
                  this.endStatementPosition = this.scanner.currentPosition - 1;
                  break;
            case TokenNameRBRACE:
            case TokenNameSEMICOLON :
                  this.endStatementPosition = this.scanner.currentPosition - 1;
                  this.endPosition = this.scanner.startPosition - 1; 
                  //the item is not part of the potential futur expression/statement
                  break;
            case TokenNameRPAREN :
                  // in order to handle ( expression) ////// (cast)expression///// foo(x)
                  this.rParenPos = this.scanner.currentPosition - 1; // position of the end of right parenthesis (in case of unicode \u0029) lex00101
                  break;
            case TokenNameLPAREN :
                  this.lParenPos = this.scanner.startPosition;
                  break;
            case TokenNameAT :
                  pushOnIntStack(this.scanner.startPosition);
                  break;
            case TokenNameQUESTION  :
                  pushOnIntStack(this.scanner.startPosition);
                  pushOnIntStack(this.scanner.currentPosition - 1);
                  break;
            case TokenNameLESS :
                  pushOnIntStack(this.scanner.startPosition);
                  break;
            case TokenNameELLIPSIS :
                  pushOnIntStack(this.scanner.currentPosition - 1);
                  break;                  
                  //  case TokenNameCOMMA :
                  //  case TokenNameCOLON  :
                  //  case TokenNameEQUAL  :
                  //  case TokenNameLBRACKET  :
                  //  case TokenNameDOT :
                  //  case TokenNameERROR :
                  //  case TokenNameEOF  :
                  //  case TokenNamecase  :
                  //  case TokenNamecatch  :
                  //  case TokenNameelse  :
                  //  case TokenNameextends  :
                  //  case TokenNamefinally  :
                  //  case TokenNameimplements  :
                  //  case TokenNamethrows  :
                  //  case TokenNameinstanceof  :
                  //  case TokenNameEQUAL_EQUAL  :
                  //  case TokenNameLESS_EQUAL  :
                  //  case TokenNameGREATER_EQUAL  :
                  //  case TokenNameNOT_EQUAL  :
                  //  case TokenNameLEFT_SHIFT  :
                  //  case TokenNameRIGHT_SHIFT  :
                  //  case TokenNameUNSIGNED_RIGHT_SHIFT :
                  //  case TokenNamePLUS_EQUAL  :
                  //  case TokenNameMINUS_EQUAL  :
                  //  case TokenNameMULTIPLY_EQUAL  :
                  //  case TokenNameDIVIDE_EQUAL  :
                  //  case TokenNameAND_EQUAL  :
                  //  case TokenNameOR_EQUAL  :
                  //  case TokenNameXOR_EQUAL  :
                  //  case TokenNameREMAINDER_EQUAL  :
                  //  case TokenNameLEFT_SHIFT_EQUAL  :
                  //  case TokenNameRIGHT_SHIFT_EQUAL  :
                  //  case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL  :
                  //  case TokenNameOR_OR  :
                  //  case TokenNameAND_AND  :
                  //  case TokenNameREMAINDER :
                  //  case TokenNameXOR  :
                  //  case TokenNameAND  :
                  //  case TokenNameMULTIPLY :
                  //  case TokenNameOR  :
                  //  case TokenNameDIVIDE :
                  //  case TokenNameGREATER  :
      }
}
protected void consumeTypeArgument() {
      pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));    
}
protected void consumeTypeArgumentList() {
      concatGenericsLists();
}
protected void consumeTypeArgumentList1() {
      concatGenericsLists();
}
protected void consumeTypeArgumentList2() {
      concatGenericsLists();
}
protected void consumeTypeArgumentList3() {
      concatGenericsLists();
}
protected void consumeTypeArgumentReferenceType1() {
      concatGenericsLists();
      pushOnGenericsStack(getTypeReference(0)); 
      intPtr--;
}
protected void consumeTypeArgumentReferenceType2() {
      concatGenericsLists();
      pushOnGenericsStack(getTypeReference(0)); 
      intPtr--;
}
protected void consumeTypeArguments() {
      concatGenericsLists();
      intPtr--;

      if(options.sourceLevel < ClassFileConstants.JDK1_5 &&
                  this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
            int length = this.genericsLengthStack[this.genericsLengthPtr];
            this.problemReporter().invalidUsageOfTypeArguments(
                  (TypeReference)this.genericsStack[this.genericsPtr - length + 1],
                  (TypeReference)this.genericsStack[this.genericsPtr]);
      }
}
protected void consumeTypeDeclarations() {
      // TypeDeclarations ::= TypeDeclarations TypeDeclaration
      concatNodeLists();
}
protected void consumeTypeImportOnDemandDeclarationName() {
      // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
      /* push an ImportRef build from the last name 
      stored in the identifier stack. */

      ImportReference impt;
      int length;
      char[][] tokens = new char[length = this.identifierLengthStack[this.identifierLengthPtr--]][];
      this.identifierPtr -= length;
      long[] positions = new long[length];
      System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, 0, length);
      System.arraycopy(this.identifierPositionStack, this.identifierPtr + 1, positions, 0, length);
      pushOnAstStack(impt = new ImportReference(tokens, positions, true, AccDefault));

      if (this.currentToken == TokenNameSEMICOLON){
            impt.declarationSourceEnd = this.scanner.currentPosition - 1;
      } else {
            impt.declarationSourceEnd = impt.sourceEnd;
      }
      impt.declarationEnd = impt.declarationSourceEnd;
      //this.endPosition is just before the ;
      impt.declarationSourceStart = this.intStack[this.intPtr--];

      // recovery
      if (this.currentElement != null){
            this.lastCheckPoint = impt.declarationSourceEnd+1;
            this.currentElement = this.currentElement.add(impt, 0);
            this.lastIgnoredToken = -1;
            this.restartRecovery = true; // used to avoid branching back into the regular automaton         
      }     
}
protected void consumeTypeParameterHeader() {
      //TypeParameterHeader ::= Identifier
      TypeParameter typeParameter = new TypeParameter();
      long pos = this.identifierPositionStack[this.identifierPtr];
      final int end = (int) pos;
      typeParameter.declarationSourceEnd = end;
      typeParameter.sourceEnd = end;
      final int start = (int) (pos >>> 32);
      typeParameter.declarationSourceStart = start;
      typeParameter.sourceStart = start;
      typeParameter.name = this.identifierStack[this.identifierPtr--];
      this.identifierLengthPtr--;
      pushOnGenericsStack(typeParameter);
      
      this.listTypeParameterLength++;
}
protected void consumeTypeParameter1() {
      // nothing to do
}
protected void consumeTypeParameter1WithExtends() {
      //TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType1
      TypeReference superType = (TypeReference) this.genericsStack[this.genericsPtr--];
      this.genericsLengthPtr--;
      TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
      typeParameter.declarationSourceEnd = superType.sourceEnd;
      typeParameter.type = superType;
      superType.bits |= ASTNode.IsSuperType;
      this.genericsStack[this.genericsPtr] = typeParameter;
}
protected void consumeTypeParameter1WithExtendsAndBounds() {
      //TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList1
      int additionalBoundsLength = this.genericsLengthStack[this.genericsLengthPtr--];
      TypeReference[] bounds = new TypeReference[additionalBoundsLength];
      this.genericsPtr -= additionalBoundsLength;
      System.arraycopy(this.genericsStack, this.genericsPtr + 1, bounds, 0, additionalBoundsLength);
      TypeReference superType = getTypeReference(this.intStack[this.intPtr--]);
      TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
      typeParameter.declarationSourceEnd = bounds[additionalBoundsLength - 1].sourceEnd;
      typeParameter.type = superType;
      superType.bits |= ASTNode.IsSuperType;    
      typeParameter.bounds = bounds;
      for (int i = 0, max = bounds.length; i < max; i++) {
            bounds[i].bits |= ASTNode.IsSuperType;
      }     
}
protected void consumeTypeParameterList() {
      //TypeParameterList ::= TypeParameterList ',' TypeParameter
      concatGenericsLists();
}
protected void consumeTypeParameterList1() {
      //TypeParameterList1 ::= TypeParameterList ',' TypeParameter1
      concatGenericsLists();
}
protected void consumeTypeParameters() {
      intPtr--;
      if(options.sourceLevel < ClassFileConstants.JDK1_5&&
                  this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
            int length = this.genericsLengthStack[this.genericsLengthPtr];
            this.problemReporter().invalidUsageOfTypeParameters(
                  (TypeParameter) this.genericsStack[genericsPtr - length + 1],
                  (TypeParameter) this.genericsStack[genericsPtr]);
      }
}
protected void consumeTypeParameterWithExtends() {
      //TypeParameter ::= TypeParameterHeader 'extends' ReferenceType
      TypeReference superType = getTypeReference(this.intStack[this.intPtr--]);
      TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
      typeParameter.declarationSourceEnd = superType.sourceEnd;
      typeParameter.type = superType;
      superType.bits |= ASTNode.IsSuperType;
}
protected void consumeTypeParameterWithExtendsAndBounds() {
      //TypeParameter ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList
      int additionalBoundsLength = this.genericsLengthStack[this.genericsLengthPtr--];
      TypeReference[] bounds = new TypeReference[additionalBoundsLength];
      this.genericsPtr -= additionalBoundsLength;
      System.arraycopy(this.genericsStack, this.genericsPtr + 1, bounds, 0, additionalBoundsLength);
      TypeReference superType = getTypeReference(this.intStack[this.intPtr--]);
      TypeParameter typeParameter = (TypeParameter) this.genericsStack[this.genericsPtr];
      typeParameter.type = superType;
      superType.bits |= ASTNode.IsSuperType;
      typeParameter.bounds = bounds;
      typeParameter.declarationSourceEnd = bounds[additionalBoundsLength - 1].sourceEnd;
      for (int i = 0, max = bounds.length; i < max; i++) {
            bounds[i].bits |= ASTNode.IsSuperType;
      }           
}
protected void consumeUnaryExpression(int op) {
      // UnaryExpression ::= '+' PushPosition UnaryExpression
      // UnaryExpression ::= '-' PushPosition UnaryExpression
      // UnaryExpressionNotPlusMinus ::= '~' PushPosition UnaryExpression
      // UnaryExpressionNotPlusMinus ::= '!' PushPosition UnaryExpression

      //optimize the push/pop

      //handle manually the -2147483648 while it is not a real
      //computation of an - and 2147483648 (notice that 2147483648
      //is Integer.MAX_VALUE+1.....)
      //Same for -9223372036854775808L ............

      //this.intStack have the position of the operator

      Expression r, exp = this.expressionStack[this.expressionPtr];
      if (op == MINUS) {
            if ((exp instanceof IntLiteral) && (((IntLiteral) exp).mayRepresentMIN_VALUE())) {
                  r = this.expressionStack[this.expressionPtr] = new IntLiteralMinValue();
            } else {
                  if ((exp instanceof LongLiteral) && (((LongLiteral) exp).mayRepresentMIN_VALUE())) {
                        r = this.expressionStack[this.expressionPtr] = new LongLiteralMinValue();
                  } else {
                        r = this.expressionStack[this.expressionPtr] = new UnaryExpression(exp, op);
                  }
            }
      } else {
            r = this.expressionStack[this.expressionPtr] = new UnaryExpression(exp, op);
      }
      r.sourceStart = this.intStack[this.intPtr--];
      r.sourceEnd = exp.sourceEnd;
}
protected void consumeUnaryExpression(int op, boolean post) {
      // PreIncrementExpression ::= '++' PushPosition UnaryExpression
      // PreDecrementExpression ::= '--' PushPosition UnaryExpression

      // ++ and -- operators
      //optimize the push/pop

      //this.intStack has the position of the operator when prefix

      Expression leftHandSide = this.expressionStack[this.expressionPtr];
      if (leftHandSide instanceof Reference) {
            // ++foo()++ is unvalid 
            if (post) {
                  this.expressionStack[this.expressionPtr] = 
                        new PostfixExpression(
                              leftHandSide,
                              IntLiteral.One,
                              op,
                              this.endStatementPosition); 
            } else {
                  this.expressionStack[this.expressionPtr] = 
                        new PrefixExpression(
                              leftHandSide,
                              IntLiteral.One,
                              op,
                              this.intStack[this.intPtr--]); 
            }
      } else {
            //the ++ or the -- is NOT taken into account if code gen proceeds
            if (!post) {
                  this.intPtr--;
            }
            problemReporter().invalidUnaryExpression(leftHandSide);
      }
}
protected void consumeVariableDeclarators() {
      // VariableDeclarators ::= VariableDeclarators ',' VariableDeclarator
      optimizedConcatNodeLists();
}
protected void consumeVariableInitializers() {
      // VariableInitializers ::= VariableInitializers ',' VariableInitializer
      concatExpressionLists();
}
protected void consumeWildcard() {
      final Wildcard wildcard = new Wildcard(Wildcard.UNBOUND);
      wildcard.sourceEnd = this.intStack[this.intPtr--];
      wildcard.sourceStart = this.intStack[this.intPtr--];
      pushOnGenericsStack(wildcard);
}
protected void consumeWildcard1() {
      final Wildcard wildcard = new Wildcard(Wildcard.UNBOUND);
      wildcard.sourceEnd = this.intStack[this.intPtr--];
      wildcard.sourceStart = this.intStack[this.intPtr--];
      pushOnGenericsStack(wildcard);
}
protected void consumeWildcard1WithBounds() {
      // Nothing to do
      // The wildcard is created by the consumeWildcardBounds1Extends or by consumeWildcardBounds1Super
}
protected void consumeWildcard2() {
      final Wildcard wildcard = new Wildcard(Wildcard.UNBOUND);
      wildcard.sourceEnd = this.intStack[this.intPtr--];
      wildcard.sourceStart = this.intStack[this.intPtr--];
      pushOnGenericsStack(wildcard);
}
protected void consumeWildcard2WithBounds() {
      // Nothing to do
      // The wildcard is created by the consumeWildcardBounds2Extends or by consumeWildcardBounds2Super
}
protected void consumeWildcard3() {
      final Wildcard wildcard = new Wildcard(Wildcard.UNBOUND);
      wildcard.sourceEnd = this.intStack[this.intPtr--];
      wildcard.sourceStart = this.intStack[this.intPtr--];
      pushOnGenericsStack(wildcard);
}
protected void consumeWildcard3WithBounds() {
      // Nothing to do
      // The wildcard is created by the consumeWildcardBounds3Extends or by consumeWildcardBounds3Super
}
protected void consumeWildcardBounds1Extends() {
      Wildcard wildcard = new Wildcard(Wildcard.EXTENDS);
      wildcard.bound = (TypeReference) this.genericsStack[this.genericsPtr];
      wildcard.sourceEnd = wildcard.bound.sourceEnd;
      this.intPtr--; // remove end position of the '?'
      wildcard.sourceStart = this.intStack[this.intPtr--];
      this.genericsStack[this.genericsPtr] = wildcard;
}
protected void consumeWildcardBounds1Super() {
      Wildcard wildcard = new Wildcard(Wildcard.SUPER);
      wildcard.bound = (TypeReference) this.genericsStack[this.genericsPtr];
      this.intPtr--; // remove the starting position of the super keyword
      wildcard.sourceEnd = wildcard.bound.sourceEnd;
      this.intPtr--; // remove end position of the '?'
      wildcard.sourceStart = this.intStack[this.intPtr--];
      this.genericsStack[this.genericsPtr] = wildcard;
}
protected void consumeWildcardBounds2Extends() {
      Wildcard wildcard = new Wildcard(Wildcard.EXTENDS);
      wildcard.bound = (TypeReference) this.genericsStack[this.genericsPtr];
      wildcard.sourceEnd = wildcard.bound.sourceEnd;
      this.intPtr--; // remove end position of the '?'
      wildcard.sourceStart = this.intStack[this.intPtr--];
      this.genericsStack[this.genericsPtr] = wildcard;
}
protected void consumeWildcardBounds2Super() {
      Wildcard wildcard = new Wildcard(Wildcard.SUPER);
      wildcard.bound = (TypeReference) this.genericsStack[this.genericsPtr];
      this.intPtr--; // remove the starting position of the super keyword
      wildcard.sourceEnd = wildcard.bound.sourceEnd;
      this.intPtr--; // remove end position of the '?'
      wildcard.sourceStart = this.intStack[this.intPtr--];
      this.genericsStack[this.genericsPtr] = wildcard;
}
protected void consumeWildcardBounds3Extends() {
      Wildcard wildcard = new Wildcard(Wildcard.EXTENDS);
      wildcard.bound = (TypeReference) this.genericsStack[this.genericsPtr];
      wildcard.sourceEnd = wildcard.bound.sourceEnd;
      this.intPtr--; // remove end position of the '?'
      wildcard.sourceStart = this.intStack[this.intPtr--];
      this.genericsStack[this.genericsPtr] = wildcard;
}
protected void consumeWildcardBounds3Super() {
      Wildcard wildcard = new Wildcard(Wildcard.SUPER);
      wildcard.bound = (TypeReference) this.genericsStack[this.genericsPtr];
      this.intPtr--; // remove the starting position of the super keyword
      wildcard.sourceEnd = wildcard.bound.sourceEnd;
      this.intPtr--; // remove end position of the '?'
      wildcard.sourceStart = this.intStack[this.intPtr--];
      this.genericsStack[this.genericsPtr] = wildcard;
}
protected void consumeWildcardBoundsExtends() {
      Wildcard wildcard = new Wildcard(Wildcard.EXTENDS);
      wildcard.bound = getTypeReference(this.intStack[this.intPtr--]);
      wildcard.sourceEnd = wildcard.bound.sourceEnd;
      this.intPtr--; // remove end position of the '?'
      wildcard.sourceStart = this.intStack[this.intPtr--];
      pushOnGenericsStack(wildcard);
}
protected void consumeWildcardBoundsSuper() {
      Wildcard wildcard = new Wildcard(Wildcard.SUPER);
      wildcard.bound = getTypeReference(this.intStack[this.intPtr--]);
      this.intPtr--; // remove the starting position of the super keyword
      wildcard.sourceEnd = wildcard.bound.sourceEnd;
      this.intPtr--; // remove end position of the '?'
      wildcard.sourceStart = this.intStack[this.intPtr--];
      pushOnGenericsStack(wildcard);
}
protected void consumeWildcardWithBounds() {
      // Nothing to do
      // The wildcard is created by the consumeWildcardBoundsExtends or by consumeWildcardBoundsSuper
}
/**
 * Given the current comment stack, answer whether some comment is available in a certain exclusive range
 * 
 * @param sourceStart int
 * @param sourceEnd int
 * @return boolean
 */
public boolean containsComment(int sourceStart, int sourceEnd) {
      int iComment = this.scanner.commentPtr;
      for (; iComment >= 0; iComment--) {
            int commentStart = this.scanner.commentStarts[iComment];
            // ignore comments before start
            if (commentStart < sourceStart) continue;
            // ignore comments after end
            if (commentStart > sourceEnd) continue;
            return true;
      }
      return false;
}
public MethodDeclaration convertToMethodDeclaration(ConstructorDeclaration c, CompilationResult compilationResult) {
      MethodDeclaration m = new MethodDeclaration(compilationResult);
      m.typeParameters = c.typeParameters;
      m.sourceStart = c.sourceStart;
      m.sourceEnd = c.sourceEnd;
      m.bodyStart = c.bodyStart;
      m.bodyEnd = c.bodyEnd;
      m.declarationSourceEnd = c.declarationSourceEnd;
      m.declarationSourceStart = c.declarationSourceStart;
      m.selector = c.selector;
      m.statements = c.statements;
      m.modifiers = c.modifiers;
      m.annotations = c.annotations;
      m.arguments = c.arguments;
      m.thrownExceptions = c.thrownExceptions;
      m.explicitDeclarations = c.explicitDeclarations;
      m.returnType = null;
      m.javadoc = c.javadoc;
      return m;
}
protected TypeReference copyDims(TypeReference typeRef, int dim) {
      return typeRef.copyDims(dim);
}
protected FieldDeclaration createFieldDeclaration(char[] fieldDeclarationName, int sourceStart, int sourceEnd) {
      return new FieldDeclaration(fieldDeclarationName, sourceStart, sourceEnd);
}

protected LocalDeclaration createLocalDeclaration(char[] localDeclarationName, int sourceStart, int sourceEnd) {
      return new LocalDeclaration(localDeclarationName, sourceStart, sourceEnd);
}
protected RecoveredType currentRecoveryType() {
      if(this.currentElement != null) {
            if(this.currentElement instanceof RecoveredType) {
                  return (RecoveredType) this.currentElement;
            } else {
                  return this.currentElement.enclosingType();
            }
      }
      return null;
}
public CompilationUnitDeclaration dietParse(ICompilationUnit sourceUnit, CompilationResult compilationResult) {

      CompilationUnitDeclaration parsedUnit;
      boolean old = this.diet;
      try {
            this.diet = true;
            parsedUnit = parse(sourceUnit, compilationResult);
      }
      finally {
            this.diet = old;
      }
      return parsedUnit;
}
protected void dispatchDeclarationInto(int length) {
      /* they are length on this.astStack that should go into
         methods fields constructors lists of the typeDecl

         Return if there is a constructor declaration in the methods declaration */
         
      
      // Looks for the size of each array . 

      if (length == 0)
            return;
      int[] flag = new int[length + 1]; //plus one -- see <HERE>
      int size1 = 0, size2 = 0, size3 = 0;
      boolean hasAbstractMethods = false;
      for (int i = length - 1; i >= 0; i--) {
            ASTNode astNode = this.astStack[this.astPtr--];
            if (astNode instanceof AbstractMethodDeclaration) {
                  //methods and constructors have been regrouped into one single list
                  flag[i] = 2;
                  size2++;
                  if (((AbstractMethodDeclaration) astNode).isAbstract()) {
                        hasAbstractMethods = true;
                  }
            } else if (astNode instanceof TypeDeclaration) {
                  flag[i] = 3;
                  size3++;
            } else {
                  //field
                  flag[i] = 1;
                  size1++;
            }
      }

      //arrays creation
      TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
      if (size1 != 0) {
            typeDecl.fields = new FieldDeclaration[size1];
      }
      if (size2 != 0) {
            typeDecl.methods = new AbstractMethodDeclaration[size2];
            if (hasAbstractMethods) typeDecl.bits |= ASTNode.HasAbstractMethods;
      }
      if (size3 != 0) {
            typeDecl.memberTypes = new TypeDeclaration[size3];
      }

      //arrays fill up
      size1 = size2 = size3 = 0;
      int flagI = flag[0], start = 0;
      int length2;
      for (int end = 0; end <= length; end++) //<HERE> the plus one allows to 
            {
            if (flagI != flag[end]) //treat the last element as a ended flag.....
                  { //array copy
                  switch (flagI) {
                        case 1 :
                              size1 += (length2 = end - start);
                              System.arraycopy(
                                    this.astStack, 
                                    this.astPtr + start + 1, 
                                    typeDecl.fields, 
                                    size1 - length2, 
                                    length2); 
                              break;
                        case 2 :
                              size2 += (length2 = end - start);
                              System.arraycopy(
                                    this.astStack, 
                                    this.astPtr + start + 1, 
                                    typeDecl.methods, 
                                    size2 - length2, 
                                    length2); 
                              break;
                        case 3 :
                              size3 += (length2 = end - start);
                              System.arraycopy(
                                    this.astStack, 
                                    this.astPtr + start + 1, 
                                    typeDecl.memberTypes, 
                                    size3 - length2, 
                                    length2); 
                              break;
                  }
                  flagI = flag[start = end];
            }
      }

      if (typeDecl.memberTypes != null) {
            for (int i = typeDecl.memberTypes.length - 1; i >= 0; i--) {
                  typeDecl.memberTypes[i].enclosingType = typeDecl;
            }
      }
}
protected void dispatchDeclarationIntoEnumDeclaration(int length) {
      
      if (length == 0)
      return;
   int[] flag = new int[length + 1]; //plus one -- see <HERE>
   int size1 = 0, size2 = 0, size3 = 0;
   TypeDeclaration enumDeclaration = (TypeDeclaration) this.astStack[this.astPtr - length];
   boolean hasAbstractMethods = false;
   for (int i = length - 1; i >= 0; i--) {
      ASTNode astNode = this.astStack[this.astPtr--];
      if (astNode instanceof AbstractMethodDeclaration) {
         //methods and constructors have been regrouped into one single list
         flag[i] = 2;
         size2++;
            if (((AbstractMethodDeclaration) astNode).isAbstract()) {
                  hasAbstractMethods = true;
            }         
      } else if (astNode instanceof TypeDeclaration) {
         flag[i] = 3;
         size3++;
      } else if (astNode instanceof FieldDeclaration) {
         flag[i] = 1;
         size1++;
//         if(astNode instanceof EnumConstant) {
//            EnumConstant constant = (EnumConstant) astNode;
//            ((AllocationExpression)constant.initialization).type = new SingleTypeReference(enumDeclaration.name,
//                  (((long) enumDeclaration.sourceStart) << 32) + enumDeclaration.sourceEnd);
//         }
      }
   }
 
   //arrays creation
   if (size1 != 0) {
      enumDeclaration.fields = new FieldDeclaration[size1];
   }
   if (size2 != 0) {
      enumDeclaration.methods = new AbstractMethodDeclaration[size2];
      if (hasAbstractMethods) enumDeclaration.bits |= ASTNode.HasAbstractMethods;
   }
   if (size3 != 0) {
      enumDeclaration.memberTypes = new TypeDeclaration[size3];
   }
 
   //arrays fill up
   size1 = size2 = size3 = 0;
   int flagI = flag[0], start = 0;
   int length2;
   for (int end = 0; end <= length; end++) //<HERE> the plus one allows to 
      {
      if (flagI != flag[end]) //treat the last element as a ended flag.....
         { //array copy
         switch (flagI) {
            case 1 :
               size1 += (length2 = end - start);
               System.arraycopy(
                  this.astStack, 
                  this.astPtr + start + 1, 
                  enumDeclaration.fields, 
                  size1 - length2, 
                  length2); 
               break;
            case 2 :
               size2 += (length2 = end - start);
               System.arraycopy(
                  this.astStack, 
                  this.astPtr + start + 1, 
                  enumDeclaration.methods, 
                  size2 - length2, 
                  length2); 
               break;
            case 3 :
               size3 += (length2 = end - start);
               System.arraycopy(
                  this.astStack, 
                  this.astPtr + start + 1, 
                  enumDeclaration.memberTypes, 
                  size3 - length2, 
                  length2); 
               break;
         }
         flagI = flag[start = end];
      }
   }
 
   if (enumDeclaration.memberTypes != null) {
      for (int i = enumDeclaration.memberTypes.length - 1; i >= 0; i--) {
         enumDeclaration.memberTypes[i].enclosingType = enumDeclaration;
      }
   }}
protected CompilationUnitDeclaration endParse(int act) {

      this.lastAct = act;

      if (this.currentElement != null){
            this.currentElement.topElement().updateParseTree();
            if (VERBOSE_RECOVERY){
                  System.out.print(Messages.parser_syntaxRecovery); 
                  System.out.println("--------------------------");            //$NON-NLS-1$
                  System.out.println(this.compilationUnit);       
                  System.out.println("----------------------------------"); //$NON-NLS-1$
            }           
      } else {
            if (this.diet & VERBOSE_RECOVERY){
                  System.out.print(Messages.parser_regularParse); 
                  System.out.println("--------------------------");      //$NON-NLS-1$
                  System.out.println(this.compilationUnit);       
                  System.out.println("----------------------------------"); //$NON-NLS-1$
            }
      }
      persistLineSeparatorPositions();
      for (int i = 0; i < this.scanner.foundTaskCount; i++){
            problemReporter().task(
                  new String(this.scanner.foundTaskTags[i]), 
                  new String(this.scanner.foundTaskMessages[i]),
                  this.scanner.foundTaskPriorities[i] == null ? null : new String(this.scanner.foundTaskPriorities[i]), 
                  this.scanner.foundTaskPositions[i][0], 
                  this.scanner.foundTaskPositions[i][1]);
      }
      return this.compilationUnit;
}
/*
 * Flush comments defined prior to a given positions.
 *
 * Note: comments are stacked in syntactical order
 *
 * Either answer given <position>, or the end position of a comment line 
 * immediately following the <position> (same line)
 *
 * e.g.
 * void foo(){
 * } // end of method foo
 */
 
public int flushCommentsDefinedPriorTo(int position) {

      int lastCommentIndex = this.scanner.commentPtr;
      if (lastCommentIndex < 0) return position; // no comment

      // compute the index of the first obsolete comment
      int index = lastCommentIndex;
      int validCount = 0;
      while (index >= 0){
            int commentEnd = this.scanner.commentStops[index];
            if (commentEnd < 0) commentEnd = -commentEnd; // negative end position for non-javadoc comments
            if (commentEnd <= position){
                  break;
            }
            index--;
            validCount++;
      }
      // if the source at <position> is immediately followed by a line comment, then
      // flush this comment and shift <position> to the comment end.
      if (validCount > 0){
            int immediateCommentEnd = -this.scanner.commentStops[index+1]; //non-javadoc comment end positions are negative
            if (immediateCommentEnd > 0){ // only tolerating non-javadoc comments
                  // is there any line break until the end of the immediate comment ? (thus only tolerating line comment)
                  immediateCommentEnd--; // comment end in one char too far
                  if (this.scanner.getLineNumber(position) == this.scanner.getLineNumber(immediateCommentEnd)){
                        position = immediateCommentEnd;
                        validCount--; // flush this comment
                        index++;
                  }
            }
      }

      if (index < 0) return position; // no obsolete comment

      switch (validCount) {
            case 0:
                  // do nothing
                  break;
            // move valid comment infos, overriding obsolete comment infos
            case 2:
                  this.scanner.commentStarts[0] = this.scanner.commentStarts[index+1];
                  this.scanner.commentStops[0] = this.scanner.commentStops[index+1];
                  this.scanner.commentTagStarts[0] = this.scanner.commentTagStarts[index+1];
                  this.scanner.commentStarts[1] = this.scanner.commentStarts[index+2];
                  this.scanner.commentStops[1] = this.scanner.commentStops[index+2];
                  this.scanner.commentTagStarts[1] = this.scanner.commentTagStarts[index+2];
                  break;
            case 1:
                  this.scanner.commentStarts[0] = this.scanner.commentStarts[index+1];
                  this.scanner.commentStops[0] = this.scanner.commentStops[index+1];
                  this.scanner.commentTagStarts[0] = this.scanner.commentTagStarts[index+1];
                  break;
            default:
                  System.arraycopy(this.scanner.commentStarts, index + 1, this.scanner.commentStarts, 0, validCount);
                  System.arraycopy(this.scanner.commentStops, index + 1, this.scanner.commentStops, 0, validCount);           
                  System.arraycopy(this.scanner.commentTagStarts, index + 1, this.scanner.commentTagStarts, 0, validCount);
      }
      this.scanner.commentPtr = validCount - 1;
      return position;
}
protected TypeReference getAnnotationType() {
      int length = this.identifierLengthStack[this.identifierLengthPtr--];
      if (length == 1) {
            return new SingleTypeReference(
                        this.identifierStack[this.identifierPtr], 
                        this.identifierPositionStack[this.identifierPtr--]);
      } else {
            char[][] tokens = new char[length][];
            this.identifierPtr -= length;
            long[] positions = new long[length];
            System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, 0, length);
            System.arraycopy(
                  this.identifierPositionStack, 
                  this.identifierPtr + 1, 
                  positions, 
                  0, 
                  length);
            return new QualifiedTypeReference(tokens, positions);
      }
}
public int getFirstToken() {
      // the first token is a virtual token that
      // allows the parser to parse several goals
      // even if they aren't LALR(1)....
      // Goal ::= '++' CompilationUnit
      // Goal ::= '--' MethodBody
      // Goal ::= '==' ConstructorBody
      // -- Initializer
      // Goal ::= '>>' StaticInitializer
      // Goal ::= '>>' Block
      // -- error recovery
      // Goal ::= '>>>' Headers
      // Goal ::= '*' BlockStatements
      // Goal ::= '*' MethodPushModifiersHeader
      // -- JDOM
      // Goal ::= '&&' FieldDeclaration
      // Goal ::= '||' ImportDeclaration
      // Goal ::= '?' PackageDeclaration
      // Goal ::= '+' TypeDeclaration
      // Goal ::= '/' GenericMethodDeclaration
      // Goal ::= '&' ClassBodyDeclaration
      // -- code snippet
      // Goal ::= '%' Expression
      // -- completion parser
      // Goal ::= '!' ConstructorBlockStatementsopt
      // Goal ::= '~' BlockStatementsopt
      
      return this.firstToken;
}
/*
 * Answer back an array of sourceStart/sourceEnd positions of the available JavaDoc comments.
 * The array is a flattened structure: 2*n entries with consecutives start and end positions.
 *
 * If no JavaDoc is available, then null is answered instead of an empty array.
 *
 * e.g. { 10, 20, 25, 45 }  --> javadoc1 from 10 to 20, javadoc2 from 25 to 45
 */
public int[] getJavaDocPositions() {

      int javadocCount = 0;
      for (int i = 0, max = this.scanner.commentPtr; i <= max; i++){
            // javadoc only (non javadoc comment have negative end positions.)
            if (this.scanner.commentStops[i] > 0){
                  javadocCount++;
            }
      }
      if (javadocCount == 0) return null;

      int[] positions = new int[2*javadocCount];
      int index = 0;
      for (int i = 0, max = this.scanner.commentPtr; i <= max; i++){
            // javadoc only (non javadoc comment have negative end positions.)
            if (this.scanner.commentStops[i] > 0){
                  positions[index++] = this.scanner.commentStarts[i];
                  positions[index++] = this.scanner.commentStops[i]-1; //stop is one over             
            }
      }
      return positions;
}
      public void getMethodBodies(CompilationUnitDeclaration unit) {
            //fill the methods bodies in order for the code to be generated

            if (unit == null) return;
            
            if (unit.ignoreMethodBodies) {
                  unit.ignoreFurtherInvestigation = true;
                  return;
                  // if initial diet parse did not work, no need to dig into method bodies.
            }

            if ((unit.bits & ASTNode.HasAllMethodBodies) != 0)
                  return; //work already done ...

            // save existing values to restore them at the end of the parsing process
            // see bug 47079 for more details
            int[] oldLineEnds = this.scanner.lineEnds;
            int oldLinePtr = this.scanner.linePtr;

            //real parse of the method....
            CompilationResult compilationResult = unit.compilationResult;
            this.scanner.setSource(compilationResult);
            
            if (this.javadocParser != null && this.javadocParser.checkDocComment) {
                  char[] contents = compilationResult.compilationUnit.getContents();
                  this.javadocParser.scanner.setSource(contents);
            }
            if (unit.types != null) {
                  for (int i = unit.types.length; --i >= 0;)
                        unit.types[i].parseMethod(this, unit);
            }
            
            // tag unit has having read bodies
            unit.bits |= ASTNode.HasAllMethodBodies;

            // this is done to prevent any side effects on the compilation unit result
            // line separator positions array.
            this.scanner.lineEnds = oldLineEnds;
            this.scanner.linePtr = oldLinePtr;
      }
protected char getNextCharacter(char[] comment, int[] index) {
      char nextCharacter = comment[index[0]++];
      switch(nextCharacter) {
            case '\\' :
                  int c1, c2, c3, c4;
                  index[0]++;
                  while (comment[index[0]] == 'u') index[0]++;
                  if (!(((c1 = Character.getNumericValue(comment[index[0]++])) > 15
                        || c1 < 0)
                        || ((c2 = Character.getNumericValue(comment[index[0]++])) > 15 || c2 < 0)
                        || ((c3 = Character.getNumericValue(comment[index[0]++])) > 15 || c3 < 0)
                        || ((c4 = Character.getNumericValue(comment[index[0]++])) > 15 || c4 < 0))) {
                              nextCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
                  }
                  break;
      }
      return nextCharacter;
}
protected Expression getTypeReference(Expression exp) {
      
      exp.bits &= ~ASTNode.RestrictiveFlagMASK;
      exp.bits |= Binding.TYPE;
      return exp;
}
protected TypeReference getTypeReference(int dim) {
      /* build a Reference on a variable that may be qualified or not
       This variable is a type reference and dim will be its dimensions*/

      TypeReference ref;
      int length = this.identifierLengthStack[this.identifierLengthPtr--];
      if (length < 0) { //flag for precompiled type reference on base types
            ref = TypeReference.baseTypeReference(-length, dim);
            ref.sourceStart = this.intStack[this.intPtr--];
            if (dim == 0) {
                  ref.sourceEnd = this.intStack[this.intPtr--];
            } else {
                  this.intPtr--;
                  ref.sourceEnd = this.endPosition;
            }
      } else {
            int numberOfIdentifiers = this.genericsIdentifiersLengthStack[this.genericsIdentifiersLengthPtr--];
            if (length != numberOfIdentifiers || this.genericsLengthStack[this.genericsLengthPtr] != 0) {
                  // generic type
                  ref = getTypeReferenceForGenericType(dim, length, numberOfIdentifiers);
            } else if (length == 1) {
                  // single variable reference
                  this.genericsLengthPtr--; // pop the 0
                  if (dim == 0) {
                        ref = 
                              new SingleTypeReference(
                                    this.identifierStack[this.identifierPtr], 
                                    this.identifierPositionStack[this.identifierPtr--]); 
                  } else {
                        ref = 
                              new ArrayTypeReference(
                                    this.identifierStack[this.identifierPtr], 
                                    dim, 
                                    this.identifierPositionStack[this.identifierPtr--]); 
                        ref.sourceEnd = this.endPosition;               
                  }
            } else {
                  this.genericsLengthPtr--;
                  //Qualified variable reference
                  char[][] tokens = new char[length][];
                  this.identifierPtr -= length;
                  long[] positions = new long[length];
                  System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, 0, length);
                  System.arraycopy(
                        this.identifierPositionStack, 
                        this.identifierPtr + 1, 
                        positions, 
                        0, 
                        length); 
                  if (dim == 0) {
                        ref = new QualifiedTypeReference(tokens, positions);
                  } else {
                        ref = new ArrayQualifiedTypeReference(tokens, dim, positions);
                        ref.sourceEnd = this.endPosition;
                  }
            }
      }
      return ref;
}
protected TypeReference getTypeReferenceForGenericType(int dim, int identifierLength, int numberOfIdentifiers) {
      if (identifierLength == 1 && numberOfIdentifiers == 1) {
            int currentTypeArgumentsLength = this.genericsLengthStack[this.genericsLengthPtr--];
            TypeReference[] typeArguments = new TypeReference[currentTypeArgumentsLength];
            this.genericsPtr -= currentTypeArgumentsLength;
            System.arraycopy(this.genericsStack, this.genericsPtr + 1, typeArguments, 0, currentTypeArgumentsLength);
            ParameterizedSingleTypeReference parameterizedSingleTypeReference = new ParameterizedSingleTypeReference(this.identifierStack[this.identifierPtr], typeArguments, dim, this.identifierPositionStack[this.identifierPtr--]);
            if (dim != 0) {
                  parameterizedSingleTypeReference.sourceEnd = this.endPosition;
            }
            return parameterizedSingleTypeReference;
      } else {
            TypeReference[][] typeArguments = new TypeReference[numberOfIdentifiers][];
            char[][] tokens = new char[numberOfIdentifiers][];
            long[] positions = new long[numberOfIdentifiers];
            int index = numberOfIdentifiers;
            int currentIdentifiersLength = identifierLength;
            while (index > 0) {
                  int currentTypeArgumentsLength = this.genericsLengthStack[this.genericsLengthPtr--];
                  if (currentTypeArgumentsLength != 0) {
                        this.genericsPtr -= currentTypeArgumentsLength;
                        System.arraycopy(this.genericsStack, this.genericsPtr + 1, typeArguments[index - 1] = new TypeReference[currentTypeArgumentsLength], 0, currentTypeArgumentsLength);
                  }
                  switch(currentIdentifiersLength) {
                        case 1 :
                              // we are in a case A<B>.C<D> or A<B>.C<D>
                              tokens[index - 1] = this.identifierStack[this.identifierPtr];
                              positions[index - 1] = this.identifierPositionStack[this.identifierPtr--];
                              break;
                        default:
                              // we are in a case A.B.C<B>.C<D> or A.B.C<B>...
                              this.identifierPtr -= currentIdentifiersLength;
                              System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, index - currentIdentifiersLength, currentIdentifiersLength);
                              System.arraycopy(this.identifierPositionStack, this.identifierPtr + 1, positions, index - currentIdentifiersLength, currentIdentifiersLength);
                  }
                  index -= currentIdentifiersLength;
                  if (index > 0) {
                        currentIdentifiersLength = this.identifierLengthStack[this.identifierLengthPtr--];
                  }
            }
            return new ParameterizedQualifiedTypeReference(tokens, typeArguments, dim, positions);
      }
}
protected NameReference getUnspecifiedReference() {
      /* build a (unspecified) NameReference which may be qualified*/

      int length;
      NameReference ref;
      if ((length = this.identifierLengthStack[this.identifierLengthPtr--]) == 1)
            // single variable reference
            ref = 
                  new SingleNameReference(
                        this.identifierStack[this.identifierPtr], 
                        this.identifierPositionStack[this.identifierPtr--]); 
      else
            //Qualified variable reference
            {
            char[][] tokens = new char[length][];
            this.identifierPtr -= length;
            System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, 0, length);
            long[] positions = new long[length];
            System.arraycopy(this.identifierPositionStack, this.identifierPtr + 1, positions, 0, length);
            ref = 
                  new QualifiedNameReference(tokens, 
                        positions,
                        (int) (this.identifierPositionStack[this.identifierPtr + 1] >> 32), // sourceStart
                        (int) this.identifierPositionStack[this.identifierPtr + length]); // sourceEnd
      }
      return ref;
}
protected NameReference getUnspecifiedReferenceOptimized() {
      /* build a (unspecified) NameReference which may be qualified
      The optimization occurs for qualified reference while we are
      certain in this case the last item of the qualified name is
      a field access. This optimization is IMPORTANT while it results
      that when a NameReference is build, the type checker should always
      look for that it is not a type reference */

      int length;
      NameReference ref;
      if ((length = this.identifierLengthStack[this.identifierLengthPtr--]) == 1) {
            // single variable reference
            ref = 
                  new SingleNameReference(
                        this.identifierStack[this.identifierPtr], 
                        this.identifierPositionStack[this.identifierPtr--]); 
            ref.bits &= ~ASTNode.RestrictiveFlagMASK;
            ref.bits |= Binding.LOCAL | Binding.FIELD;
            return ref;
      }

      //Qualified-variable-reference
      //In fact it is variable-reference DOT field-ref , but it would result in a type
      //conflict tha can be only reduce by making a superclass (or inetrface ) between
      //nameReference and FiledReference or putting FieldReference under NameReference
      //or else..........This optimisation is not really relevant so just leave as it is

      char[][] tokens = new char[length][];
      this.identifierPtr -= length;
      System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, 0, length);
      long[] positions = new long[length];
      System.arraycopy(this.identifierPositionStack, this.identifierPtr + 1, positions, 0, length);
      ref = new QualifiedNameReference(
                  tokens,
                  positions, 
                  (int) (this.identifierPositionStack[this.identifierPtr + 1] >> 32), // sourceStart
                  (int) this.identifierPositionStack[this.identifierPtr + length]); // sourceEnd
      ref.bits &= ~ASTNode.RestrictiveFlagMASK;
      ref.bits |= Binding.LOCAL | Binding.FIELD;
      return ref;
}
public void goForBlockStatementsopt() {
      //tells the scanner to go for block statements opt parsing

      this.firstToken = TokenNameTWIDDLE;
      this.scanner.recordLineSeparator = false;
}
public void goForBlockStatementsOrCatchHeader() {
      //tells the scanner to go for block statements or method headers parsing 

      this.firstToken = TokenNameMULTIPLY;
      this.scanner.recordLineSeparator = false;
}
public void goForClassBodyDeclarations() {
      //tells the scanner to go for any body declarations parsing

      this.firstToken = TokenNameAND;
      this.scanner.recordLineSeparator = true;
}
public void goForCompilationUnit(){
      //tells the scanner to go for compilation unit parsing

      this.firstToken = TokenNamePLUS_PLUS ;
      this.scanner.foundTaskCount = 0;
      this.scanner.recordLineSeparator = true;
      this.scanner.currentLine= null;
}
public void goForExpression() {
      //tells the scanner to go for an expression parsing

      this.firstToken = TokenNameREMAINDER;
      this.scanner.recordLineSeparator = true; // recovery goals must record line separators
}
public void goForFieldDeclaration(){
      //tells the scanner to go for field declaration parsing

      this.firstToken = TokenNameAND_AND ;
      this.scanner.recordLineSeparator = true;
}
public void goForGenericMethodDeclaration(){
      //tells the scanner to go for generic method declarations parsing

      this.firstToken = TokenNameDIVIDE;
      this.scanner.recordLineSeparator = true;
}
public void goForHeaders(){
      //tells the scanner to go for headers only parsing
      RecoveredType currentType = this.currentRecoveryType();
      if(currentType != null && currentType.insideEnumConstantPart) {
            this.firstToken = TokenNameNOT;
      } else {
            this.firstToken = TokenNameUNSIGNED_RIGHT_SHIFT;
      }
      this.scanner.recordLineSeparator = true; // recovery goals must record line separators
}
public void goForImportDeclaration(){
      //tells the scanner to go for import declaration parsing

      this.firstToken = TokenNameOR_OR ;
      this.scanner.recordLineSeparator = true;
}
public void goForInitializer(){
      //tells the scanner to go for initializer parsing

      this.firstToken = TokenNameRIGHT_SHIFT ;
      this.scanner.recordLineSeparator = false;
}
public void goForMemberValue() {
      //tells the scanner to go for a member value parsing

      this.firstToken = TokenNameOR_OR;
      this.scanner.recordLineSeparator = true; // recovery goals must record line separators
}
public void goForMethodBody(){
      //tells the scanner to go for method body parsing

      this.firstToken = TokenNameMINUS_MINUS ;
      this.scanner.recordLineSeparator = false;
}
public void goForPackageDeclaration() {
      //tells the scanner to go for package declaration parsing

      this.firstToken = TokenNameQUESTION;
      this.scanner.recordLineSeparator = true;
}
public void goForTypeDeclaration() {
      //tells the scanner to go for type (interface or class) declaration parsing

      this.firstToken = TokenNamePLUS;
      this.scanner.recordLineSeparator = true;
}
protected void ignoreExpressionAssignment() {
      // Assignment ::= InvalidArrayInitializerAssignement
      // encoded operator would be: this.intStack[this.intPtr]
      this.intPtr--;
      ArrayInitializer arrayInitializer = (ArrayInitializer) this.expressionStack[this.expressionPtr--];
      this.expressionLengthPtr -- ;
      // report a syntax error and abort parsing
      problemReporter().arrayConstantsOnlyInArrayInitializers(arrayInitializer.sourceStart, arrayInitializer.sourceEnd);      
}
public void initialize() {
      //positionning the parser for a new compilation unit
      //avoiding stack reallocation and all that....
      this.astPtr = -1;
      this.astLengthPtr = -1;
      this.expressionPtr = -1;
      this.expressionLengthPtr = -1;
      this.identifierPtr = -1;      
      this.identifierLengthPtr      = -1;
      this.intPtr = -1;
      this.nestedMethod[this.nestedType = 0] = 0; // need to reset for further reuse
      this.variablesCounter[this.nestedType] = 0;
      this.dimensions = 0 ;
      this.realBlockPtr = -1;
      this.compilationUnit = null;
      this.referenceContext = null;
      this.endStatementPosition = 0;

      //remove objects from stack too, while the same parser/compiler couple is
      //re-used between two compilations ....
      
      int astLength = this.astStack.length;
      if (this.noAstNodes.length < astLength){
            this.noAstNodes = new ASTNode[astLength];
            //System.out.println("Resized AST stacks : "+ astLength);
            
      }
      System.arraycopy(this.noAstNodes, 0, this.astStack, 0, astLength);

      int expressionLength = this.expressionStack.length;
      if (this.noExpressions.length < expressionLength){
            this.noExpressions = new Expression[expressionLength];
            //System.out.println("Resized EXPR stacks : "+ expressionLength);
      }
      System.arraycopy(this.noExpressions, 0, this.expressionStack, 0, expressionLength);

      // reset this.scanner state
      this.scanner.commentPtr = -1;
      this.scanner.foundTaskCount = 0;
      this.scanner.eofPosition = Integer.MAX_VALUE;
      this.scanner.wasNonExternalizedStringLiteral = false;
      this.scanner.nonNLSStrings = null;
      this.scanner.currentLine = null;    

      resetModifiers();

      // recovery
      this.lastCheckPoint = -1;
      this.currentElement = null;
      this.restartRecovery = false;
      this.hasReportedError = false;
      this.recoveredStaticInitializerStart = 0;
      this.lastIgnoredToken = -1;
      this.lastErrorEndPosition = -1;
      this.lastErrorEndPositionBeforeRecovery = -1;
      this.lastJavadocEnd = -1;
      this.listLength = 0;
      this.listTypeParameterLength = 0;
      
      this.rBraceStart = 0;
      this.rBraceEnd = 0;
      this.rBraceSuccessorStart = 0;

      this.genericsIdentifiersLengthPtr = -1;
      this.genericsLengthPtr = -1;
      this.genericsPtr = -1;
}
public void initializeScanner(){
      this.scanner = new Scanner(
            false /*comment*/, 
            false /*whitespace*/, 
            this.options.getSeverity(CompilerOptions.NonExternalizedString) != ProblemSeverities.Ignore /*nls*/, 
            this.options.sourceLevel /*sourceLevel*/, 
            this.options.complianceLevel /*complianceLevel*/, 
            this.options.taskTags/*taskTags*/,
            this.options.taskPriorites/*taskPriorities*/,
            this.options.isTaskCaseSensitive/*taskCaseSensitive*/);
}
public void jumpOverMethodBody() {
      //on diet parsing.....do not buffer method statements

      //the scanner.diet is reinitialized to false
      //automatically by the scanner once it has jumped over
      //the statements

      if (this.diet && (this.dietInt == 0))
            this.scanner.diet = true;
}
protected void markEnclosingMemberWithLocalType() {
      if (this.currentElement != null) return; // this is already done in the recovery code
      for (int i = this.astPtr; i >= 0; i--) {
            ASTNode node = this.astStack[i];
            if (node instanceof AbstractMethodDeclaration 
                        || node instanceof FieldDeclaration
                        || node instanceof TypeDeclaration) { // mark type for now: all initializers will be marked when added to this type
                  node.bits |= ASTNode.HasLocalTypeMASK;
                  return;
            }
      }
      // default to reference context (case of parse method body)
      if (this.referenceContext instanceof AbstractMethodDeclaration
                  || this.referenceContext instanceof TypeDeclaration) {
            ((ASTNode)this.referenceContext).bits |= ASTNode.HasLocalTypeMASK;
      }
}
protected void markInitializersWithLocalType(TypeDeclaration type) {
      if (type.fields == null || (type.bits & ASTNode.HasLocalTypeMASK) == 0) return;
      for (int i = 0, length = type.fields.length; i < length; i++) {
            FieldDeclaration field = type.fields[i];
            if (field instanceof Initializer) {
                  field.bits |= ASTNode.HasLocalTypeMASK;
            }
      }
}
/*
 * Move checkpoint location (current implementation is moving it by one token)
 *
 * Answers true if successfully moved checkpoint (in other words, it did not attempt to move it
 * beyond end of file).
 */
protected boolean moveRecoveryCheckpoint() {

      int pos = this.lastCheckPoint;
      /* reset this.scanner, and move checkpoint by one token */
      this.scanner.startPosition = pos;
      this.scanner.currentPosition = pos;
      this.scanner.diet = false; // quit jumping over method bodies
      
      /* if about to restart, then no need to shift token */
      if (this.restartRecovery){
            this.lastIgnoredToken = -1;
            this.scanner.currentLine = null;
            return true;
      }
      
      /* protect against shifting on an invalid token */
      this.lastIgnoredToken = this.nextIgnoredToken;
      this.nextIgnoredToken = -1;
      do {
            try {
                  this.nextIgnoredToken = this.scanner.getNextToken();
                  if(this.scanner.currentPosition == this.scanner.startPosition){
                        this.scanner.currentPosition++; // on fake completion identifier
                        this.nextIgnoredToken = -1;
                  }
                  
            } catch(InvalidInputException e){
                  pos = this.scanner.currentPosition;
            }
      } while (this.nextIgnoredToken < 0);
      
      if (this.nextIgnoredToken == TokenNameEOF) { // no more recovery after this point
            if (this.currentToken == TokenNameEOF) { // already tried one iteration on EOF
                  this.scanner.currentLine = null;
                  return false;
            }
      }
      this.lastCheckPoint = this.scanner.currentPosition;
      
      /* reset this.scanner again to previous checkpoint location*/
      this.scanner.startPosition = pos;
      this.scanner.currentPosition = pos;
      this.scanner.commentPtr = -1;
      this.scanner.foundTaskCount = 0;
      this.scanner.currentLine = null;

      return true;

/*
      The following implementation moves the checkpoint location by one line:
       
      int pos = this.lastCheckPoint;
      // reset this.scanner, and move checkpoint by one token
      this.scanner.startPosition = pos;
      this.scanner.currentPosition = pos;
      this.scanner.diet = false; // quit jumping over method bodies
      
      // if about to restart, then no need to shift token
      if (this.restartRecovery){
            this.lastIgnoredToken = -1;
            return true;
      }
      
      // protect against shifting on an invalid token
      this.lastIgnoredToken = this.nextIgnoredToken;
      this.nextIgnoredToken = -1;
      
      boolean wasTokenizingWhiteSpace = this.scanner.tokenizeWhiteSpace;
      this.scanner.tokenizeWhiteSpace = true;
      checkpointMove: 
            do {
                  try {
                        this.nextIgnoredToken = this.scanner.getNextToken();
                        switch(this.nextIgnoredToken){
                              case Scanner.TokenNameWHITESPACE :
                                    if(this.scanner.getLineNumber(this.scanner.startPosition)
                                          == this.scanner.getLineNumber(this.scanner.currentPosition)){
                                          this.nextIgnoredToken = -1;
                                          }
                                    break;
                              case TokenNameSEMICOLON :
                              case TokenNameLBRACE :
                              case TokenNameRBRACE :
                                    break;
                              case TokenNameIdentifier :
                                    if(this.scanner.currentPosition == this.scanner.startPosition){
                                          this.scanner.currentPosition++; // on fake completion identifier
                                    }
                              default:                                  
                                    this.nextIgnoredToken = -1;
                                    break;
                              case TokenNameEOF :
                                    break checkpointMove;
                        }
                  } catch(InvalidInputException e){
                        pos = this.scanner.currentPosition;
                  }
            } while (this.nextIgnoredToken < 0);
      this.scanner.tokenizeWhiteSpace = wasTokenizingWhiteSpace;
      
      if (this.nextIgnoredToken == TokenNameEOF) { // no more recovery after this point
            if (this.currentToken == TokenNameEOF) { // already tried one iteration on EOF
                  return false;
            }
      }
      this.lastCheckPoint = this.scanner.currentPosition;
      
      // reset this.scanner again to previous checkpoint location
      this.scanner.startPosition = pos;
      this.scanner.currentPosition = pos;
      this.scanner.commentPtr = -1;

      return true;
*/
}
protected MessageSend newMessageSend() {
      // '(' ArgumentListopt ')'
      // the arguments are on the expression stack

      MessageSend m = new MessageSend();
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            this.expressionPtr -= length;
            System.arraycopy(
                  this.expressionStack, 
                  this.expressionPtr + 1, 
                  m.arguments = new Expression[length], 
                  0, 
                  length); 
      }
      return m;
}
protected MessageSend newMessageSendWithTypeArguments() {
      MessageSend m = new MessageSend();
      int length;
      if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
            this.expressionPtr -= length;
            System.arraycopy(
                  this.expressionStack, 
                  this.expressionPtr + 1, 
                  m.arguments = new Expression[length], 
                  0, 
                  length); 
      }
      return m;
}
protected void optimizedConcatNodeLists() {
      /*back from a recursive loop. Virtualy group the
      astNode into an array using this.astLengthStack*/

      /*
       * This is a case where you have two sublists into the this.astStack that you want
       * to merge in one list. There is no action required on the this.astStack. The only
       * thing you need to do is merge the two lengths specified on the astStackLength.
       * The top two length are for example:
       * ... p   n
       * and you want to result in a list like:
       * ... n+p 
       * This means that the p could be equals to 0 in case there is no astNode pushed
       * on the this.astStack.
       * Look at the InterfaceMemberDeclarations for an example.
       * This case optimizes the fact that p == 1.
       */

      this.astLengthStack[--this.astLengthPtr]++;
}
/*main loop of the automat
When a rule is reduced, the method consumeRule(int) is called with the number
of the consumed rule. When a terminal is consumed, the method consumeToken(int) is 
called in order to remember (when needed) the consumed token */
// (int)asr[asi(act)]
// name[symbol_index[currentKind]]
protected void parse() {
      if (DEBUG) System.out.println("-- ENTER INSIDE PARSE METHOD --");  //$NON-NLS-1$
      boolean isDietParse = this.diet;
      int oldFirstToken = getFirstToken();
      this.hasError = false;
      
      this.hasReportedError = false;
      int act = START_STATE;
      this.stateStackTop = -1;
      this.currentToken = getFirstToken();
      ProcessTerminals : for (;;) {
            int stackLength = this.stack.length;
            if (++this.stateStackTop >= stackLength) {
                  System.arraycopy(
                        this.stack, 0,
                        this.stack = new int[stackLength + StackIncrement], 0,
                        stackLength);
            }
            this.stack[this.stateStackTop] = act;

            act = tAction(act, this.currentToken);
            if (act == ERROR_ACTION || this.restartRecovery) {
                  int errorPos = this.scanner.currentPosition;
                  if (!this.hasReportedError) {
                        this.hasError = true;
                  }
                  if (resumeOnSyntaxError()) {
                        if (act == ERROR_ACTION) this.lastErrorEndPosition = errorPos;
                        act = START_STATE;
                        this.stateStackTop = -1;
                        this.currentToken = getFirstToken();
                        continue ProcessTerminals;
                  }
                  act = ERROR_ACTION;
                  break ProcessTerminals;
            }
            if (act <= NUM_RULES) {
                  this.stateStackTop--;

            } else if (act > ERROR_ACTION) { /* shift-reduce */
                  consumeToken(this.currentToken);
                  if (this.currentElement != null) this.recoveryTokenCheck();
                  try {
                        this.currentToken = this.scanner.getNextToken();
                  } catch(InvalidInputException e){
                        if (!this.hasReportedError){
                              this.problemReporter().scannerError(this, e.getMessage());
                              this.hasReportedError = true;
                        }
                        this.lastCheckPoint = this.scanner.currentPosition;
                        this.restartRecovery = true;
                  }                             
                  act -= ERROR_ACTION;
                  
            } else {
                if (act < ACCEPT_ACTION) { /* shift */
                        consumeToken(this.currentToken);
                        if (this.currentElement != null) this.recoveryTokenCheck();
                        try{
                              this.currentToken = this.scanner.getNextToken();
                        } catch(InvalidInputException e){
                              if (!this.hasReportedError){
                                    this.problemReporter().scannerError(this, e.getMessage());
                                    this.hasReportedError = true;
                              }
                              this.lastCheckPoint = this.scanner.currentPosition;
                              this.restartRecovery = true;
                        }                             
                        continue ProcessTerminals;
                  }
                  break ProcessTerminals;
            }
                  
            // ProcessNonTerminals : 
            do { /* reduce */
                  consumeRule(act);
                  this.stateStackTop -= (rhs[act] - 1);
                  act = ntAction(this.stack[this.stateStackTop], lhs[act]);
            } while (act <= NUM_RULES);
      }
      endParse(act);
      
      if (this.reportSyntaxErrorIsRequired && this.hasError) {
            reportSyntaxErrors(isDietParse, oldFirstToken);
      }
      if (DEBUG) System.out.println("-- EXIT FROM PARSE METHOD --");  //$NON-NLS-1$
}
public void parse(ConstructorDeclaration cd, CompilationUnitDeclaration unit) {
      parse(cd, unit, false);
}
public void parse(ConstructorDeclaration cd, CompilationUnitDeclaration unit, boolean recordLineSeparator) {
      //only parse the method body of cd
      //fill out its statements

      //convert bugs into parse error

      initialize();
      goForBlockStatementsopt();
      if (recordLineSeparator) {
            this.scanner.recordLineSeparator = true;
      }
      this.nestedMethod[this.nestedType]++;
      pushOnRealBlockStack(0);
      
      this.referenceContext = cd;
      this.compilationUnit = unit;

      this.scanner.resetTo(cd.bodyStart, cd.bodyEnd);
      try {
            parse();
      } catch (AbortCompilation ex) {
            this.lastAct = ERROR_ACTION;
      } finally {
            this.nestedMethod[this.nestedType]--;
      }

      checkNonNLSAfterBodyEnd(cd.declarationSourceEnd);
      
      if (this.lastAct == ERROR_ACTION) {
            initialize();
            return;
      }

      //statements
      cd.explicitDeclarations = this.realBlockStack[this.realBlockPtr--];
      int length;
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            this.astPtr -= length;
            if (this.astStack[this.astPtr + 1] instanceof ExplicitConstructorCall)
                  //avoid a isSomeThing that would only be used here BUT what is faster between two alternatives ?
                  {
                  System.arraycopy(
                        this.astStack, 
                        this.astPtr + 2, 
                        cd.statements = new Statement[length - 1], 
                        0, 
                        length - 1); 
                  cd.constructorCall = (ExplicitConstructorCall) this.astStack[this.astPtr + 1];
            } else { //need to add explicitly the super();
                  System.arraycopy(
                        this.astStack, 
                        this.astPtr + 1, 
                        cd.statements = new Statement[length], 
                        0, 
                        length); 
                  cd.constructorCall = SuperReference.implicitSuperConstructorCall();
            }
      } else {
            cd.constructorCall = SuperReference.implicitSuperConstructorCall();
            if (!containsComment(cd.bodyStart, cd.bodyEnd)) {
                  cd.bits |= ASTNode.UndocumentedEmptyBlockMASK;
            }           
      }

      if (cd.constructorCall.sourceEnd == 0) {
            cd.constructorCall.sourceEnd = cd.sourceEnd;
            cd.constructorCall.sourceStart = cd.sourceStart;
      }
}
// A P I

public void parse(
      FieldDeclaration field, 
      TypeDeclaration type, 
      CompilationUnitDeclaration unit,
      char[] initializationSource) {
      //only parse the initializationSource of the given field

      //convert bugs into parse error

      initialize();
      goForExpression();
      this.nestedMethod[this.nestedType]++;

      this.referenceContext = type;
      this.compilationUnit = unit;

      this.scanner.setSource(initializationSource);
      this.scanner.resetTo(0, initializationSource.length-1);
      try {
            parse();
      } catch (AbortCompilation ex) {
            this.lastAct = ERROR_ACTION;
      } finally {
            this.nestedMethod[this.nestedType]--;
      }

      if (this.lastAct == ERROR_ACTION) {
            return;
      }

      field.initialization = this.expressionStack[this.expressionPtr];
      
      // mark field with local type if one was found during parsing
      if ((type.bits & ASTNode.HasLocalTypeMASK) != 0) {
            field.bits |= ASTNode.HasLocalTypeMASK;
      }     
}
// A P I

public CompilationUnitDeclaration parse(
      ICompilationUnit sourceUnit, 
      CompilationResult compilationResult) {
      // parses a compilation unit and manages error handling (even bugs....)

      return parse(sourceUnit, compilationResult, -1, -1/*parse without reseting the scanner*/);
}
// A P I

public CompilationUnitDeclaration parse(
      ICompilationUnit sourceUnit, 
      CompilationResult compilationResult,
      int start,
      int end) {
      // parses a compilation unit and manages error handling (even bugs....)

      CompilationUnitDeclaration unit;
      try {
            /* automaton initialization */
            initialize();
            goForCompilationUnit();

            /* scanners initialization */
            char[] contents = sourceUnit.getContents();
            this.scanner.setSource(contents);
            if (end != -1) this.scanner.resetTo(start, end);
            if (this.javadocParser != null && this.javadocParser.checkDocComment) {
                  this.javadocParser.scanner.setSource(contents);
                  if (end != -1) {
                        this.javadocParser.scanner.resetTo(start, end);
                  }
            }
            /* unit creation */
            this.referenceContext = 
                  this.compilationUnit = 
                        new CompilationUnitDeclaration(
                              this.problemReporter, 
                              compilationResult, 
                              this.scanner.source.length);
            /* run automaton */
            parse();
      } finally {
            unit = this.compilationUnit;
            this.compilationUnit = null; // reset parser
            // tag unit has having read bodies
            if (!this.diet) unit.bits |= ASTNode.HasAllMethodBodies;          
      }
      return unit;
}
// A P I

public void parse(
      Initializer initializer, 
      TypeDeclaration type, 
      CompilationUnitDeclaration unit) {
      //only parse the method body of md
      //fill out method statements

      //convert bugs into parse error

      initialize();
      goForBlockStatementsopt();
      this.nestedMethod[this.nestedType]++;
      pushOnRealBlockStack(0);
      
      this.referenceContext = type;
      this.compilationUnit = unit;

      this.scanner.resetTo(initializer.bodyStart, initializer.bodyEnd); // just on the beginning {
      try {
            parse();
      } catch (AbortCompilation ex) {
            this.lastAct = ERROR_ACTION;
      } finally {
            this.nestedMethod[this.nestedType]--;
      }

      checkNonNLSAfterBodyEnd(initializer.declarationSourceEnd);
      
      if (this.lastAct == ERROR_ACTION) {
            return;
      }
      
      //refill statements
      initializer.block.explicitDeclarations = this.realBlockStack[this.realBlockPtr--];
      int length;
      if ((length = this.astLengthStack[this.astLengthPtr--]) > 0) {
            System.arraycopy(this.astStack, (this.astPtr -= length) + 1, initializer.block.statements = new Statement[length], 0, length); 
      } else {
            // check whether this block at least contains some comment in it
            if (!containsComment(initializer.block.sourceStart, initializer.block.sourceEnd)) {
                  initializer.block.bits |= ASTNode.UndocumentedEmptyBlockMASK;
            }
      }
      
      // mark initializer with local type if one was found during parsing
      if ((type.bits & ASTNode.HasLocalTypeMASK) != 0) {
            initializer.bits |= ASTNode.HasLocalTypeMASK;
      }     
}
// A P I

public void parse(MethodDeclaration md, CompilationUnitDeclaration unit) {
      //only parse the method body of md
      //fill out method statements

      //convert bugs into parse error

      if (md.isAbstract())
            return;
      if (md.isNative())
            return;
      if ((md.modifiers & AccSemicolonBody) != 0)
            return;

      initialize();
      goForBlockStatementsopt();
      this.nestedMethod[this.nestedType]++;
      pushOnRealBlockStack(0);

      this.referenceContext = md;
      this.compilationUnit = unit;

      this.scanner.resetTo(md.bodyStart, md.bodyEnd);
      // reset the scanner to parser from { down to }
      try {
            parse();
      } catch (AbortCompilation ex) {
            this.lastAct = ERROR_ACTION;
      } finally {
            this.nestedMethod[this.nestedType]--;           
      }

      checkNonNLSAfterBodyEnd(md.declarationSourceEnd);
      
      if (this.lastAct == ERROR_ACTION) {
            return;
      }

      //refill statements
      md.explicitDeclarations = this.realBlockStack[this.realBlockPtr--];
      int length;
      if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
            System.arraycopy(
                  this.astStack, 
                  (this.astPtr -= length) + 1, 
                  md.statements = new Statement[length], 
                  0, 
                  length); 
      } else {
            if (!containsComment(md.bodyStart, md.bodyEnd)) {
                  md.bits |= ASTNode.UndocumentedEmptyBlockMASK;
            }
      }
}
public ASTNode[] parseClassBodyDeclarations(char[] source, int offset, int length, CompilationUnitDeclaration unit) {
      /* automaton initialization */
      initialize();
      goForClassBodyDeclarations();
      /* scanner initialization */
      this.scanner.setSource(source);
      this.scanner.resetTo(offset, offset + length - 1);
      if (this.javadocParser != null && this.javadocParser.checkDocComment) {
            this.javadocParser.scanner.setSource(source);
            this.javadocParser.scanner.resetTo(offset, offset + length - 1);
      }

      /* type declaration should be parsed as member type declaration */      
      this.nestedType = 1;

      /* unit creation */
      this.referenceContext = unit;
      this.compilationUnit = unit;

      /* run automaton */
      try {
            parse();
      } catch (AbortCompilation ex) {
            this.lastAct = ERROR_ACTION;
      }

      if (this.lastAct == ERROR_ACTION) {
            return null;
      }
      int astLength;
      if ((astLength = this.astLengthStack[this.astLengthPtr--]) != 0) {
            ASTNode[] result = new ASTNode[astLength];
            this.astPtr -= astLength;
            System.arraycopy(this.astStack, this.astPtr + 1, result, 0, astLength);
            return result;
      }
      return null;
}
public Expression parseExpression(char[] source, int offset, int length, CompilationUnitDeclaration unit) {

      initialize();
      goForExpression();
      this.nestedMethod[this.nestedType]++;

      this.referenceContext = unit;
      this.compilationUnit = unit;

      this.scanner.setSource(source);
      this.scanner.resetTo(offset, offset + length - 1);
      try {
            parse();
      } catch (AbortCompilation ex) {
            this.lastAct = ERROR_ACTION;
      } finally {
            this.nestedMethod[this.nestedType]--;
      }

      if (this.lastAct == ERROR_ACTION) {
            return null;
      }

      return this.expressionStack[this.expressionPtr];
}
public Expression parseMemberValue(char[] source, int offset, int length, CompilationUnitDeclaration unit) {

      initialize();
      goForMemberValue();
      this.nestedMethod[this.nestedType]++;

      this.referenceContext = unit;
      this.compilationUnit = unit;

      this.scanner.setSource(source);
      this.scanner.resetTo(offset, offset + length - 1);
      try {
            parse();
      } catch (AbortCompilation ex) {
            this.lastAct = ERROR_ACTION;
      } finally {
            this.nestedMethod[this.nestedType]--;
      }

      if (this.lastAct == ERROR_ACTION) {
            return null;
      }

      return this.expressionStack[this.expressionPtr];
}
public void persistLineSeparatorPositions() {
      if (this.scanner.recordLineSeparator) {
            this.compilationUnit.compilationResult.lineSeparatorPositions = this.scanner.getLineEnds();
      }
}
/**
 * Returns this parser's problem reporter initialized with its reference context.
 * Also it is assumed that a problem is going to be reported, so initializes
 * the compilation result's line positions.
 * 
 * @return ProblemReporter
 */
public ProblemReporter problemReporter(){
      if (this.scanner.recordLineSeparator) {
            this.compilationUnit.compilationResult.lineSeparatorPositions = this.scanner.getLineEnds();
      }
      this.problemReporter.referenceContext = this.referenceContext;
      return this.problemReporter;
}
protected void pushIdentifier() {
      /*push the consumeToken on the identifier stack.
      Increase the total number of identifier in the stack.
      identifierPtr points on the next top */

      int stackLength = this.identifierStack.length;
      if (++this.identifierPtr >= stackLength) {
            System.arraycopy(
                  this.identifierStack, 0,
                  this.identifierStack = new char[stackLength + 20][], 0,
                  stackLength);
            System.arraycopy(
                  this.identifierPositionStack, 0,
                  this.identifierPositionStack = new long[stackLength + 20], 0,
                  stackLength);
      }
      this.identifierStack[this.identifierPtr] = this.scanner.getCurrentIdentifierSource();
      this.identifierPositionStack[this.identifierPtr] =
            (((long) this.scanner.startPosition) << 32) + (this.scanner.currentPosition - 1); 

      stackLength = this.identifierLengthStack.length;
      if (++this.identifierLengthPtr >= stackLength) {
            System.arraycopy(
                  this.identifierLengthStack, 0,
                  this.identifierLengthStack = new int[stackLength + 10], 0,
                  stackLength);
      }
      this.identifierLengthStack[this.identifierLengthPtr] = 1;
}
protected void pushIdentifier(int flag) {
      /*push a special flag on the stack :
      -zero stands for optional Name
      -negative number for direct ref to base types.
      identifierLengthPtr points on the top */

      int stackLength = this.identifierLengthStack.length;
      if (++this.identifierLengthPtr >= stackLength) {
            System.arraycopy(
                  this.identifierLengthStack, 0,
                  this.identifierLengthStack = new int[stackLength + 10], 0,
                  stackLength);
      }
      this.identifierLengthStack[this.identifierLengthPtr] = flag;
}
protected void pushOnAstLengthStack(int pos) {

      int stackLength = this.astLengthStack.length;
      if (++this.astLengthPtr >= stackLength) {
            System.arraycopy(
                  this.astLengthStack, 0,
                  this.astLengthStack = new int[stackLength + StackIncrement], 0,
                  stackLength);
      }
      this.astLengthStack[this.astLengthPtr] = pos;
}
protected void pushOnAstStack(ASTNode node) {
      /*add a new obj on top of the ast stack
      astPtr points on the top*/

      int stackLength = this.astStack.length;
      if (++this.astPtr >= stackLength) {
            System.arraycopy(
                  this.astStack, 0,
                  this.astStack = new ASTNode[stackLength + AstStackIncrement], 0,
                  stackLength);
            this.astPtr = stackLength;
      }
      this.astStack[this.astPtr] = node;

      stackLength = this.astLengthStack.length;
      if (++this.astLengthPtr >= stackLength) {
            System.arraycopy(
                  this.astLengthStack, 0,
                  this.astLengthStack = new int[stackLength + AstStackIncrement], 0,
                  stackLength);
      }
      this.astLengthStack[this.astLengthPtr] = 1;
}
protected void pushOnExpressionStack(Expression expr) {

      int stackLength = this.expressionStack.length;
      if (++this.expressionPtr >= stackLength) {
            System.arraycopy(
                  this.expressionStack, 0,
                  this.expressionStack = new Expression[stackLength + ExpressionStackIncrement], 0,
                  stackLength);
      }
      this.expressionStack[this.expressionPtr] = expr;

      stackLength = this.expressionLengthStack.length;
      if (++this.expressionLengthPtr >= stackLength) {
            System.arraycopy(
                  this.expressionLengthStack, 0,
                  this.expressionLengthStack = new int[stackLength + ExpressionStackIncrement], 0,
                  stackLength);
      }
      this.expressionLengthStack[this.expressionLengthPtr] = 1;
}
protected void pushOnExpressionStackLengthStack(int pos) {

      int stackLength = this.expressionLengthStack.length;
      if (++this.expressionLengthPtr >= stackLength) {
            System.arraycopy(
                  this.expressionLengthStack, 0,
                  this.expressionLengthStack = new int[stackLength + StackIncrement], 0,
                  stackLength);
      }
      this.expressionLengthStack[this.expressionLengthPtr] = pos;
}
protected void pushOnGenericsStack(ASTNode node) {
      /*add a new obj on top of the generics stack
      genericsPtr points on the top*/

      int stackLength = this.genericsStack.length;
      if (++this.genericsPtr >= stackLength) {
            System.arraycopy(
                  this.genericsStack, 0,
                  this.genericsStack = new ASTNode[stackLength + GenericsStackIncrement], 0,
                  stackLength);
      }
      this.genericsStack[this.genericsPtr] = node;

      stackLength = this.genericsLengthStack.length;
      if (++this.genericsLengthPtr >= stackLength) {
            System.arraycopy(
                  this.genericsLengthStack, 0,
                  this.genericsLengthStack = new int[stackLength + GenericsStackIncrement], 0,
                  stackLength);
      }
      this.genericsLengthStack[this.genericsLengthPtr] = 1;
}
protected void pushOnGenericsIdentifiersLengthStack(int pos) {
      int stackLength = this.genericsIdentifiersLengthStack.length;
      if (++this.genericsIdentifiersLengthPtr >= stackLength) {
            System.arraycopy(
                  this.genericsIdentifiersLengthStack, 0,
                  this.genericsIdentifiersLengthStack = new int[stackLength + GenericsStackIncrement], 0,
                  stackLength);
      }
      this.genericsIdentifiersLengthStack[this.genericsIdentifiersLengthPtr] = pos;
}
protected void pushOnGenericsLengthStack(int pos) {
      int stackLength = this.genericsLengthStack.length;
      if (++this.genericsLengthPtr >= stackLength) {
            System.arraycopy(
                  this.genericsLengthStack, 0,
                  this.genericsLengthStack = new int[stackLength + GenericsStackIncrement], 0,
                  stackLength);
      }
      this.genericsLengthStack[this.genericsLengthPtr] = pos;
}
protected void pushOnIntStack(int pos) {

      int stackLength = this.intStack.length;
      if (++this.intPtr >= stackLength) {
            System.arraycopy(
                  this.intStack, 0,
                  this.intStack = new int[stackLength + StackIncrement], 0,
                  stackLength);
      }
      this.intStack[this.intPtr] = pos;
}
protected void pushOnRealBlockStack(int i){
      
      int stackLength = this.realBlockStack.length;
      if (++this.realBlockPtr >= stackLength) {
            System.arraycopy(
                  this.realBlockStack, 0,
                  this.realBlockStack = new int[stackLength + StackIncrement], 0,
                  stackLength);
      }
      this.realBlockStack[this.realBlockPtr] = i;
}
public void recoveryExitFromVariable() {
      if(this.currentElement != null && this.currentElement.parent != null) {
            if(this.currentElement instanceof RecoveredLocalVariable) {
                  
                  int end = ((RecoveredLocalVariable)this.currentElement).localDeclaration.sourceEnd;
                  this.currentElement.updateSourceEndIfNecessary(end);
                  this.currentElement = this.currentElement.parent;
            } else if(this.currentElement instanceof RecoveredField
                  && !(this.currentElement instanceof RecoveredInitializer)) {
                        
                  int end = ((RecoveredField)this.currentElement).fieldDeclaration.sourceEnd;
                  this.currentElement.updateSourceEndIfNecessary(end);
                  this.currentElement = this.currentElement.parent;
            }
      }
}
/* Token check performed on every token shift once having entered
 * recovery mode.
 */
public void recoveryTokenCheck() {
      switch (this.currentToken) {
            case TokenNameLBRACE : 
                  RecoveredElement newElement = null;
                  if(!this.ignoreNextOpeningBrace) {
                        newElement = this.currentElement.updateOnOpeningBrace(this.scanner.startPosition - 1, this.scanner.currentPosition - 1);
                  }
                  this.lastCheckPoint = this.scanner.currentPosition;                     
                  if (newElement != null){ // null means nothing happened
                        this.restartRecovery = true; // opening brace detected
                        this.currentElement = newElement;
                  }
                  break;
            
            case TokenNameRBRACE : 
                  this.rBraceStart = this.scanner.startPosition - 1;
                  this.rBraceEnd = this.scanner.currentPosition - 1;
                  this.endPosition = this.flushCommentsDefinedPriorTo(this.rBraceEnd);
                  newElement =
                        this.currentElement.updateOnClosingBrace(this.scanner.startPosition, this.rBraceEnd);
                        this.lastCheckPoint = this.scanner.currentPosition;
                  if (newElement != this.currentElement){
                        this.currentElement = newElement;
//                      if (newElement instanceof RecoveredField && this.dietInt <= 0) {
//                            if (((RecoveredField)newElement).fieldDeclaration.type == null) { // enum constant
//                                  this.isInsideEnumConstantPart = true; // restore status
//                            }
//                      }
                  }
                  break;
            case TokenNameSEMICOLON :
                  this.endStatementPosition = this.scanner.currentPosition - 1;
                  this.endPosition = this.scanner.startPosition - 1; 
                  RecoveredType currentType = this.currentRecoveryType();
                  if(currentType != null) {
                        currentType.insideEnumConstantPart = false;
                  }
                  // fall through
            default : {
                  if (this.rBraceEnd > this.rBraceSuccessorStart && this.scanner.currentPosition != this.scanner.startPosition){
                        this.rBraceSuccessorStart = this.scanner.startPosition;
                  }
                  break;
            }
      }
      this.ignoreNextOpeningBrace = false;
}
// A P I
protected void reportSyntaxErrors(boolean isDietParse, int oldFirstToken) {
      if(this.referenceContext instanceof MethodDeclaration) {
            MethodDeclaration methodDeclaration = (MethodDeclaration) this.referenceContext;
            if(methodDeclaration.errorInSignature){
                  return;
            }
      }
      this.compilationUnit.compilationResult.lineSeparatorPositions = this.scanner.getLineEnds();
      this.scanner.recordLineSeparator = false;
      
      int start = this.scanner.initialPosition;
      int end = this.scanner.eofPosition <= Integer.MAX_VALUE ? this.scanner.eofPosition - 1 : this.scanner.eofPosition;
      if(isDietParse) {
            TypeDeclaration[] types = this.compilationUnit.types;
            
            int[][] intervalToSkip = org.eclipse.jdt.internal.compiler.parser.diagnose.RangeUtil.computeDietRange(types);
            DiagnoseParser diagnoseParser = new DiagnoseParser(this, oldFirstToken, start, end, intervalToSkip[0], intervalToSkip[1], intervalToSkip[2], this.options);
            diagnoseParser.diagnoseParse();
            
            reportSyntaxErrorsForSkippedMethod(types);
            this.scanner.resetTo(start, end);
      } else {
            DiagnoseParser diagnoseParser = new DiagnoseParser(this, oldFirstToken, start, end, this.options);
            diagnoseParser.diagnoseParse();
      }
}
private void reportSyntaxErrorsForSkippedMethod(TypeDeclaration[] types){
      if(types != null) {
            for (int i = 0; i < types.length; i++) {
                  TypeDeclaration[] memberTypes = types[i].memberTypes;
                  if(memberTypes != null) {
                        reportSyntaxErrorsForSkippedMethod(memberTypes);
                  }
                  
                  AbstractMethodDeclaration[] methods = types[i].methods;
                  if(methods != null) {
                        for (int j = 0; j < methods.length; j++) {
                              AbstractMethodDeclaration method = methods[j];
                              if(method.errorInSignature) {
                                    if(method.isAnnotationMethod()) {
                                          DiagnoseParser diagnoseParser = new DiagnoseParser(this, TokenNameQUESTION, method.declarationSourceStart, method.declarationSourceEnd, this.options);
                                          diagnoseParser.diagnoseParse();
                                    } else {
                                          DiagnoseParser diagnoseParser = new DiagnoseParser(this, TokenNameDIVIDE, method.declarationSourceStart, method.declarationSourceEnd, this.options);
                                          diagnoseParser.diagnoseParse();
                                    }
                                    
                              }
                        }
                  }
                  
                  FieldDeclaration[] fields = types[i].fields;
                  if (fields != null) {
                        int length = fields.length;
                        for (int j = 0; j < length; j++) {
                              if (fields[j] instanceof Initializer) {
                                    Initializer initializer = (Initializer)fields[j];
                                    if(initializer.errorInSignature){
                                          DiagnoseParser diagnoseParser = new DiagnoseParser(this, TokenNameRIGHT_SHIFT, initializer.declarationSourceStart, initializer.declarationSourceEnd, this.options);
                                          diagnoseParser.diagnoseParse();
                                    }
                              }
                        }
                  }
            }
      }
}
protected void resetModifiers() {
      this.modifiers = AccDefault;
      this.modifiersSourceStart = -1; // <-- see comment into modifiersFlag(int)
      this.scanner.commentPtr = -1;
}
/*
 * Reset context so as to resume to regular parse loop
 */
protected void resetStacks() {

      this.astPtr = -1;
      this.astLengthPtr = -1;
      this.expressionPtr = -1;
      this.expressionLengthPtr = -1;
      this.identifierPtr = -1;      
      this.identifierLengthPtr      = -1;
      this.intPtr = -1;
      this.nestedMethod[this.nestedType = 0] = 0; // need to reset for further reuse
      this.variablesCounter[this.nestedType] = 0;
      this.dimensions = 0 ;
      this.realBlockStack[this.realBlockPtr = 0] = 0;
      this.recoveredStaticInitializerStart = 0;
      this.listLength = 0;
      this.listTypeParameterLength = 0;
      // Fix for http://dev.eclipse.org/bugs/show_bug.cgi?id=29365
      if (this.scanner != null) this.scanner.currentLine = null;
      
      this.genericsIdentifiersLengthPtr = -1;
      this.genericsLengthPtr = -1;
      this.genericsPtr = -1;
}
/*
 * Reset context so as to resume to regular parse loop
 * If unable to reset for resuming, answers false.
 *
 * Move checkpoint location, reset internal stacks and
 * decide which grammar goal is activated.
 */
protected boolean resumeAfterRecovery() {

      // reset internal stacks 
      this.resetStacks();
      this.resetModifiers();
      
      /* attempt to move checkpoint location */
      if (!this.moveRecoveryCheckpoint()) {
            return false;
      }

      // only look for headers
      if (this.referenceContext instanceof CompilationUnitDeclaration){
            goForHeaders();
            this.diet = true; // passed this point, will not consider method bodies
            return true;
      }
      // does not know how to restart
      return false;
}
protected boolean resumeOnSyntaxError() {

      /* request recovery initialization */
      if (this.currentElement == null){
            // Reset javadoc before restart parsing after recovery
            this.javadoc = null;

            // build some recovered elements
            this.currentElement = buildInitialRecoveryState(); 
      }
      /* do not investigate deeper in recovery when no recovered element */
      if (this.currentElement == null) return false;
      
      /* manual forced recovery restart - after headers */
      if (this.restartRecovery){
            this.restartRecovery = false;
      }
      /* update recovery state with current error state of the parser */
      this.updateRecoveryState();
      
      /* attempt to reset state in order to resume to parse loop */
      return this.resumeAfterRecovery();
}
public String toString() {


      String s = "lastCheckpoint : int = " + String.valueOf(this.lastCheckPoint) + "\n"; //$NON-NLS-1$ //$NON-NLS-2$
      s = s + "identifierStack : char["+(this.identifierPtr + 1)+"][] = {"; //$NON-NLS-1$ //$NON-NLS-2$
      for (int i = 0; i <= this.identifierPtr; i++) {
            s = s + "\"" + String.valueOf(this.identifierStack[i]) + "\","; //$NON-NLS-1$ //$NON-NLS-2$
      }
      s = s + "}\n"; //$NON-NLS-1$

      s = s + "identifierLengthStack : int["+(this.identifierLengthPtr + 1)+"] = {"; //$NON-NLS-1$ //$NON-NLS-2$
      for (int i = 0; i <= this.identifierLengthPtr; i++) {
            s = s + this.identifierLengthStack[i] + ","; //$NON-NLS-1$
      }
      s = s + "}\n"; //$NON-NLS-1$

      s = s + "astLengthStack : int["+(this.astLengthPtr + 1)+"] = {"; //$NON-NLS-1$ //$NON-NLS-2$
      for (int i = 0; i <= this.astLengthPtr; i++) {
            s = s + this.astLengthStack[i] + ","; //$NON-NLS-1$
      }
      s = s + "}\n"; //$NON-NLS-1$
      s = s + "astPtr : int = " + String.valueOf(this.astPtr) + "\n"; //$NON-NLS-1$ //$NON-NLS-2$

      s = s + "intStack : int["+(this.intPtr + 1)+"] = {"; //$NON-NLS-1$ //$NON-NLS-2$
      for (int i = 0; i <= this.intPtr; i++) {
            s = s + this.intStack[i] + ","; //$NON-NLS-1$
      }
      s = s + "}\n"; //$NON-NLS-1$

      s = s + "expressionLengthStack : int["+(this.expressionLengthPtr + 1)+"] = {"; //$NON-NLS-1$ //$NON-NLS-2$
      for (int i = 0; i <= this.expressionLengthPtr; i++) {
            s = s + this.expressionLengthStack[i] + ","; //$NON-NLS-1$
      }
      s = s + "}\n"; //$NON-NLS-1$

      s = s + "expressionPtr : int = " + String.valueOf(this.expressionPtr) + "\n"; //$NON-NLS-1$ //$NON-NLS-2$
      
      s = s + "genericsIdentifiersLengthStack : int["+(this.genericsIdentifiersLengthPtr + 1)+"] = {"; //$NON-NLS-1$ //$NON-NLS-2$
      for (int i = 0; i <= this.genericsIdentifiersLengthPtr; i++) {
            s = s + this.genericsIdentifiersLengthStack[i] + ","; //$NON-NLS-1$
      }
      s = s + "}\n"; //$NON-NLS-1$
      
      s = s + "genericsLengthStack : int["+(this.genericsLengthPtr + 1)+"] = {"; //$NON-NLS-1$ //$NON-NLS-2$
      for (int i = 0; i <= this.genericsLengthPtr; i++) {
            s = s + this.genericsLengthStack[i] + ","; //$NON-NLS-1$
      }
      s = s + "}\n"; //$NON-NLS-1$

      s = s + "genericsPtr : int = " + String.valueOf(this.genericsPtr) + "\n"; //$NON-NLS-1$ //$NON-NLS-2$

      s = s + "\n\n\n----------------Scanner--------------\n" + this.scanner.toString(); //$NON-NLS-1$
      return s;

}
/*
 * Update recovery state based on current parser/scanner state
 */
protected void updateRecoveryState() {

      /* expose parser state to recovery state */
      this.currentElement.updateFromParserState();

      /* check and update recovered state based on current token,
            this action is also performed when shifting token after recovery
            got activated once. 
      */
      this.recoveryTokenCheck();
}
protected void updateSourceDeclarationParts(int variableDeclaratorsCounter) {
      //fields is a definition of fields that are grouped together like in
      //public int[] a, b[], c
      //which results into 3 fields.

      FieldDeclaration field;
      int endTypeDeclarationPosition = 
            -1 + this.astStack[this.astPtr - variableDeclaratorsCounter + 1].sourceStart; 
      for (int i = 0; i < variableDeclaratorsCounter - 1; i++) {
            //last one is special(see below)
            field = (FieldDeclaration) this.astStack[this.astPtr - i - 1];
            field.endPart1Position = endTypeDeclarationPosition;
            field.endPart2Position = -1 + this.astStack[this.astPtr - i].sourceStart;
      }
      //last one
      (field = (FieldDeclaration) this.astStack[this.astPtr]).endPart1Position = 
            endTypeDeclarationPosition; 
      field.endPart2Position = field.declarationSourceEnd;

}
protected void updateSourcePosition(Expression exp) {
      //update the source Position of the expression

      //this.intStack : int int
      //-->
      //this.intStack : 

      exp.sourceEnd = this.intStack[this.intPtr--];
      exp.sourceStart = this.intStack[this.intPtr--];
}
}

Generated by  Doxygen 1.6.0   Back to index