| /******************************************************************************* |
| * 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.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.ExtraCompilerModifiers; |
| 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, 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; |
| |
| protected boolean checkExternalizeStrings; |
| protected boolean recordStringLiterals; |
| |
| // 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 |= ExtraCompilerModifiers.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(ClassFileConstants.AccDeprecated); |
| } |
| this.javadoc = this.javadocParser.docComment; // null if check javadoc is not activated |
| if (currentElement == null) this.lastJavadocEnd = commentEnd; |
| } |
| } |
| } |
| 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*/} |
| } 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.UndocumentedEmptyBlock; |
| } |
| 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.IsAnonymousType|ASTNode.IsLocalType); |
| 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); |
| } |
| this.recordStringLiterals = false; |
| } |
| 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.ContainsAssertion; |
| } |
| typeDecl.addClinit(); |
| typeDecl.bodyEnd = this.endStatementPosition; |
| if (length == 0 && !containsComment(typeDecl.bodyStart, typeDecl.bodyEnd)) { |
| typeDecl.bits |= ASTNode.UndocumentedEmptyBlock; |
| } |
| 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.IsMemberType; |
| } |
| } else { |
| // Record that the block has a declaration for local types |
| annotationTypeDeclaration.bits |= ASTNode.IsLocalType; |
| 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--] | ClassFileConstants.AccAnnotation | ClassFileConstants.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 |= ExtraCompilerModifiers.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 arrayAllocation = new ArrayAllocationExpression(); |
| this.expressionLengthPtr -- ; |
| arrayAllocation.initializer = (ArrayInitializer) this.expressionStack[this.expressionPtr--]; |
| |
| arrayAllocation.type = getTypeReference(0); |
| arrayAllocation.type.bits |= ASTNode.IgnoreRawTypeCheck; // no need to worry about raw type usage |
| length = (this.expressionLengthStack[this.expressionLengthPtr--]); |
| this.expressionPtr -= length ; |
| System.arraycopy( |
| this.expressionStack, |
| this.expressionPtr+1, |
| arrayAllocation.dimensions = new Expression[length], |
| 0, |
| length); |
| arrayAllocation.sourceStart = this.intStack[this.intPtr--]; |
| if (arrayAllocation.initializer == null) { |
| arrayAllocation.sourceEnd = this.endPosition; |
| } else { |
| arrayAllocation.sourceEnd = arrayAllocation.initializer.sourceEnd ; |
| } |
| pushOnExpressionStack(arrayAllocation); |
| } |
| protected void consumeArrayCreationExpressionWithoutInitializer() { |
| // ArrayCreationWithoutArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs |
| // ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs |
| |
| int length; |
| ArrayAllocationExpression arrayAllocation = new ArrayAllocationExpression(); |
| arrayAllocation.type = getTypeReference(0); |
| arrayAllocation.type.bits |= ASTNode.IgnoreRawTypeCheck; // no need to worry about raw type usage |
| length = (this.expressionLengthStack[this.expressionLengthPtr--]); |
| this.expressionPtr -= length ; |
| System.arraycopy( |
| this.expressionStack, |
| this.expressionPtr+1, |
| arrayAllocation.dimensions = new Expression[length], |
| 0, |
| length); |
| arrayAllocation.sourceStart = this.intStack[this.intPtr--]; |
| if (arrayAllocation.initializer == null) { |
| arrayAllocation.sourceEnd = this.endPosition; |
| } else { |
| arrayAllocation.sourceEnd = arrayAllocation.initializer.sourceEnd ; |
| } |
| pushOnExpressionStack(arrayAllocation); |
| } |
| 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.UndocumentedEmptyBlock; |
| } |
| 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.UndocumentedEmptyBlock; // 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(TypeDeclaration.kind(typeDecl.modifiers)) { |
| case TypeDeclaration.CLASS_DECL : |
| case TypeDeclaration.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.ContainsAssertion; |
| } |
| typeDecl.addClinit(); |
| typeDecl.bodyEnd = this.endStatementPosition; |
| if (length == 0 && !containsComment(typeDecl.bodyStart, typeDecl.bodyEnd)) { |
| typeDecl.bits |= ASTNode.UndocumentedEmptyBlock; |
| } |
| |
| 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.IsMemberType; |
| } |
| } else { |
| // Record that the block has a declaration for local types |
| typeDecl.bits |= ASTNode.IsLocalType; |
| 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 |
| RecoveredType recoveredType = (RecoveredType) this.currentElement; |
| recoveredType.pendingTypeParameters = null; |
| |
| 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.UndocumentedEmptyBlock; |
| } |
| 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.UndocumentedEmptyBlock; |
| } |
| 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.UndocumentedEmptyBlock; |
| } |
| } |
| |
| //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 |= ExtraCompilerModifiers.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); |
| } |
| this.recordStringLiterals = true; |
| } |
| 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 consumeEnhancedForStatementHeaderInit(boolean hasModifiers) { |
| 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; |
| } |
| |
| 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, |
| this.intStack[this.intPtr--]); |
| pushOnAstStack(iteratorForStatement); |
| } |
| protected void consumeEnhancedForStatementHeader(){ |
| // EnhancedForStatementHeader ::= EnhancedForStatementHeaderInit ':' Expression ')' |
| final ForeachStatement statement = (ForeachStatement) this.astStack[this.astPtr]; |
| //updates are on the expression stack |
| this.expressionLengthPtr--; |
| final Expression collection = this.expressionStack[this.expressionPtr--]; |
| statement.collection = collection; |
| if(options.sourceLevel < ClassFileConstants.JDK1_5 && |
| this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) { |
| this.problemReporter().invalidUsageOfForeachStatements(statement.elementVariable, 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.IsUsefulEmptyStatement; |
| |
| 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.IsAnonymousType|ASTNode.IsLocalType); |
| 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.IsAnonymousType|ASTNode.IsLocalType); |
| 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; |
| } |
| } |
| 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.ContainsAssertion; |
| } |
| enumDeclaration.addClinit(); |
| enumDeclaration.bodyEnd = this.endStatementPosition; |
| if (length == 0 && !containsComment(enumDeclaration.bodyStart, enumDeclaration.bodyEnd)) { |
| enumDeclaration.bits |= ASTNode.UndocumentedEmptyBlock; |
| } |
| |
| 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.IsMemberType; |
| } |
| } 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--] | ClassFileConstants.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] & ~ClassFileConstants.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() { |
| // 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--])); |
| if (exp.sourceEnd == 0) { |
| //array on base type.... |
| exp.sourceEnd = this.scanner.startPosition - 1; |
| } |
| //the scanner is on the next token already.... |
| } |
| protected void consumeInstanceOfExpressionWithName() { |
| // 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); |
| 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.ContainsAssertion; |
| } |
| typeDecl.addClinit(); |
| typeDecl.bodyEnd = this.endStatementPosition; |
| if (length == 0 && !containsComment(typeDecl.bodyStart, typeDecl.bodyEnd)) { |
| typeDecl.bits |= ASTNode.UndocumentedEmptyBlock; |
| } |
| 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.IsMemberType; |
| } |
| } else { |
| // Record that the block has a declaration for local types |
| typeDecl.bits |= ASTNode.IsLocalType; |
| 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--] | ClassFileConstants.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 = ClassFileConstants.AccDefault | ClassFileConstants.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 = ClassFileConstants.AccDefault | ClassFileConstants.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 |= ExtraCompilerModifiers.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 |= ExtraCompilerModifiers.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); |
| } |
| this.recordStringLiterals = true; |
| } |
| 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 |= ExtraCompilerModifiers.AccSemicolonBody; |
| } else { |
| if (!this.diet && statements == null) { |
| if (!containsComment(md.bodyStart, this.endPosition)) { |
| md.bits |= ASTNode.UndocumentedEmptyBlock; |
| } |
| } |
| } |
| // 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 |= ExtraCompilerModifiers.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 |= ClassFileConstants.AccAnnotationDefault; |
| } |
| this.expressionPtr--; |
| this.recordStringLiterals = true; |
| } |
| |
| 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); |
| this.recordStringLiterals = false; |
| } 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); |
| this.recordStringLiterals = false; |
| } 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){ |
| boolean isType; |
| if ((isType = this.currentElement instanceof RecoveredType) |
| //|| md.modifiers != 0 |
| || (this.scanner.getLineNumber(md.returnType.sourceStart) |
| == this.scanner.getLineNumber(md.sourceStart))){ |
| if(isType) { |
| ((RecoveredType) this.currentElement).pendingTypeParameters = null; |
| } |
| 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); |
| } |
| this.recordStringLiterals = true; |
| } |
| 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, ClassFileConstants.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 & ClassFileConstants.AccAnnotation) != 0; |
| } else { |
| RecoveredType recoveredType = this.currentElement.enclosingType(); |
| if(recoveredType != null) { |
| isAnnotationMethod = (recoveredType.typeDeclaration.modifiers & ClassFileConstants.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 & ClassFileConstants.AccAnnotation) != 0; |
| } else { |
| RecoveredType recoveredType = this.currentElement.enclosingType(); |
| if(recoveredType != null) { |
| isAnnotationMethod = (recoveredType.typeDeclaration.modifiers & ClassFileConstants.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(); |
| 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("EnhancedForStatementHeaderInit ::= for LPAREN Type..."); } //$NON-NLS-1$ |
| consumeEnhancedForStatementHeaderInit(false); |
| break; |
| |
| case 514 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Modifiers"); } //$NON-NLS-1$ |
| consumeEnhancedForStatementHeaderInit(true); |
| break; |
| |
| case 515 : if (DEBUG) { System.out.println("EnhancedForStatementHeader ::=..."); } //$NON-NLS-1$ |
| consumeEnhancedForStatementHeader(); |
| break; |
| |
| case 516 : if (DEBUG) { System.out.println("SingleStaticImportDeclaration ::=..."); } //$NON-NLS-1$ |
| consumeImportDeclaration(); |
| break; |
| |
| case 517 : if (DEBUG) { System.out.println("SingleStaticImportDeclarationName ::= import static Name"); } //$NON-NLS-1$ |
| consumeSingleStaticImportDeclarationName(); |
| break; |
| |
| case 518 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclaration ::=..."); } //$NON-NLS-1$ |
| consumeImportDeclaration(); |
| break; |
| |
| case 519 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclarationName ::= import static..."); } //$NON-NLS-1$ |
| consumeStaticImportOnDemandDeclarationName(); |
| break; |
| |
| case 520 : if (DEBUG) { System.out.println("TypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$ |
| consumeTypeArguments(); |
| break; |
| |
| case 521 : if (DEBUG) { System.out.println("OnlyTypeArguments ::= LESS TypeArgumentList1"); } //$NON-NLS-1$ |
| consumeOnlyTypeArguments(); |
| break; |
| |
| case 523 : if (DEBUG) { System.out.println("TypeArgumentList1 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$ |
| consumeTypeArgumentList1(); |
| break; |
| |
| case 525 : if (DEBUG) { System.out.println("TypeArgumentList ::= TypeArgumentList COMMA TypeArgument"); } //$NON-NLS-1$ |
| consumeTypeArgumentList(); |
| break; |
| |
| case 526 : if (DEBUG) { System.out.println("TypeArgument ::= ReferenceType"); } //$NON-NLS-1$ |
| consumeTypeArgument(); |
| break; |
| |
| case 530 : if (DEBUG) { System.out.println("ReferenceType1 ::= ReferenceType GREATER"); } //$NON-NLS-1$ |
| consumeReferenceType1(); |
| break; |
| |
| case 531 : if (DEBUG) { System.out.println("ReferenceType1 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$ |
| consumeTypeArgumentReferenceType1(); |
| break; |
| |
| case 533 : if (DEBUG) { System.out.println("TypeArgumentList2 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$ |
| consumeTypeArgumentList2(); |
| break; |
| |
| case 536 : if (DEBUG) { System.out.println("ReferenceType2 ::= ReferenceType RIGHT_SHIFT"); } //$NON-NLS-1$ |
| consumeReferenceType2(); |
| break; |
| |
| case 537 : if (DEBUG) { System.out.println("ReferenceType2 ::= ClassOrInterface LESS..."); } //$NON-NLS-1$ |
| consumeTypeArgumentReferenceType2(); |
| break; |
| |
| case 539 : if (DEBUG) { System.out.println("TypeArgumentList3 ::= TypeArgumentList COMMA..."); } //$NON-NLS-1$ |
| consumeTypeArgumentList3(); |
| break; |
| |
| case 542 : if (DEBUG) { System.out.println("ReferenceType3 ::= ReferenceType UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$ |
| consumeReferenceType3(); |
| break; |
| |
| case 543 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION"); } //$NON-NLS-1$ |
| consumeWildcard(); |
| break; |
| |
| case 544 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION WildcardBounds"); } //$NON-NLS-1$ |
| consumeWildcardWithBounds(); |
| break; |
| |
| case 545 : if (DEBUG) { System.out.println("WildcardBounds ::= extends ReferenceType"); } //$NON-NLS-1$ |
| consumeWildcardBoundsExtends(); |
| break; |
| |
| case 546 : if (DEBUG) { System.out.println("WildcardBounds ::= super ReferenceType"); } //$NON-NLS-1$ |
| consumeWildcardBoundsSuper(); |
| break; |
| |
| case 547 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION GREATER"); } //$NON-NLS-1$ |
| consumeWildcard1(); |
| break; |
| |
| case 548 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION WildcardBounds1"); } //$NON-NLS-1$ |
| consumeWildcard1WithBounds(); |
| break; |
| |
| case 549 : if (DEBUG) { System.out.println("WildcardBounds1 ::= extends ReferenceType1"); } //$NON-NLS-1$ |
| consumeWildcardBounds1Extends(); |
| break; |
| |
| case 550 : if (DEBUG) { System.out.println("WildcardBounds1 ::= super ReferenceType1"); } //$NON-NLS-1$ |
| consumeWildcardBounds1Super(); |
| break; |
| |
| case 551 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION RIGHT_SHIFT"); } //$NON-NLS-1$ |
| consumeWildcard2(); |
| break; |
| |
| case 552 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION WildcardBounds2"); } //$NON-NLS-1$ |
| consumeWildcard2WithBounds(); |
| break; |
| |
| case 553 : if (DEBUG) { System.out.println("WildcardBounds2 ::= extends ReferenceType2"); } //$NON-NLS-1$ |
| consumeWildcardBounds2Extends(); |
| break; |
| |
| case 554 : if (DEBUG) { System.out.println("WildcardBounds2 ::= super ReferenceType2"); } //$NON-NLS-1$ |
| consumeWildcardBounds2Super(); |
| break; |
| |
| case 555 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$ |
| consumeWildcard3(); |
| break; |
| |
| case 556 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION WildcardBounds3"); } //$NON-NLS-1$ |
| consumeWildcard3WithBounds(); |
| break; |
| |
| case 557 : if (DEBUG) { System.out.println("WildcardBounds3 ::= extends ReferenceType3"); } //$NON-NLS-1$ |
| consumeWildcardBounds3Extends(); |
| break; |
| |
| case 558 : if (DEBUG) { System.out.println("WildcardBounds3 ::= super ReferenceType3"); } //$NON-NLS-1$ |
| consumeWildcardBounds3Super(); |
| break; |
| |
| case 559 : if (DEBUG) { System.out.println("TypeParameterHeader ::= Identifier"); } //$NON-NLS-1$ |
| consumeTypeParameterHeader(); |
| break; |
| |
| case 560 : if (DEBUG) { System.out.println("TypeParameters ::= LESS TypeParameterList1"); } //$NON-NLS-1$ |
| consumeTypeParameters(); |
| break; |
| |
| case 562 : if (DEBUG) { System.out.println("TypeParameterList ::= TypeParameterList COMMA..."); } //$NON-NLS-1$ |
| consumeTypeParameterList(); |
| break; |
| |
| case 564 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$ |
| consumeTypeParameterWithExtends(); |
| break; |
| |
| case 565 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } //$NON-NLS-1$ |
| consumeTypeParameterWithExtendsAndBounds(); |
| break; |
| |
| case 567 : if (DEBUG) { System.out.println("AdditionalBoundList ::= AdditionalBoundList..."); } //$NON-NLS-1$ |
| consumeAdditionalBoundList(); |
| break; |
| |
| case 568 : if (DEBUG) { System.out.println("AdditionalBound ::= AND ReferenceType"); } //$NON-NLS-1$ |
| consumeAdditionalBound(); |
| break; |
| |
| case 570 : if (DEBUG) { System.out.println("TypeParameterList1 ::= TypeParameterList COMMA..."); } //$NON-NLS-1$ |
| consumeTypeParameterList1(); |
| break; |
| |
| case 571 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader GREATER"); } //$NON-NLS-1$ |
| consumeTypeParameter1(); |
| break; |
| |
| case 572 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$ |
| consumeTypeParameter1WithExtends(); |
| break; |
| |
| case 573 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } //$NON-NLS-1$ |
| consumeTypeParameter1WithExtendsAndBounds(); |
| break; |
| |
| case 575 : if (DEBUG) { System.out.println("AdditionalBoundList1 ::= AdditionalBoundList..."); } //$NON-NLS-1$ |
| consumeAdditionalBoundList1(); |
| break; |
| |
| case 576 : if (DEBUG) { System.out.println("AdditionalBound1 ::= AND ReferenceType1"); } //$NON-NLS-1$ |
| consumeAdditionalBound1(); |
| break; |
| |
| case 582 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= PLUS PushPosition..."); } //$NON-NLS-1$ |
| consumeUnaryExpression(OperatorIds.PLUS); |
| break; |
| |
| case 583 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= MINUS PushPosition..."); } //$NON-NLS-1$ |
| consumeUnaryExpression(OperatorIds.MINUS); |
| break; |
| |
| case 586 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= TWIDDLE..."); } //$NON-NLS-1$ |
| consumeUnaryExpression(OperatorIds.TWIDDLE); |
| break; |
| |
| case 587 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= NOT PushPosition"); } //$NON-NLS-1$ |
| consumeUnaryExpression(OperatorIds.NOT); |
| break; |
| |
| case 590 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.MULTIPLY); |
| break; |
| |
| case 591 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name MULTIPLY..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.MULTIPLY); |
| break; |
| |
| case 592 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.DIVIDE); |
| break; |
| |
| case 593 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name DIVIDE..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.DIVIDE); |
| break; |
| |
| case 594 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.REMAINDER); |
| break; |
| |
| case 595 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name REMAINDER..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.REMAINDER); |
| break; |
| |
| case 597 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.PLUS); |
| break; |
| |
| case 598 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name PLUS..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.PLUS); |
| break; |
| |
| case 599 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.MINUS); |
| break; |
| |
| case 600 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name MINUS..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.MINUS); |
| break; |
| |
| case 602 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.LEFT_SHIFT); |
| break; |
| |
| case 603 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name LEFT_SHIFT..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.LEFT_SHIFT); |
| break; |
| |
| case 604 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.RIGHT_SHIFT); |
| break; |
| |
| case 605 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name RIGHT_SHIFT..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.RIGHT_SHIFT); |
| break; |
| |
| case 606 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT); |
| break; |
| |
| case 607 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name UNSIGNED_RIGHT_SHIFT..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.UNSIGNED_RIGHT_SHIFT); |
| break; |
| |
| case 609 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.LESS); |
| break; |
| |
| case 610 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.LESS); |
| break; |
| |
| case 611 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.GREATER); |
| break; |
| |
| case 612 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.GREATER); |
| break; |
| |
| case 613 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.LESS_EQUAL); |
| break; |
| |
| case 614 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS_EQUAL..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.LESS_EQUAL); |
| break; |
| |
| case 615 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.GREATER_EQUAL); |
| break; |
| |
| case 616 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER_EQUAL..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.GREATER_EQUAL); |
| break; |
| |
| case 618 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); } //$NON-NLS-1$ |
| consumeInstanceOfExpressionWithName(); |
| break; |
| |
| case 619 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeInstanceOfExpression(); |
| break; |
| |
| case 621 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeEqualityExpression(OperatorIds.EQUAL_EQUAL); |
| break; |
| |
| case 622 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name EQUAL_EQUAL..."); } //$NON-NLS-1$ |
| consumeEqualityExpressionWithName(OperatorIds.EQUAL_EQUAL); |
| break; |
| |
| case 623 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeEqualityExpression(OperatorIds.NOT_EQUAL); |
| break; |
| |
| case 624 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name NOT_EQUAL..."); } //$NON-NLS-1$ |
| consumeEqualityExpressionWithName(OperatorIds.NOT_EQUAL); |
| break; |
| |
| case 626 : if (DEBUG) { System.out.println("AndExpression_NotName ::= AndExpression_NotName AND..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.AND); |
| break; |
| |
| case 627 : if (DEBUG) { System.out.println("AndExpression_NotName ::= Name AND EqualityExpression"); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.AND); |
| break; |
| |
| case 629 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.XOR); |
| break; |
| |
| case 630 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::= Name XOR AndExpression"); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.XOR); |
| break; |
| |
| case 632 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.OR); |
| break; |
| |
| case 633 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::= Name OR..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.OR); |
| break; |
| |
| case 635 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.AND_AND); |
| break; |
| |
| case 636 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::= Name AND_AND..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.AND_AND); |
| break; |
| |
| case 638 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeBinaryExpression(OperatorIds.OR_OR); |
| break; |
| |
| case 639 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::= Name OR_OR..."); } //$NON-NLS-1$ |
| consumeBinaryExpressionWithName(OperatorIds.OR_OR); |
| break; |
| |
| case 641 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::=..."); } //$NON-NLS-1$ |
| consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ; |
| break; |
| |
| case 642 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::= Name QUESTION..."); } //$NON-NLS-1$ |
| consumeConditionalExpressionWithName(OperatorIds.QUESTIONCOLON) ; |
| break; |
| |
| case 646 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } //$NON-NLS-1$ |
| consumeAnnotationTypeDeclarationHeaderName() ; |
| break; |
| |
| case 647 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } //$NON-NLS-1$ |
| consumeAnnotationTypeDeclarationHeaderName() ; |
| break; |
| |
| case 648 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeader ::=..."); } //$NON-NLS-1$ |
| consumeAnnotationTypeDeclarationHeader() ; |
| break; |
| |
| case 649 : if (DEBUG) { System.out.println("AnnotationTypeDeclaration ::=..."); } //$NON-NLS-1$ |
| consumeAnnotationTypeDeclaration() ; |
| break; |
| |
| case 651 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::="); } //$NON-NLS-1$ |
| consumeEmptyAnnotationTypeMemberDeclarationsopt() ; |
| break; |
| |
| case 652 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::= NestedType..."); } //$NON-NLS-1$ |
| consumeAnnotationTypeMemberDeclarationsopt() ; |
| break; |
| |
| case 654 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarations ::=..."); } //$NON-NLS-1$ |
| consumeAnnotationTypeMemberDeclarations() ; |
| break; |
| |
| case 655 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt..."); } //$NON-NLS-1$ |
| consumeMethodHeaderNameWithTypeParameters(true); |
| break; |
| |
| case 656 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt Type..."); } //$NON-NLS-1$ |
| consumeMethodHeaderName(true); |
| break; |
| |
| case 657 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::="); } //$NON-NLS-1$ |
| consumeEmptyMethodHeaderDefaultValue() ; |
| break; |
| |
| case 658 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::= DefaultValue"); } //$NON-NLS-1$ |
| consumeMethodHeaderDefaultValue(); |
| break; |
| |
| case 659 : if (DEBUG) { System.out.println("AnnotationMethodHeader ::= AnnotationMethodHeaderName..."); } //$NON-NLS-1$ |
| consumeMethodHeader(); |
| break; |
| |
| case 660 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclaration ::=..."); } //$NON-NLS-1$ |
| consumeAnnotationTypeMemberDeclaration() ; |
| break; |
| |
| case 668 : if (DEBUG) { System.out.println("AnnotationName ::= AT Name"); } //$NON-NLS-1$ |
| consumeAnnotationName() ; |
| break; |
| |
| case 669 : if (DEBUG) { System.out.println("NormalAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$ |
| consumeNormalAnnotation() ; |
| break; |
| |
| case 670 : if (DEBUG) { System.out.println("MemberValuePairsopt ::="); } //$NON-NLS-1$ |
| consumeEmptyMemberValuePairsopt() ; |
| break; |
| |
| case 673 : if (DEBUG) { System.out.println("MemberValuePairs ::= MemberValuePairs COMMA..."); } //$NON-NLS-1$ |
| consumeMemberValuePairs() ; |
| break; |
| |
| case 674 : if (DEBUG) { System.out.println("MemberValuePair ::= SimpleName EQUAL EnterMemberValue..."); } //$NON-NLS-1$ |
| consumeMemberValuePair() ; |
| break; |
| |
| case 675 : if (DEBUG) { System.out.println("EnterMemberValue ::="); } //$NON-NLS-1$ |
| consumeEnterMemberValue() ; |
| break; |
| |
| case 676 : if (DEBUG) { System.out.println("ExitMemberValue ::="); } //$NON-NLS-1$ |
| consumeExitMemberValue() ; |
| break; |
| |
| case 678 : if (DEBUG) { System.out.println("MemberValue ::= Name"); } //$NON-NLS-1$ |
| consumeMemberValueAsName() ; |
| 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$ |
| consumeMemberValueArrayInitializer() ; |
| break; |
| |
| case 683 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$ |
| consumeEmptyMemberValueArrayInitializer() ; |
| break; |
| |
| case 684 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::= LBRACE PushLeftBrace..."); } //$NON-NLS-1$ |
| consumeEmptyMemberValueArrayInitializer() ; |
| break; |
| |
| case 686 : if (DEBUG) { System.out.println("MemberValues ::= MemberValues COMMA MemberValue"); } //$NON-NLS-1$ |
| consumeMemberValues() ; |
| break; |
| |
| case 687 : if (DEBUG) { System.out.println("MarkerAnnotation ::= AnnotationName"); } //$NON-NLS-1$ |
| consumeMarkerAnnotation() ; |
| break; |
| |
| case 688 : if (DEBUG) { System.out.println("SingleMemberAnnotation ::= AnnotationName LPAREN..."); } //$NON-NLS-1$ |
| consumeSingleMemberAnnotation() ; |
| break; |
| |
| case 689 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); } //$NON-NLS-1$ |
| consumeRecoveryMethodHeaderNameWithTypeParameters(); |
| break; |
| |
| case 690 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt Type..."); } //$NON-NLS-1$ |
| consumeRecoveryMethodHeaderName(); |
| break; |
| |
| case 691 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$ |
| consumeMethodHeader(); |
| break; |
| |
| case 692 : 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); |
| } |
| this.recordStringLiterals = true; |
| } |
| 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, ClassFileConstants.AccStatic)); |
| |
| this.modifiers = ClassFileConstants.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 = ClassFileConstants.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, ClassFileConstants.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 statement = (Statement) this.astStack[this.astPtr]; |
| this.astStack[this.astPtr] = |
| new LabeledStatement( |
| this.identifierStack[this.identifierPtr], |
| statement, |
| this.identifierPositionStack[this.identifierPtr--], |
| 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.UndocumentedEmptyBlock; |
| } |
| } |
| 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, ClassFileConstants.AccStatic)); |
| |
| this.modifiers = ClassFileConstants.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 = ClassFileConstants.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.UndocumentedEmptyBlock; // clear bit set since was diet |
| Initializer initializer = new Initializer(block, ClassFileConstants.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 */ |
| // // 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(ClassFileConstants.AccAbstract); |
| pushOnExpressionStackLengthStack(0); |
| break; |
| case TokenNamestrictfp : |
| checkAndSetModifiers(ClassFileConstants.AccStrictfp); |
| pushOnExpressionStackLengthStack(0); |
| break; |
| case TokenNamefinal : |
| checkAndSetModifiers(ClassFileConstants.AccFinal); |
| pushOnExpressionStackLengthStack(0); |
| break; |
| case TokenNamenative : |
| checkAndSetModifiers(ClassFileConstants.AccNative); |
| pushOnExpressionStackLengthStack(0); |
| break; |
| case TokenNameprivate : |
| checkAndSetModifiers(ClassFileConstants.AccPrivate); |
| pushOnExpressionStackLengthStack(0); |
| break; |
| case TokenNameprotected : |
| checkAndSetModifiers(ClassFileConstants.AccProtected); |
| pushOnExpressionStackLengthStack(0); |
| break; |
| case TokenNamepublic : |
| checkAndSetModifiers(ClassFileConstants.AccPublic); |
| pushOnExpressionStackLengthStack(0); |
| break; |
| case TokenNametransient : |
| checkAndSetModifiers(ClassFileConstants.AccTransient); |
| pushOnExpressionStackLengthStack(0); |
| break; |
| case TokenNamevolatile : |
| checkAndSetModifiers(ClassFileConstants.AccVolatile); |
| pushOnExpressionStackLengthStack(0); |
| break; |
| case TokenNamestatic : |
| checkAndSetModifiers(ClassFileConstants.AccStatic); |
| pushOnExpressionStackLengthStack(0); |
| break; |
| case TokenNamesynchronized : |
| this.synchronizedBlockSourceStart = this.scanner.startPosition; |
| checkAndSetModifiers(ClassFileConstants.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; |
| if (this.recordStringLiterals && this.checkExternalizeStrings) { |
| stringLiteral = new StringLiteral( |
| this.scanner.getCurrentTokenSourceString(), |
| this.scanner.startPosition, |
| this.scanner.currentPosition - 1, |
| this.scanner.getLineNumber(this.scanner.startPosition)); |
| this.compilationUnit.recordStringLiteral(stringLiteral); |
| } else { |
| stringLiteral = new StringLiteral( |
| this.scanner.getCurrentTokenSourceString(), |
| this.scanner.startPosition, |
| this.scanner.currentPosition - 1, |
| 0); |
| } |
| 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, ClassFileConstants.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() { |
| int startPos = this.intStack[this.intPtr--]; |
| |
| if(this.currentElement != null) { |
| if(this.currentElement instanceof RecoveredType) { |
| RecoveredType recoveredType =(RecoveredType) this.currentElement; |
| int length = this.genericsLengthStack[this.genericsLengthPtr]; |
| TypeParameter[] typeParameters = new TypeParameter[length]; |
| System.arraycopy(this.genericsStack, genericsPtr - length + 1, typeParameters, 0, length); |
| |
| recoveredType.add(typeParameters, startPos); |
| } |
| } |
| |
| |
| 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; |
| } |
| 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() { |
| this.initialize(false); |
| } |
| public void initialize(boolean initializeNLS) { |
| //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.recordStringLiterals = true; |
| final boolean checkNLS = this.options.getSeverity(CompilerOptions.NonExternalizedString) != ProblemSeverities.Ignore; |
| this.checkExternalizeStrings = checkNLS; |
| this.scanner.checkNonExternalizedStringLiterals = initializeNLS && checkNLS; |
| |
| 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*/, |
| false, /* will be set in initialize(boolean) */ |
| 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.HasLocalType; |
| return; |
| } |
| } |
| // default to reference context (case of parse method body) |
| if (this.referenceContext instanceof AbstractMethodDeclaration |
| || this.referenceContext instanceof TypeDeclaration) { |
| ((ASTNode)this.referenceContext).bits |= ASTNode.HasLocalType; |
| } |
| } |
| protected void markInitializersWithLocalType(TypeDeclaration type) { |
| if (type.fields == null || (type.bits & ASTNode.HasLocalType) == 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.HasLocalType; |
| } |
| } |
| } |
| /* |
| * 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.insideRecovery = true; |
| 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 |
| 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; |
| 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); |
| // record all nls tags in the corresponding compilation unit |
| final NLSTag[] tags = this.scanner.getNLSTags(); |
| if (tags != null) { |
| this.compilationUnit.nlsTags = tags; |
| } |
| this.scanner.checkNonExternalizedStringLiterals = false; |
| 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.UndocumentedEmptyBlock; |
| } |
| } |
| |
| 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.HasLocalType) != 0) { |
| field.bits |= ASTNode.HasLocalType; |
| } |
| } |
| // 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(true); |
| 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.UndocumentedEmptyBlock; |
| } |
| } |
| |
| // mark initializer with local type if one was found during parsing |
| if ((type.bits & ASTNode.HasLocalType) != 0) { |
| initializer.bits |= ASTNode.HasLocalType; |
| } |
| } |
| // 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 & ExtraCompilerModifiers.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.UndocumentedEmptyBlock; |
| } |
| } |
| } |
| 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 = ClassFileConstants.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; |
| |
| 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() { |
| this.checkExternalizeStrings = false; |
| this.scanner.checkNonExternalizedStringLiterals = false; |
| /* 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--]; |
| } |
| } |