[340756] [validation] False syntax error in with (x) var y;
Parser is fixed for 'with', 'white' and 'for' cases
Signed-off-by: vrubezhny <vrubezhny@exadel.com>
diff --git a/bundles/org.eclipse.wst.jsdt.core/grammar/js.g b/bundles/org.eclipse.wst.jsdt.core/grammar/js.g
index 5da7f1d..e0c0842 100644
--- a/bundles/org.eclipse.wst.jsdt.core/grammar/js.g
+++ b/bundles/org.eclipse.wst.jsdt.core/grammar/js.g
@@ -501,7 +501,7 @@
/. $putCase consumeDefaultLabel(); $break ./
/:$readableName SwitchLabel:/
-WhileStatement ::= 'while' '(' Expression ')' Statement
+WhileStatement ::= 'while' '(' Expression ')' BlockStatement
/.$putCase consumeStatementWhile() ; $break ./
/:$readableName WhileStatement:/
@@ -509,7 +509,7 @@
/.$putCase consumeStatementWhile() ; $break ./
/:$readableName WhileStatement:/
-WithStatement ::= 'with' '(' Expression ')' Statement
+WithStatement ::= 'with' '(' Expression ')' BlockStatement
/.$putCase consumeStatementWith() ; $break ./
/:$readableName WithStatement:/
@@ -521,11 +521,11 @@
/.$putCase consumeStatementDo() ; $break ./
/:$readableName DoStatement:/
-ForStatement ::= 'for' '(' ForInitopt ';' Expressionopt ';' ForUpdateopt ')' Statement
+ForStatement ::= 'for' '(' ForInitopt ';' Expressionopt ';' ForUpdateopt ')' BlockStatement
/.$putCase consumeStatementFor() ; $break ./
/:$readableName ForStatement:/
-ForStatement ::= 'for' '(' ForInInit 'in' Expression ')' Statement
+ForStatement ::= 'for' '(' ForInInit 'in' Expression ')' BlockStatement
/.$putCase consumeStatementForIn() ; $break ./
/:$readableName ForStatement:/
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/DelegateASTVisitor.java b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/DelegateASTVisitor.java
index 828bc8c..e006a6d 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/DelegateASTVisitor.java
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/DelegateASTVisitor.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2009 IBM Corporation and others.
+ * Copyright (c) 2000, 2013 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
@@ -478,8 +478,8 @@
public void endVisit(WhileStatement whileStatement, BlockScope scope) {
visitor.endVisit(whileStatement);
}
- public void endVisit(WithStatement whileStatement, BlockScope scope) {
- visitor.endVisit(whileStatement);
+ public void endVisit(WithStatement withStatement, BlockScope scope) {
+ visitor.endVisit(withStatement);
}
public boolean visit(
AllocationExpression allocationExpression,
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/Parser.java b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/Parser.java
index 3187e69..cedf049 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/Parser.java
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/Parser.java
@@ -1,7124 +1,7124 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2013 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
- * Etienne Pfister <epfister@hsr.ch> bug 224333
- *******************************************************************************/
-package org.eclipse.wst.jsdt.internal.compiler.parser;
+/*******************************************************************************
+ * Copyright (c) 2000, 2013 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
+ * Etienne Pfister <epfister@hsr.ch> bug 224333
+ *******************************************************************************/
+package org.eclipse.wst.jsdt.internal.compiler.parser;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+import java.util.Set;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.PerformanceStats;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.wst.jsdt.core.JavaScriptCore;
+import org.eclipse.wst.jsdt.core.ast.IDoStatement;
+import org.eclipse.wst.jsdt.core.compiler.CharOperation;
+import org.eclipse.wst.jsdt.core.compiler.InvalidInputException;
+import org.eclipse.wst.jsdt.core.infer.IInferEngine;
+import org.eclipse.wst.jsdt.core.infer.IInferEngineExtension;
+import org.eclipse.wst.jsdt.core.infer.InferOptions;
+import org.eclipse.wst.jsdt.core.infer.InferrenceManager;
+import org.eclipse.wst.jsdt.internal.compiler.ASTVisitor;
+import org.eclipse.wst.jsdt.internal.compiler.CompilationResult;
+import org.eclipse.wst.jsdt.internal.compiler.ast.AND_AND_Expression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ASTNode;
+import org.eclipse.wst.jsdt.internal.compiler.ast.AbstractMethodDeclaration;
+import org.eclipse.wst.jsdt.internal.compiler.ast.AbstractVariableDeclaration;
+import org.eclipse.wst.jsdt.internal.compiler.ast.AllocationExpression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.Argument;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ArrayInitializer;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ArrayQualifiedTypeReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ArrayReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ArrayTypeReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.Assignment;
+import org.eclipse.wst.jsdt.internal.compiler.ast.BinaryExpression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.Block;
+import org.eclipse.wst.jsdt.internal.compiler.ast.BreakStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.CaseStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.CombinedBinaryExpression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.CompilationUnitDeclaration;
+import org.eclipse.wst.jsdt.internal.compiler.ast.CompoundAssignment;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ConditionalExpression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ConstructorDeclaration;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ContinueStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.DebuggerStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.DoStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.DoubleLiteral;
+import org.eclipse.wst.jsdt.internal.compiler.ast.EmptyExpression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.EmptyStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.EqualExpression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ExplicitConstructorCall;
+import org.eclipse.wst.jsdt.internal.compiler.ast.Expression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.FalseLiteral;
+import org.eclipse.wst.jsdt.internal.compiler.ast.FieldDeclaration;
+import org.eclipse.wst.jsdt.internal.compiler.ast.FieldReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ForInStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ForStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.FunctionExpression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.IfStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ImportReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.Initializer;
+import org.eclipse.wst.jsdt.internal.compiler.ast.IntLiteral;
+import org.eclipse.wst.jsdt.internal.compiler.ast.IntLiteralMinValue;
+import org.eclipse.wst.jsdt.internal.compiler.ast.Javadoc;
+import org.eclipse.wst.jsdt.internal.compiler.ast.LabeledStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ListExpression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.LocalDeclaration;
+import org.eclipse.wst.jsdt.internal.compiler.ast.MessageSend;
+import org.eclipse.wst.jsdt.internal.compiler.ast.MethodDeclaration;
+import org.eclipse.wst.jsdt.internal.compiler.ast.NameReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.NullLiteral;
+import org.eclipse.wst.jsdt.internal.compiler.ast.OR_OR_Expression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ObjectGetterSetterField;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ObjectLiteral;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ObjectLiteralField;
+import org.eclipse.wst.jsdt.internal.compiler.ast.OperatorIds;
+import org.eclipse.wst.jsdt.internal.compiler.ast.PostfixExpression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.PrefixExpression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ProgramElement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.QualifiedNameReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.QualifiedTypeReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.Reference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.RegExLiteral;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ReturnStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.SingleNameReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.SingleTypeReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.Statement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.StringLiteral;
+import org.eclipse.wst.jsdt.internal.compiler.ast.SuperReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.SwitchStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ThisReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.ThrowStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.TrueLiteral;
+import org.eclipse.wst.jsdt.internal.compiler.ast.TryStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.TypeDeclaration;
+import org.eclipse.wst.jsdt.internal.compiler.ast.TypeReference;
+import org.eclipse.wst.jsdt.internal.compiler.ast.UnaryExpression;
+import org.eclipse.wst.jsdt.internal.compiler.ast.UndefinedLiteral;
+import org.eclipse.wst.jsdt.internal.compiler.ast.WhileStatement;
+import org.eclipse.wst.jsdt.internal.compiler.ast.WithStatement;
+import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
+import org.eclipse.wst.jsdt.internal.compiler.env.ICompilationUnit;
+import org.eclipse.wst.jsdt.internal.compiler.impl.CompilerOptions;
+import org.eclipse.wst.jsdt.internal.compiler.impl.ReferenceContext;
+import org.eclipse.wst.jsdt.internal.compiler.lookup.Binding;
+import org.eclipse.wst.jsdt.internal.compiler.lookup.BlockScope;
+import org.eclipse.wst.jsdt.internal.compiler.lookup.ClassScope;
+import org.eclipse.wst.jsdt.internal.compiler.lookup.ExtraCompilerModifiers;
+import org.eclipse.wst.jsdt.internal.compiler.lookup.MethodScope;
+import org.eclipse.wst.jsdt.internal.compiler.lookup.Scope;
+import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeConstants;
+import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeIds;
+import org.eclipse.wst.jsdt.internal.compiler.parser.diagnose.DiagnoseParser;
+import org.eclipse.wst.jsdt.internal.compiler.problem.AbortCompilation;
+import org.eclipse.wst.jsdt.internal.compiler.problem.AbortCompilationUnit;
+import org.eclipse.wst.jsdt.internal.compiler.problem.ProblemReporter;
+import org.eclipse.wst.jsdt.internal.compiler.problem.ProblemSeverities;
+import org.eclipse.wst.jsdt.internal.compiler.util.Messages;
+import org.eclipse.wst.jsdt.internal.compiler.util.Util;
+
+public class Parser implements ParserBasicInformation, TerminalTokens, OperatorIds, TypeIds {
+
+ private static final String PERFORMANCE__INFER_TYPES = "org.eclipse.wst.jsdt.core/perf/Parser/inferTypes"; //$NON-NLS-1$
+ private static final boolean REPORT_PERFORMANCE__INFER_TYPES = Boolean.valueOf(Platform.getDebugOption("org.eclipse.wst.jsdt.core/perfReport/Parser/inferTypes")).booleanValue(); //$NON-NLS-1$
+
+ public static final boolean DO_DIET_PARSE=false;
+
+ protected static final int THIS_CALL = ExplicitConstructorCall.This;
+
+ 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 boolean DEBUG_AUTOMATON = 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.wst.jsdt.internal.compiler.parser." + READABLE_NAMES_FILE; //$NON-NLS-1$
+ public static String readableName[] = null;
+
+ public static byte rhs[] = null;
+
+ public static int[] reverse_index = null;
+ public static char[] recovery_templates_index = null;
+ public static char[] recovery_templates = null;
+ public static char[] statements_recovery_filter = null;
+ public static byte[] state_flags = 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;
+
+
+ static boolean optionalSemicolonState[] =null;
+
+
+ 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;
+
+ // statement recovery
+// public boolean statementRecoveryEnabled = true;
+ public boolean methodRecoveryActivated = false;
+ protected boolean statementRecoveryActivated = false;
+ protected TypeDeclaration[] recoveredTypes;
+ protected int recoveredTypePtr;
+ protected int nextTypeStart;
+ protected TypeDeclaration pendingRecoveredType;
+
+ public RecoveryScanner recoveryScanner;
+
+ //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;
+
+ private boolean enteredRecoverStatements;
+
+ private int insertedSemicolonPosition=-1;
+
+ private Set errorAction = new HashSet();
+
+ private static final int UNCONSUMED_LIT_ELEMENT=0x4;
+ private static final int UNCONSUMED_ELISION=0x2;
+ private static final int WAS_ARRAY_LIT_ELEMENT=0x1;
+
+ public static final byte FLAG_EMPTY_STATEMENT = 1;
+
+ public IInferEngine[] inferenceEngines;
+
+ 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) {
+ BufferedWriter writer = null;
+ try {
+ writer = new BufferedWriter(new FileWriter(filename));
+ for (Iterator iterator = listToDump.iterator(); iterator.hasNext(); ) {
+ writer.write(String.valueOf(iterator.next()));
+ }
+ writer.flush();
+ } catch(IOException e) {
+ // ignore
+ } finally {
+ if (writer != null) {
+ try {
+ writer.close();
+ } catch (IOException e1) {
+ // ignore
+ }
+ }
+ }
+ System.out.println(filename + " creation complete"); //$NON-NLS-1$
+}
+private final static String[] buildFileForName(String filename, String contents) {
+ 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) {
+
+ 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 buildFilesForRecoveryTemplates(
+ String indexFilename,
+ String templatesFilename,
+ char[] newTerminalIndex,
+ char[] newNonTerminalIndex,
+ String[] newName,
+ char[] newLhs,
+ String[] tokens) {
+
+ int[] newReverse = computeReverseTable(newTerminalIndex, newNonTerminalIndex, newName);
+
+ char[] newRecoveyTemplatesIndex = new char[newNonTerminalIndex.length];
+ char[] newRecoveyTemplates = new char[newNonTerminalIndex.length];
+ int newRecoveyTemplatesPtr = 0;
+
+ for (int i = 0; i < tokens.length; i = i + 3) {
+ if("3".equals(tokens[i])) { //$NON-NLS-1$
+ int length = newRecoveyTemplates.length;
+ if(length == newRecoveyTemplatesPtr + 1) {
+ System.arraycopy(newRecoveyTemplates, 0, newRecoveyTemplates = new char[length * 2], 0, length);
+ }
+ newRecoveyTemplates[newRecoveyTemplatesPtr++] = 0;
+
+ int index = newLhs[Integer.parseInt(tokens[i + 1])];
+
+ newRecoveyTemplatesIndex[index] = (char)newRecoveyTemplatesPtr;
+
+ String token = tokens[i + 2].trim();
+ java.util.StringTokenizer st = new java.util.StringTokenizer(new String(token), " "); //$NON-NLS-1$
+ String[] terminalNames = new String[st.countTokens()];
+ int t = 0;
+ while (st.hasMoreTokens()) {
+ terminalNames[t++] = st.nextToken();
+ }
+
+ for (int j = 0; j < terminalNames.length; j++) {
+ int symbol = getSymbol(terminalNames[j], newName, newReverse);
+ if(symbol > -1) {
+ length = newRecoveyTemplates.length;
+ if(length == newRecoveyTemplatesPtr + 1) {
+ System.arraycopy(newRecoveyTemplates, 0, newRecoveyTemplates = new char[length * 2], 0, length);
+ }
+ newRecoveyTemplates[newRecoveyTemplatesPtr++] = (char)symbol;
+ }
+ }
+ }
+ }
+ newRecoveyTemplates[newRecoveyTemplatesPtr++] = 0;
+ System.arraycopy(newRecoveyTemplates, 0, newRecoveyTemplates = new char[newRecoveyTemplatesPtr], 0, newRecoveyTemplatesPtr);
+
+ buildFileForTable(indexFilename, newRecoveyTemplatesIndex);
+ buildFileForTable(templatesFilename, newRecoveyTemplates);
+}
+private static void buildFilesForStatementsRecoveryFilter(
+ String filename,
+ char[] newNonTerminalIndex,
+ char[] newLhs,
+ String[] tokens) {
+
+ char[] newStatementsRecoveryFilter = new char[newNonTerminalIndex.length];
+
+ for (int i = 0; i < tokens.length; i = i + 3) {
+ if("4".equals(tokens[i])) { //$NON-NLS-1$
+ int index = newLhs[Integer.parseInt(tokens[i + 1])];
+
+ newStatementsRecoveryFilter[index] = 1;
+ }
+ }
+ buildFileForTable(filename, newStatementsRecoveryFilter);
+ }
+
+private static void buildFilesForFlags(
+ String filename,
+ int size,
+ String[] tokens) {
+
+ byte[] flags = new byte[size];
+
+ for (int i = 0; i < tokens.length; i = i + 3) {
+ if("5".equals(tokens[i])) { //$NON-NLS-1$
+ int index = Integer.parseInt(tokens[i + 1]);
+ byte value =(byte) Integer.parseInt(tokens[i + 2].trim());
+ flags[index]=value;
+ }
+ }
+ buildFileForTable(filename, flags);
+ }
+
+private static void buildFileForCompliance(
+ String file,
+ int length,
+ String[] tokens) {
+
+ 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) {
+ java.io.FileOutputStream stream = null;
+ try {
+ stream = new java.io.FileOutputStream(filename);
+ stream.write(bytes);
+ } catch(IOException e) {
+ // ignore
+ } finally {
+ if (stream != null) {
+ try {
+ stream.close();
+ } catch (IOException e1) {
+ // ignore
+ }
+ }
+ }
+ System.out.println(filename + " creation complete"); //$NON-NLS-1$
+ }
+ private final static void buildFileForTable(String filename, char[] chars) {
+ 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 = null;
+ try {
+ stream = new java.io.FileOutputStream(filename);
+ stream.write(bytes);
+ } catch(IOException e) {
+ // ignore
+ } finally {
+ if (stream != null) {
+ try {
+ stream.close();
+ } catch (IOException e1) {
+ // ignore
+ }
+ }
+ }
+ System.out.println(filename + " creation complete"); //$NON-NLS-1$
+ }
+ private final static byte[] buildFileOfByteFor(String filename, String tag, String[] tokens) {
+
+ //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) {
+
+ //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) {
+
+ //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) {
+
+ //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.wst.jsdt.internal.compiler.parser.Parser.buildFilesFromLPG("d:/leapfrog/grammar/javadcl.java")]
+ char[] contents = CharOperation.NO_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$
+ char[] newTerminalIndex = 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 = CharOperation.NO_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$
+
+ buildFilesForRecoveryTemplates(
+ prefix + (++i) + ".rsc", //$NON-NLS-1$
+ prefix + (++i) + ".rsc", //$NON-NLS-1$
+ newTerminalIndex,
+ newNonTerminalIndex,
+ newName,
+ newLhs,
+ tokens);
+
+ buildFilesForStatementsRecoveryFilter(
+ prefix + (++i) + ".rsc", //$NON-NLS-1$
+ newNonTerminalIndex,
+ newLhs,
+ tokens);
+
+ buildFilesForFlags(
+ prefix + (++i) + ".rsc", //$NON-NLS-1$
+ rhs.length,
+ tokens);
+
+
+ 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);
+
+ reverse_index = computeReverseTable(terminal_index, non_terminal_index, name);
+
+ recovery_templates_index = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
+ recovery_templates = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
+
+ statements_recovery_filter = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
+ state_flags = readByteTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
+
+ base_action = lhs;
+
+ optionalSemicolonState =new boolean[base_action.length];
+ for ( i = 0; i < optionalSemicolonState.length; i++) {
+ if (base_action[i]+TokenNameSEMICOLON<term_check.length
+ && (term_check[base_action[i]+TokenNameSEMICOLON] == TokenNameSEMICOLON))
+ {
+ int act=term_action[base_action[i]+TokenNameSEMICOLON];
+ if (act>ERROR_ACTION)
+ act-=ERROR_ACTION;
+ boolean isEmptyStatementsState = false;
+ if (act<NUM_RULES)
+ isEmptyStatementsState = (state_flags[act]&FLAG_EMPTY_STATEMENT)>0;
+ if (!isEmptyStatementsState)
+ optionalSemicolonState[i]=true;
+ }
+ }
+
+}
+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 int[] computeReverseTable(char[] newTerminalIndex, char[] newNonTerminalIndex, String[] newName) {
+ int[] newReverseTable = new int[newName.length];
+ for (int j = 0; j < newName.length; j++) {
+ found : {
+ for (int k = 0; k < newTerminalIndex.length; k++) {
+ if(newTerminalIndex[k] == j) {
+ newReverseTable[j] = k;
+ break found;
+ }
+ }
+ for (int k = 0; k < newNonTerminalIndex.length; k++) {
+ if(newNonTerminalIndex[k] == j) {
+ newReverseTable[j] = -k;
+ break found;
+ }
+ }
+ }
+ }
+ return newReverseTable;
+}
+
+private static int getSymbol(String terminalName, String[] newName, int[] newReverse) {
+ for (int j = 0; j < newName.length; j++) {
+ if(terminalName.equals(newName[j])) {
+ return newReverse[j];
+ }
+ }
+ return -1;
+}
+
+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 & 1) != 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 = createJavadocParser();
+
+}
+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){
+ if (!DO_DIET_PARSE)
+ {
+ this.methodRecoveryActivated=true;
+// this.statementRecoveryActivated=true;
+ }
+ element = new RecoveredUnit(this.compilationUnit, 0, this);
+
+ /* ignore current stack state, since restarting from the beginnning
+ since could not trust simple brace count */
+ if (false){ // experimenting restart recovery from scratch
+ this.compilationUnit.currentPackage = null;
+ this.compilationUnit.imports = null;
+ this.compilationUnit.types = null;
+ this.compilationUnit.statements = null;
+ this.currentToken = 0;
+ this.listLength = 0;
+ this.listTypeParameterLength = 0;
+ this.endPosition = 0;
+ this.endStatementPosition = 0;
+ return element;
+ }
+ else
+ {
+ this.currentToken = 0;
+// if (this.astPtr<0&&this.compilationUnit.sourceEnd>0)
+// this.lastCheckPoint = this.compilationUnit.sourceEnd;
+
+ }
+
+ 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;
+ if(this.statementRecoveryActivated) {
+ element = element.add(new Block(0), 0);
+ }
+ } 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;
+
+ element = recoverAST(element);
+ if (this.statementRecoveryActivated) {
+ if (this.pendingRecoveredType != null &&
+ this.scanner.startPosition - 1 <= this.pendingRecoveredType.declarationSourceEnd) {
+ // Add the pending type to the AST if this type isn't already added in the AST.
+ element = element.add(this.pendingRecoveredType, 0);
+ this.lastCheckPoint = this.pendingRecoveredType.declarationSourceEnd + 1;
+ this.pendingRecoveredType = null;
+ }
+ }
+ ProgramElement[] compUnitStatments = this.compilationUnit.statements;
+ if (compUnitStatments!=null && compUnitStatments.length>0 &&
+ this.lastCheckPoint<compUnitStatments[compUnitStatments.length-1].sourceEnd)
+ {
+ ProgramElement programElement = compUnitStatments[compUnitStatments.length-1];
+
+ this.lastCheckPoint=((programElement instanceof Expression) ? ((Expression)programElement).statementEnd : programElement.sourceEnd)+1;
+ }
+ return element;
+}
+
+public RecoveredElement recoverAST(RecoveredElement element) {
+ for(int i = 0; i <= this.astPtr; i++){
+ ASTNode node = this.astStack[i];
+ if (node instanceof AbstractMethodDeclaration){
+ AbstractMethodDeclaration method = (AbstractMethodDeclaration) node;
+ if (method.getName()!=null)
+ {
+ if (method.declarationSourceEnd == 0){
+ element = element.add(method, 0);
+ this.lastCheckPoint = method.bodyStart;
+ } else {
+ element = element.add(method, 0);
+ this.lastCheckPoint = method.declarationSourceEnd + 1;
+ }
+ }
+ else
+ element = recoverFunctionExpression(element,method);
+ 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 LocalDeclaration){
+ LocalDeclaration localDecl = (LocalDeclaration) node;
+ if (localDecl.declarationSourceEnd == 0){
+ element = element.add(localDecl, 0);
+ if (localDecl.initialization == null){
+ this.lastCheckPoint = localDecl.sourceEnd + 1;
+ } else {
+ this.lastCheckPoint = localDecl.initialization.sourceEnd + 1;
+ }
+ } else {
+ element = element.add(localDecl, 0);
+ this.lastCheckPoint = localDecl.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 Statement){
+ Statement statement = (Statement) node;
+ if (statement.sourceEnd == 0){
+ element = element.add(statement, 1);
+ this.lastCheckPoint = statement.sourceStart;
+ } else {
+ element = element.add(statement, 0);
+ this.lastCheckPoint = statement.sourceEnd + 1;
+ }
+ continue;
+ }
+ if (node instanceof ImportReference){
+ ImportReference importRef = (ImportReference) node;
+ element = element.add(importRef, 0);
+ this.lastCheckPoint = importRef.declarationSourceEnd + 1;
+ }
+ if(this.statementRecoveryActivated) {
+ if(node instanceof Block) {
+ Block block = (Block) node;
+ element = element.add(block, 0);
+ this.lastCheckPoint = block.sourceEnd + 1;
+ } else if(node instanceof LocalDeclaration) {
+ LocalDeclaration statement = (LocalDeclaration) node;
+ element = element.add(statement, 0);
+ this.lastCheckPoint = statement.declarationSourceEnd + 1;
+ } else if(node instanceof Expression) {
+ if(node instanceof Assignment ||
+ node instanceof PrefixExpression ||
+ node instanceof PostfixExpression ||
+ node instanceof MessageSend ||
+ node instanceof AllocationExpression) {
+ // recover only specific expressions
+ Expression statement = (Expression) node;
+ element = element.add(statement, 0);
+ if(statement.statementEnd != -1) {
+ this.lastCheckPoint = statement.statementEnd + 1;
+ } else {
+ this.lastCheckPoint = statement.sourceEnd + 1;
+ }
+ }
+ } else if(node instanceof Statement) {
+ Statement statement = (Statement) node;
+ element = element.add(statement, 0);
+ this.lastCheckPoint = statement.sourceEnd + 1;
+ }
+ }
+ }
+ return element;
+}
+
+protected RecoveredElement recoverFunctionExpression(RecoveredElement element, AbstractMethodDeclaration method) {
+ int start = method.exprStackPtr;
+// int end=this.expressionPtr;
+ boolean isAssignment=true;
+ Statement expression=null;
+
+ FunctionExpression funcExpr=new FunctionExpression((MethodDeclaration)method);
+ funcExpr.sourceEnd=method.declarationSourceEnd;
+ funcExpr.sourceStart=method.sourceStart;
+
+
+ if (isAssignment && start>=0)
+ {
+ expression=new Assignment(this.expressionStack[start],funcExpr,method.sourceEnd);
+ }
+ if (expression!=null)
+ {
+ element = element.add(expression, 1);
+ if (method.declarationSourceEnd == 0){
+ element = element.add(method, 0);
+ this.lastCheckPoint = method.bodyStart;
+ } else {
+ element = element.add(method, 0);
+ this.lastCheckPoint = method.declarationSourceEnd + 1;
+ }
+ if (element instanceof RecoveredMethod)
+ element.add(new Block(0), 0);
+ }
+
+ 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)
+ // don't discard if the expression being worked on is an ObjectLiteral (see bug 322412 )
+ if (!(this.diet && this.dietInt == 0) && this.scanner.commentPtr >= 0 && !(expressionPtr >= 0 && expressionStack[expressionPtr] instanceof ObjectLiteral)) {
+ 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, boolean isShort) {
+ // 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 = new AllocationExpression();
+ 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.isShort=isShort;
+ if (!isShort)
+ {
+ alloc.sourceEnd = this.intStack[this.intPtr--]; //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.member = this.expressionStack[this.expressionPtr--];
+ this.expressionLengthPtr--;
+
+ //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--];
+ if (isShort)
+ alloc.sourceEnd=alloc.member.sourceEnd;
+ 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 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 consumeAnnotationAsModifier() {
+ Expression expression = this.expressionStack[this.expressionPtr];
+ int sourceStart = expression.sourceStart;
+ if (this.modifiersSourceStart < 0) {
+ this.modifiersSourceStart = sourceStart;
+ }
+}
+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 consumeAssignment() {
+ // Assignment ::= LeftHandSide AssignmentOperator AssignmentExpression
+ //optimize the push/pop
+
+ int op = this.intStack[this.intPtr--] ; //<--the encoded operator
+
+ this.expressionPtr -- ; this.expressionLengthPtr -- ;
+ checkComment();
+
+ if(op != EQUAL) {
+ CompoundAssignment compoundAssignment = new CompoundAssignment(
+ this.expressionStack[this.expressionPtr] ,
+ this.expressionStack[this.expressionPtr+1],
+ op,
+ this.scanner.startPosition - 1);
+ if (this.javadoc != null) {
+ compoundAssignment.javadoc = this.javadoc;
+ this.javadoc = null;
+ }
+ this.expressionStack[this.expressionPtr] = compoundAssignment;
+ }
+ else {
+ Assignment assignment = new Assignment(
+ this.expressionStack[this.expressionPtr] ,
+ this.expressionStack[this.expressionPtr+1],
+ this.scanner.startPosition - 1);
+ if (this.javadoc != null) {
+ assignment.javadoc = this.javadoc;
+ this.javadoc = null;
+ }
+ this.expressionStack[this.expressionPtr] = assignment;
+ }
+
+ if (this.pendingRecoveredType != null) {
+ // Used only in statements recovery.
+ // This is not a real assignment but a placeholder for an existing anonymous type.
+ // The assignment must be replace by the anonymous type.
+ if (this.pendingRecoveredType.allocation != null &&
+ this.scanner.startPosition - 1 <= this.pendingRecoveredType.declarationSourceEnd) {
+ this.expressionStack[this.expressionPtr] = this.pendingRecoveredType.allocation;
+ this.pendingRecoveredType = null;
+ return;
+ }
+ this.pendingRecoveredType = null;
+ }
+}
+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"
+ // look for "string1" + "string2"
+ if (this.optimizeStringLiterals) {
+ if (expr1 instanceof StringLiteral) {
+ 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 if (expr1 instanceof CombinedBinaryExpression) {
+ CombinedBinaryExpression cursor;
+ // left branch is comprised of PLUS BEs
+ // cursor is shifted upwards, while needed BEs are added
+ // on demand; past the arityMax-th
+ // consecutive BE, a CBE is inserted that holds a
+ // full-fledged references table
+ if ((cursor = (CombinedBinaryExpression)expr1).arity <
+ cursor.arityMax) {
+ cursor.left = new BinaryExpression(cursor.left,
+ cursor.right, PLUS);
+ cursor.arity++;
+ } else {
+ cursor.left = new CombinedBinaryExpression(cursor.left,
+ cursor.right, PLUS, cursor.arity);
+ cursor.arity = 0;
+ cursor.tuneArityMax();
+ }
+ cursor.right = expr2;
+ cursor.sourceEnd = expr2.sourceEnd;
+ this.expressionStack[this.expressionPtr] = cursor;
+ // BE_INSTRUMENTATION: neutralized in the released code
+// cursor.depthTracker = ((BinaryExpression)cursor.left).
+// depthTracker + 1;
+ } else if (expr1 instanceof BinaryExpression &&
+ // single out the a + b case, which is a BE
+ // instead of a CBE (slightly more than a half of
+ // strings concatenation are one-deep binary
+ // expressions)
+ ((expr1.bits & ASTNode.OperatorMASK) >>
+ ASTNode.OperatorSHIFT) == OperatorIds.PLUS) {
+ this.expressionStack[this.expressionPtr] =
+ new CombinedBinaryExpression(expr1, expr2, PLUS, 1);
+ } 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 {
+ // single out the a + b case
+ this.expressionStack[this.expressionPtr] =
+ new BinaryExpression(expr1, expr2, PLUS);
+ }
+ } else if (expr1 instanceof CombinedBinaryExpression) {
+ CombinedBinaryExpression cursor;
+ // shift cursor; create BE/CBE as needed
+ if ((cursor = (CombinedBinaryExpression)expr1).arity <
+ cursor.arityMax) {
+ cursor.left = new BinaryExpression(cursor.left,
+ cursor.right, PLUS);
+ cursor.arity++;
+ } else {
+ cursor.left = new CombinedBinaryExpression(cursor.left,
+ cursor.right, PLUS, cursor.arity);
+ cursor.arity = 0;
+ cursor.tuneArityMax();
+ }
+ cursor.right = expr2;
+ cursor.sourceEnd = expr2.sourceEnd;
+ // BE_INSTRUMENTATION: neutralized in the released code
+// cursor.depthTracker = ((BinaryExpression)cursor.left).
+// depthTracker + 1;
+ this.expressionStack[this.expressionPtr] = cursor;
+ } else if (expr1 instanceof BinaryExpression &&
+ // single out the a + b case
+ ((expr1.bits & ASTNode.OperatorMASK) >>
+ ASTNode.OperatorSHIFT) == OperatorIds.PLUS) {
+ this.expressionStack[this.expressionPtr] =
+ new CombinedBinaryExpression(expr1, expr2, PLUS, 1);
+ } else {
+ this.expressionStack[this.expressionPtr] =
+ new BinaryExpression(expr1, expr2, PLUS);
+ }
+ 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 consumeProgramElements() {
+ // BlockStatements ::= BlockStatements BlockStatement
+ concatNodeLists();
+}
+protected void consumeCallExpressionWithArguments() {
+ //optimize the push/pop
+ //FunctionInvocation ::= Primary '.' 'Identifier' '(' ArgumentListopt ')'
+
+ MessageSend m = newMessageSend();
+// m.sourceStart =
+// (int) ((m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr]) >>> 32);
+// m.selector = this.identifierStack[this.identifierPtr--];
+// this.identifierLengthPtr--;
+
+ Expression receiver = this.expressionStack[this.expressionPtr];
+ m.sourceStart = receiver.sourceStart;
+ if (receiver instanceof SingleNameReference)
+ {
+ SingleNameReference singleNameReference = (SingleNameReference)receiver;
+ m.selector=singleNameReference.token;
+ m.nameSourcePosition = (((long) singleNameReference.sourceStart) << 32)+(singleNameReference.sourceStart+m.selector.length-1);
+ receiver=null;
+
+ } else if (receiver instanceof FieldReference) {
+ FieldReference fieldReference = (FieldReference) receiver;
+ m.selector=fieldReference.token;
+ m.nameSourcePosition= (((long) (fieldReference.sourceEnd-(m.selector.length-1))) << 32)+(fieldReference.sourceEnd);
+ receiver=fieldReference.receiver;
+ }
+
+
+ m.receiver = receiver;
+ m.sourceEnd = this.intStack[this.intPtr--];
+ this.expressionStack[this.expressionPtr] = m;
+}
+protected void consumeCallExpressionWithArrayReference() {
+ this.expressionPtr--;
+ this.expressionLengthPtr--;
+ Expression exp =
+ this.expressionStack[this.expressionPtr] =
+ new ArrayReference(
+ this.expressionStack[this.expressionPtr],
+ this.expressionStack[this.expressionPtr + 1]);
+ exp.sourceEnd = this.endPosition;
+}
+protected void consumeCallExpressionWithSimpleName() {
+ FieldReference fr =
+ new FieldReference(
+ this.identifierStack[this.identifierPtr],
+ this.identifierPositionStack[this.identifierPtr--]);
+ this.identifierLengthPtr--;
+ //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 consumeCaseLabel() {
+ // SwitchLabel ::= 'case' ConstantExpression ':'
+ this.expressionLengthPtr--;
+ Expression expression = this.expressionStack[this.expressionPtr--];
+ pushOnAstStack(new CaseStatement(expression, expression.sourceEnd, this.intStack[this.intPtr--]));
+}
+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 consumeClassOrInterfaceName() {
+ pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
+ pushOnGenericsLengthStack(0); // handle type arguments
+}
+protected void consumeCompilationUnit() {
+ // JavaScriptUnit ::= 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]);
+}
+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 consumeDebuggerStatement() {
+ pushOnAstStack(new DebuggerStatement(this.intStack[this.intPtr--], this.endStatementPosition));
+}
+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 consumeEmptyBlockStatementsopt() {
+ // BlockStatementsopt ::= $empty
+ pushOnAstLengthStack(0);
+}
+protected void consumeEmptyCatchesopt() {
+ // Catchesopt ::= $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 consumeEmptyInternalCompilationUnit() {
+ // InternalCompilationUnit ::= $empty
+ // nothing to do by default
+ 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;
+ this.compilationUnit.types[0] = declaration;
+ declaration.javadoc = this.compilationUnit.javadoc;
+ }
+}
+protected void consumeEmptyProgramElements() {
+ pushOnAstLengthStack(0);
+}
+protected void consumeEmptyObjectLiteral() {
+ ObjectLiteral objectLiteral = new ObjectLiteral();
+ objectLiteral.sourceEnd = this.endStatementPosition;
+ objectLiteral.sourceStart = this.intStack[this.intPtr--];
+
+ pushOnExpressionStack(objectLiteral);
+}
+protected void consumeEmptyPropertySetParameterList() {
+ pushOnExpressionStackLengthStack(0);
+}
+protected void consumeEmptyStatement() {
+ this.intPtr--;
+ // EmptyStatement ::= ';'
+ char[] source = this.scanner.source;
+ if (this.endStatementPosition >= source.length) {
+ // this would be inserted as a fake empty statement
+ pushOnAstStack(new EmptyStatement(this.endStatementPosition, this.endStatementPosition));
+ return;
+ }
+ int sourceStart = this.endStatementPosition;
+
+ if (source[this.endStatementPosition] != ';') {
+ if(source.length > 5 && this.endStatementPosition >= 4) {
+ int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
+ int pos = this.endStatementPosition - 4;
+ while (source[pos] == 'u') {
+ pos--;
+ }
+ if (source[pos] == '\\' &&
+ !((c1 = ScannerHelper.getNumericValue(source[this.endStatementPosition - 3])) > 15
+ || c1 < 0
+ || (c2 = ScannerHelper.getNumericValue(source[this.endStatementPosition - 2])) > 15
+ || c2 < 0
+ || (c3 = ScannerHelper.getNumericValue(source[this.endStatementPosition - 1])) > 15
+ || c3 < 0
+ || (c4 = ScannerHelper.getNumericValue(source[this.endStatementPosition])) > 15
+ || c4 < 0) &&
+ ((char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4)) == ';'){
+ // we have a Unicode for the ';' (/u003B)
+ sourceStart = pos;
+ }
+ }
+ }
+ if (this.astPtr > -1) {
+ if (this.astStack[this.astPtr] instanceof IDoStatement) {
+ ASTNode node = this.astStack[this.astPtr];
+ node.setSourceEnd(this.endStatementPosition);
+ pushOnAstLengthStack(0);
+ return;
+ }
+ }
+ pushOnAstStack(new EmptyStatement(sourceStart, this.endStatementPosition));
+}
+protected void consumeEmptySwitchBlock() {
+ // SwitchBlock ::= '{' '}'
+ pushOnAstLengthStack(0);
+}
+protected void consumeEnterCompilationUnit() {
+ // EnterCompilationUnit ::= $empty
+ // do nothing by default
+}
+protected void consumeEnterVariable() {
+ // EnterVariable ::= $empty
+ // do nothing by default
+ checkComment();
+ resetModifiers();
+
+ 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);
+ int modifiersStart = this.intStack[this.intPtr--];
+ declaration.modifiers = this.intStack[this.intPtr--];
+ int varPosition = this.intStack[this.intPtr--];
+ declaration.declarationSourceStart=(modifiersStart>=0)?modifiersStart:varPosition;
+ this.expressionLengthPtr--;
+
+ // Store javadoc only on first declaration as it is the same for all ones
+ LocalDeclaration fieldDeclaration = (LocalDeclaration) 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;
+// final Annotation[] annotations = previousVariable.annotations;
+// if (annotations != null) {
+// final int annotationsLength = annotations.length;
+// System.arraycopy(annotations, 0, declaration.annotations = new Annotation[annotationsLength], 0, annotationsLength);
+// }
+ }
+
+// 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 RecoveredUnit)
+ && (this.currentToken == TokenNameDOT
+ //|| declaration.modifiers != 0
+ || (Util.getLineNumber(declaration.sourceStart, this.scanner.lineEnds, 0, this.scanner.linePtr)
+ != Util.getLineNumber((int) (namePosition >>> 32), this.scanner.lineEnds, 0, this.scanner.linePtr)))){
+ 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 {
+ LocalDeclaration fieldDecl = (LocalDeclaration) this.astStack[this.astPtr];
+ this.lastCheckPoint = fieldDecl.sourceEnd + 1;
+ this.currentElement = this.currentElement.add(fieldDecl, 0);
+// }
+ this.lastIgnoredToken = -1;
+ }
+}
+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);
+}
+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 consumeExpressionStatement() {
+ // ExpressionStatement ::= StatementExpression ';'
+ this.expressionLengthPtr--;
+ Expression expression = this.expressionStack[this.expressionPtr--];
+ expression.statementEnd = this.endStatementPosition;
+ pushOnAstStack(expression);
+}
+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--;
+ int modifierPositions=(int) (namePositions >>> 32);
+ Argument arg =
+ new Argument(
+ identifierName,
+ namePositions,
+ null,
+ ClassFileConstants.AccDefault);
+// 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);
+// }
+ if (this.options.inferOptions.saveArgumentComments)
+ {
+ handleArgumentComment(arg);
+ }
+
+
+ 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++;
+}
+
+protected void handleArgumentComment(Argument arg)
+{
+ 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 && this.scanner.commentStops[0]<0) {
+ // consider all remaining leading comments to be part of current declaration
+ int start=this.scanner.commentStarts[0];
+ int end=this.scanner.commentStops[0];
+ arg.comment=CharOperation.subarray(this.scanner.source, start+2, (-end)-2);
+ this.scanner.commentPtr=-1;
+ }
+}
+protected void consumeFormalParameterList() {
+ // FormalParameterList ::= FormalParameterList ',' FormalParameter
+ optimizedConcatNodeLists();
+}
+protected void consumeFormalParameterListopt() {
+ // FormalParameterListopt ::= $empty
+ pushOnAstLengthStack(0);
+}
+protected void consumeGetSetPropertyAssignment(boolean isSetter) {
+ // remove two expressions property name/remove an optional property set parameter list
+ // remove all statement from function body
+ this.intPtr -= 2; // int pushed by consumeNestedMethod() and consumeOpenBlock() (called inside consumeMethodBody())
+ int length = this.astLengthStack[this.astLengthPtr--];
+ Statement[] statements = new Statement[length];
+ this.astPtr -= length;
+ System.arraycopy(
+ this.astStack,
+ this.astPtr + 1,
+ statements,
+ 0,
+ length);
+ Expression varName = null;
+ if (isSetter) {
+ this.expressionLengthPtr--;
+ varName = this.expressionStack[this.expressionPtr--];
+ }
+ // property name
+ this.expressionLengthPtr--;
+ Expression propertyName = this.expressionStack[this.expressionPtr--];
+ // set or get
+ this.expressionLengthPtr--;
+ Expression expression = this.expressionStack[this.expressionPtr--];
+ int end = this.endStatementPosition;
+ int start = expression.sourceStart;
+
+ if (expression instanceof SingleNameReference) {
+ SingleNameReference reference = (SingleNameReference) expression;
+ if (isSetter) {
+ if (!CharOperation.equals(reference.token, "set".toCharArray())) {
+ // report error
+ //this.problemReporter().invalidValueForGetterSetter(expression, true);
+ }
+ } else {
+ if (!CharOperation.equals(reference.token, "get".toCharArray())) {
+ // report error
+ //this.problemReporter().invalidValueForGetterSetter(expression, false);
+ }
+ }
+ }
+ ObjectGetterSetterField getterSetterField = new ObjectGetterSetterField(propertyName, statements, varName, start, end);
+ pushOnExpressionStack(getterSetterField);
+}
+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) {
+ this.compilationUnit.statements = new ProgramElement[length];
+ this.astPtr -= length;
+ System.arraycopy(this.astStack, this.astPtr + 1, this.compilationUnit.statements, 0, length);
+ }
+}
+protected void consumeLabel() {
+ // Do nothing
+}
+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];
+ AbstractVariableDeclaration nextDeclaration =null;
+ for (int i = 0; i<variableDeclaratorsCounter; i++) {
+ AbstractVariableDeclaration localDeclaration = (AbstractVariableDeclaration) this.astStack[this.astPtr - i];
+ localDeclaration.declarationSourceEnd = this.endStatementPosition;
+ localDeclaration.declarationEnd = this.endStatementPosition; // semi-colon included
+ localDeclaration.nextLocal=nextDeclaration;
+ nextDeclaration=localDeclaration;
+ }
+ this.astPtr-=variableDeclaratorsCounter-1;
+ this.astLengthStack[this.astLengthPtr]=1;
+ this.lastCheckPoint = endStatementPosition+1;
+
+}
+protected void consumeMemberExpressionWithArrayReference() {
+ this.expressionPtr--;
+ this.expressionLengthPtr--;
+ Expression exp =
+ this.expressionStack[this.expressionPtr] =
+ new ArrayReference(
+ this.expressionStack[this.expressionPtr],
+ this.expressionStack[this.expressionPtr + 1]);
+ exp.sourceEnd = this.endPosition;
+}
+protected void consumeMemberExpressionWithSimpleName() {
+ FieldReference fr =
+ new FieldReference(
+ this.identifierStack[this.identifierPtr],
+ this.identifierPositionStack[this.identifierPtr--]);
+ this.identifierLengthPtr--;
+ //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 consumeMethodBody() {
+ // MethodBody ::= NestedMethod '{' BlockStatementsopt '}'
+ this.nestedMethod[this.nestedType] --;
+}
+protected void consumeMethodDeclaration(boolean isNotAbstract) {
+ // FunctionDeclaration ::= MethodHeader MethodBody
+ // AbstractMethodDeclaration ::= MethodHeader ';'
+
+ /*
+ this.astStack : modifiers arguments throws statements
+ this.identifierStack : type name
+ this.intStack : dim dim dim
+ ==>
+ this.astStack : FunctionDeclaration
+ this.identifierStack :
+ this.intStack :
+ */
+
+
+ this.nestedType--;
+ 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 && this.dietInt == 0) && statements == null && !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.sourceEnd = 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;
+ }
+ else if (currentToken != TokenNameSEMICOLON) { // insert semicolon
+ currentToken = TokenNameSEMICOLON;
+ scanner.pushBack();
+ }
+ // 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;
+// }
+ } else if(this.currentToken == TokenNameLBRACE) {
+ if (this.currentElement instanceof RecoveredMethod &&
+ ((RecoveredMethod)this.currentElement).methodDeclaration != method) {
+ this.ignoreNextOpeningBrace = true;
+ this.currentElement.bracketBalance++;
+ } }
+ this.restartRecovery = true; // used to avoid branching back into the regular automaton
+ }
+}
+protected void consumeMethodHeaderName(boolean isAnonymous) {
+ // 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);
+// }
+
+ md.exprStackPtr=this.expressionPtr;
+ //name
+ long selectorSource =-1;
+ if (!isAnonymous)
+ {
+ md.setSelector(this.identifierStack[this.identifierPtr]);
+ selectorSource = this.identifierPositionStack[this.identifierPtr--];
+ this.identifierLengthPtr--;
+ }
+
+
+ if (this.nestedType>0)
+ markEnclosingMemberWithLocalType();
+
+ //type
+// md.returnType = getTypeReference(this.intStack[this.intPtr--]);
+ //modifiers
+ int functionPos = this.intStack[this.intPtr--];
+ int modifierPos = this.intStack[this.intPtr--];
+ md.declarationSourceStart = (functionPos>modifierPos)? modifierPos:functionPos;
+ 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
+ if (selectorSource>=0)
+ md.sourceStart = (int) (selectorSource >>> 32);
+ else
+ md.sourceStart=md.declarationSourceStart;
+ pushOnAstStack(md);
+ md.sourceEnd = this.lParenPos;
+ md.bodyStart = this.lParenPos+1;
+ this.listLength = 0; // initialize this.listLength before reading parameters/throws
+
+
+
+
+ incrementNestedType();
+
+ // recovery
+ if (this.currentElement != null){
+ if (this.currentElement instanceof RecoveredType
+ //|| md.modifiers != 0
+ || true/* (this.scanner.getLineNumber(md.returnType.sourceStart)
+ == this.scanner.getLineNumber(md.sourceStart))*/){
+ this.lastCheckPoint = md.bodyStart;
+ this.currentElement = this.currentElement.add(md, 0);
+ this.lastIgnoredToken = -1;
+ } else {
+ this.lastCheckPoint = md.sourceStart;
+ this.restartRecovery = true;
+ }
+ }
+}
+protected void consumeMethodHeaderRightParen() {
+ // MethodHeaderParameters ::= FormalParameterListopt ')'
+ int length = this.astLengthStack[this.astLengthPtr--];
+ this.astPtr -= length;
+ AbstractMethodDeclaration md = (AbstractMethodDeclaration) this.astStack[this.astPtr];
+ md.sourceEnd = this.rParenPos;
+ //arguments
+ if (length != 0) {
+ System.arraycopy(
+ this.astStack,
+ this.astPtr + 1,
+ md.arguments = new Argument[length],
+ 0,
+ length);
+ }
+ md.bodyStart = this.rParenPos+1;
+ this.listLength = 0; // reset this.listLength after having read all parameters
+ // recovery
+ if (this.currentElement != null){
+ this.lastCheckPoint = md.bodyStart;
+ if (this.currentElement.parseTree() == md) return;
+
+ // might not have been attached yet - in some constructor scenarii
+ if (md.isConstructor()){
+ if ((length != 0)
+ || (this.currentToken == TokenNameLBRACE)
+ || (this.currentToken == TokenNamethrows)){
+ this.currentElement = this.currentElement.add(md, 0);
+ this.lastIgnoredToken = -1;
+ }
+ }
+ }
+}
+protected void consumeModifiers2() {
+ this.expressionLengthStack[this.expressionLengthPtr - 1] += this.expressionLengthStack[this.expressionLengthPtr--];
+}
+protected void consumeNestedMethod() {
+ // NestedMethod ::= $empty
+ jumpOverMethodBody();
+ this.nestedMethod[this.nestedType] ++;
+ pushOnIntStack(this.scanner.currentPosition);
+ consumeOpenBlock();
+}
+protected void consumeNestedType() {
+ // NestedType ::= $empty
+ incrementNestedType();
+}
+protected void incrementNestedType() {
+ 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 consumeNewExpression() {
+ classInstanceCreation(false, true);
+}
+protected void consumeNewMemberExpressionWithArguments() {
+ classInstanceCreation(false, false);
+}
+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 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 consumePrimaryNoNewArrayThis() {
+ // PrimaryNoNewArray ::= 'this'
+ pushOnExpressionStack(new ThisReference(this.intStack[this.intPtr--], this.endPosition));
+}
+protected void consumePrimarySimpleName() {
+ // PrimaryNoNewArray ::= SimpleName
+ pushOnExpressionStack(getUnspecifiedReferenceOptimized());
+}
+protected void consumePropertyAssignment() {
+ // MemberValuePair ::= SimpleName '=' MemberValue
+ this.modifiersSourceStart=-1;
+ this.checkComment();
+ this.resetModifiers();
+
+ Expression value = this.expressionStack[this.expressionPtr--];
+ this.expressionLengthPtr--;
+
+ Expression field = this.expressionStack[this.expressionPtr--];
+ this.expressionLengthPtr--;
+ int end = value.sourceEnd;
+ int start = field.sourceStart;
+
+ ObjectLiteralField literalField = new ObjectLiteralField(field, value, start, end);
+ pushOnExpressionStack(literalField);
+
+ if (this.javadoc!=null) {
+ literalField.javaDoc = this.javadoc;
+ }
+ else if (value instanceof FunctionExpression)
+ {
+ MethodDeclaration methodDeclaration = ((FunctionExpression)value).methodDeclaration;
+ literalField.javaDoc=methodDeclaration.javadoc;
+ methodDeclaration.javadoc=null;
+ }
+ this.javadoc = null;
+
+ // discard obsolete comments while inside methods or fields initializer (see bug 74369)
+ if (!(this.diet && this.dietInt==0) && this.scanner.commentPtr >= 0) {
+ flushCommentsDefinedPriorTo(literalField.sourceEnd);
+ }
+ resetModifiers();
+}
+protected void consumePropertyName() {
+ pushOnExpressionStack(getUnspecifiedReferenceOptimized());
+}
+protected void consumePropertyNameAndValueList() {
+ concatExpressionLists();
+}
+protected void consumePropertySetParameterList() {
+ pushOnExpressionStack(getUnspecifiedReferenceOptimized());
+}
+protected void consumePushLeftBrace() {
+ pushOnIntStack(this.endPosition); // modifiers
+}
+
+protected void consumeArrayLiteralHeader() {
+ pushOnIntStack(this.endPosition); // modifiers
+ pushOnIntStack(0); // numExprs
+}
+protected void consumePushModifiers() {
+ 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(false);
+}
+protected void consumeRestoreDiet() {
+ // RestoreDiet ::= $empty
+ this.dietInt--;
+}
+protected void consumeRightParen() {
+ // PushRPAREN ::= ')'
+ pushOnIntStack(this.rParenPos);
+}
+private void consumeFunctionExpression() {
+
+ consumeMethodDeclaration(true);
+ MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr--];
+ this.astLengthPtr--;
+ FunctionExpression funcExpr=new FunctionExpression(md);
+ funcExpr.sourceEnd=md.declarationSourceEnd;
+ funcExpr.sourceStart=md.declarationSourceStart;
+ pushOnExpressionStack(funcExpr);
+}
+
+private void consumeStatementForIn() {
+// int length;
+ Expression collection = null;
+ Statement iteratorVar;
+ boolean scope = true;
+
+ //statements
+ this.astLengthPtr--;
+ Statement statement = (Statement) this.astStack[this.astPtr--];
+
+ if (this.expressionLengthStack[this.expressionLengthPtr--] != 0)
+ collection = this.expressionStack[this.expressionPtr--];
+
+ this.astLengthPtr--;
+ iteratorVar = (Statement) this.astStack[this.astPtr--];
+ pushOnAstStack(
+ new ForInStatement(
+ iteratorVar,
+ collection,
+ statement,
+ scope,
+ this.intStack[this.intPtr--],
+ this.endStatementPosition));
+
+}
+
+private void consumeArrayLiteralList() {
+ concatExpressionLists();
+ this.intStack[this.intPtr]&= ~(UNCONSUMED_ELISION|UNCONSUMED_LIT_ELEMENT);
+}
+private void consumeArrayLiteralListOne() {
+ if ( (this.intStack[this.intPtr]&UNCONSUMED_ELISION)!=0)
+ {
+ concatExpressionLists();
+ this.intStack[this.intPtr]&= ~(UNCONSUMED_ELISION|UNCONSUMED_LIT_ELEMENT);
+ }
+
+
+}
+
+private void consumeListExpression() {
+ this.expressionPtr--;
+ this.expressionLengthPtr--;
+ Expression expr1 = this.expressionStack[this.expressionPtr];
+ Expression expr2 = this.expressionStack[this.expressionPtr + 1];
+ this.expressionStack[this.expressionPtr] =
+ new ListExpression(
+ expr1,
+ expr2);
+
+}
+
+protected void consumePostDoc() {
+
+ if (this.options.inferOptions.docLocation==InferOptions.DOC_LOCATION_AFTER)
+ {
+
+ }
+}
+
+//This method is part of an automatic generation : do NOT edit-modify
+protected void consumeRule(int act) {
+switch ( act ) {
+ case 23 : if (DEBUG) { System.out.println("CompilationUnit ::= EnterCompilationUnit..."); } //$NON-NLS-1$
+ consumeCompilationUnit();
+ break;
-import java.io.BufferedInputStream;
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Locale;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-import java.util.Set;
+ case 24 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ProgramElements"); } //$NON-NLS-1$
+ consumeInternalCompilationUnitWithTypes();
+ break;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.PerformanceStats;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.wst.jsdt.core.JavaScriptCore;
-import org.eclipse.wst.jsdt.core.ast.IDoStatement;
-import org.eclipse.wst.jsdt.core.compiler.CharOperation;
-import org.eclipse.wst.jsdt.core.compiler.InvalidInputException;
-import org.eclipse.wst.jsdt.core.infer.IInferEngine;
-import org.eclipse.wst.jsdt.core.infer.IInferEngineExtension;
-import org.eclipse.wst.jsdt.core.infer.InferOptions;
-import org.eclipse.wst.jsdt.core.infer.InferrenceManager;
-import org.eclipse.wst.jsdt.internal.compiler.ASTVisitor;
-import org.eclipse.wst.jsdt.internal.compiler.CompilationResult;
-import org.eclipse.wst.jsdt.internal.compiler.ast.AND_AND_Expression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ASTNode;
-import org.eclipse.wst.jsdt.internal.compiler.ast.AbstractMethodDeclaration;
-import org.eclipse.wst.jsdt.internal.compiler.ast.AbstractVariableDeclaration;
-import org.eclipse.wst.jsdt.internal.compiler.ast.AllocationExpression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.Argument;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ArrayInitializer;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ArrayQualifiedTypeReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ArrayReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ArrayTypeReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.Assignment;
-import org.eclipse.wst.jsdt.internal.compiler.ast.BinaryExpression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.Block;
-import org.eclipse.wst.jsdt.internal.compiler.ast.BreakStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.CaseStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.CombinedBinaryExpression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.CompilationUnitDeclaration;
-import org.eclipse.wst.jsdt.internal.compiler.ast.CompoundAssignment;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ConditionalExpression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ConstructorDeclaration;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ContinueStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.DebuggerStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.DoStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.DoubleLiteral;
-import org.eclipse.wst.jsdt.internal.compiler.ast.EmptyExpression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.EmptyStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.EqualExpression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ExplicitConstructorCall;
-import org.eclipse.wst.jsdt.internal.compiler.ast.Expression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.FalseLiteral;
-import org.eclipse.wst.jsdt.internal.compiler.ast.FieldDeclaration;
-import org.eclipse.wst.jsdt.internal.compiler.ast.FieldReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ForInStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ForStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.FunctionExpression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.IfStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ImportReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.Initializer;
-import org.eclipse.wst.jsdt.internal.compiler.ast.IntLiteral;
-import org.eclipse.wst.jsdt.internal.compiler.ast.IntLiteralMinValue;
-import org.eclipse.wst.jsdt.internal.compiler.ast.Javadoc;
-import org.eclipse.wst.jsdt.internal.compiler.ast.LabeledStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ListExpression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.LocalDeclaration;
-import org.eclipse.wst.jsdt.internal.compiler.ast.MessageSend;
-import org.eclipse.wst.jsdt.internal.compiler.ast.MethodDeclaration;
-import org.eclipse.wst.jsdt.internal.compiler.ast.NameReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.NullLiteral;
-import org.eclipse.wst.jsdt.internal.compiler.ast.OR_OR_Expression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ObjectGetterSetterField;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ObjectLiteral;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ObjectLiteralField;
-import org.eclipse.wst.jsdt.internal.compiler.ast.OperatorIds;
-import org.eclipse.wst.jsdt.internal.compiler.ast.PostfixExpression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.PrefixExpression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ProgramElement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.QualifiedNameReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.QualifiedTypeReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.Reference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.RegExLiteral;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ReturnStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.SingleNameReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.SingleTypeReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.Statement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.StringLiteral;
-import org.eclipse.wst.jsdt.internal.compiler.ast.SuperReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.SwitchStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ThisReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.ThrowStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.TrueLiteral;
-import org.eclipse.wst.jsdt.internal.compiler.ast.TryStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.TypeDeclaration;
-import org.eclipse.wst.jsdt.internal.compiler.ast.TypeReference;
-import org.eclipse.wst.jsdt.internal.compiler.ast.UnaryExpression;
-import org.eclipse.wst.jsdt.internal.compiler.ast.UndefinedLiteral;
-import org.eclipse.wst.jsdt.internal.compiler.ast.WhileStatement;
-import org.eclipse.wst.jsdt.internal.compiler.ast.WithStatement;
-import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
-import org.eclipse.wst.jsdt.internal.compiler.env.ICompilationUnit;
-import org.eclipse.wst.jsdt.internal.compiler.impl.CompilerOptions;
-import org.eclipse.wst.jsdt.internal.compiler.impl.ReferenceContext;
-import org.eclipse.wst.jsdt.internal.compiler.lookup.Binding;
-import org.eclipse.wst.jsdt.internal.compiler.lookup.BlockScope;
-import org.eclipse.wst.jsdt.internal.compiler.lookup.ClassScope;
-import org.eclipse.wst.jsdt.internal.compiler.lookup.ExtraCompilerModifiers;
-import org.eclipse.wst.jsdt.internal.compiler.lookup.MethodScope;
-import org.eclipse.wst.jsdt.internal.compiler.lookup.Scope;
-import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeConstants;
-import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeIds;
-import org.eclipse.wst.jsdt.internal.compiler.parser.diagnose.DiagnoseParser;
-import org.eclipse.wst.jsdt.internal.compiler.problem.AbortCompilation;
-import org.eclipse.wst.jsdt.internal.compiler.problem.AbortCompilationUnit;
-import org.eclipse.wst.jsdt.internal.compiler.problem.ProblemReporter;
-import org.eclipse.wst.jsdt.internal.compiler.problem.ProblemSeverities;
-import org.eclipse.wst.jsdt.internal.compiler.util.Messages;
-import org.eclipse.wst.jsdt.internal.compiler.util.Util;
+ case 25 : if (DEBUG) { System.out.println("InternalCompilationUnit ::="); } //$NON-NLS-1$
+ consumeEmptyInternalCompilationUnit();
+ break;
-public class Parser implements ParserBasicInformation, TerminalTokens, OperatorIds, TypeIds {
+ case 26 : if (DEBUG) { System.out.println("EnterCompilationUnit ::="); } //$NON-NLS-1$
+ consumeEnterCompilationUnit();
+ break;
- private static final String PERFORMANCE__INFER_TYPES = "org.eclipse.wst.jsdt.core/perf/Parser/inferTypes"; //$NON-NLS-1$
- private static final boolean REPORT_PERFORMANCE__INFER_TYPES = Boolean.valueOf(Platform.getDebugOption("org.eclipse.wst.jsdt.core/perfReport/Parser/inferTypes")).booleanValue(); //$NON-NLS-1$
+ case 30 : if (DEBUG) { System.out.println("CatchHeader ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$
+ consumeCatchHeader();
+ break;
- public static final boolean DO_DIET_PARSE=false;
+ case 32 : if (DEBUG) { System.out.println("VariableDeclarators ::= VariableDeclarators COMMA..."); } //$NON-NLS-1$
+ consumeVariableDeclarators();
+ break;
- protected static final int THIS_CALL = ExplicitConstructorCall.This;
+ case 34 : if (DEBUG) { System.out.println("VariableDeclaratorsNoIn ::= VariableDeclaratorsNoIn COMMA"); } //$NON-NLS-1$
+ consumeVariableDeclarators();
+ break;
- 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;
+ case 39 : if (DEBUG) { System.out.println("EnterVariable ::="); } //$NON-NLS-1$
+ consumeEnterVariable();
+ break;
- public static short check_table[] = null;
- public static final int CurlyBracket = 2;
- private static final boolean DEBUG = false;
- private static final boolean DEBUG_AUTOMATON = 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;
+ case 40 : if (DEBUG) { System.out.println("ExitVariableWithInitialization ::="); } //$NON-NLS-1$
+ consumeExitVariableWithInitialization();
+ break;
- protected final static int GenericsStackIncrement = 10;
+ case 41 : if (DEBUG) { System.out.println("ExitVariableWithoutInitialization ::="); } //$NON-NLS-1$
+ consumeExitVariableWithoutInitialization();
+ break;
- 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;
+ case 42 : if (DEBUG) { System.out.println("ForceNoDiet ::="); } //$NON-NLS-1$
+ consumeForceNoDiet();
+ break;
- 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.wst.jsdt.internal.compiler.parser." + READABLE_NAMES_FILE; //$NON-NLS-1$
- public static String readableName[] = null;
+ case 43 : if (DEBUG) { System.out.println("RestoreDiet ::="); } //$NON-NLS-1$
+ consumeRestoreDiet();
+ break;
- public static byte rhs[] = null;
+ case 47 : if (DEBUG) { System.out.println("FunctionExpression ::= FunctionExpressionHeader..."); } //$NON-NLS-1$
+ // set to true to consume a method with a body
+consumeFunctionExpression();
+ break;
- public static int[] reverse_index = null;
- public static char[] recovery_templates_index = null;
- public static char[] recovery_templates = null;
- public static char[] statements_recovery_filter = null;
- public static byte[] state_flags = null;
+ case 48 : if (DEBUG) { System.out.println("FunctionExpressionHeader ::= FunctionExpressionHeaderName"); } //$NON-NLS-1$
+ consumeMethodHeader();
+ break;
- public static long rules_compliance[] = null;
+ case 49 : if (DEBUG) { System.out.println("FunctionExpressionHeaderName ::= Modifiersopt function..."); } //$NON-NLS-1$
+ consumeMethodHeaderName(false);
+ break;
- public static final int RoundBracket = 0;
+ case 50 : if (DEBUG) { System.out.println("FunctionExpressionHeaderName ::= Modifiersopt function..."); } //$NON-NLS-1$
+ consumeMethodHeaderName(true);
+ break;
- public static byte scope_la[] = null;
- public static char scope_lhs[] = null;
+ case 52 : if (DEBUG) { System.out.println("MethodDeclaration ::= MethodHeader MethodBody"); } //$NON-NLS-1$
+ // set to true to consume a method with a body
+consumeMethodDeclaration(true);
+ break;
- public static char scope_prefix[] = null;
- public static char scope_rhs[] = null;
- public static char scope_state[] = null;
+ case 53 : if (DEBUG) { System.out.println("AbstractMethodDeclaration ::= MethodHeader SEMICOLON"); } //$NON-NLS-1$
+ // set to false to consume a method without body
+consumeMethodDeclaration(false);
+ break;
- public static char scope_state_set[] = null;
- public static char scope_suffix[] = null;
- public static final int SquareBracket = 1;
+ case 54 : if (DEBUG) { System.out.println("MethodHeader ::= MethodHeaderName FormalParameterListopt"); } //$NON-NLS-1$
+ consumeMethodHeader();
+ break;
- //internal data for the automat
- protected final static int StackIncrement = 255;
+ case 55 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt function Identifier..."); } //$NON-NLS-1$
+ consumeMethodHeaderName(false);
+ break;
- public static char term_action[] = null;
- public static byte term_check[] = null;
+ case 56 : if (DEBUG) { System.out.println("MethodHeaderRightParen ::= RPAREN"); } //$NON-NLS-1$
+ consumeMethodHeaderRightParen();
+ break;
- public static char terminal_index[] = null;
+ case 58 : if (DEBUG) { System.out.println("FormalParameterList ::= FormalParameterList COMMA..."); } //$NON-NLS-1$
+ consumeFormalParameterList();
+ break;
- private static final String UNEXPECTED_EOF = "Unexpected End Of File" ; //$NON-NLS-1$
- public static boolean VERBOSE_RECOVERY = false;
+ case 59 : if (DEBUG) { System.out.println("FormalParameter ::= VariableDeclaratorId"); } //$NON-NLS-1$
+ consumeFormalParameter(false);
+ break;
+ case 60 : if (DEBUG) { System.out.println("MethodBody ::= NestedMethod LBRACE PostDoc..."); } //$NON-NLS-1$
+ consumeMethodBody();
+ break;
- static boolean optionalSemicolonState[] =null;
+ case 61 : if (DEBUG) { System.out.println("NestedMethod ::="); } //$NON-NLS-1$
+ consumeNestedMethod();
+ break;
+ case 62 : if (DEBUG) { System.out.println("PostDoc ::="); } //$NON-NLS-1$
+ consumePostDoc();
+ break;
- 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
+ case 63 : if (DEBUG) { System.out.println("PushLeftBraceObjectLiteral ::="); } //$NON-NLS-1$
+ consumePushLeftBrace();
+ break;
- // 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];
+ case 64 : if (DEBUG) { System.out.println("Block ::= OpenBlock LBRACE BlockStatementsopt RBRACE"); } //$NON-NLS-1$
+ consumeBlock();
+ break;
- protected boolean hasError;
- protected boolean hasReportedError;
+ case 65 : if (DEBUG) { System.out.println("OpenBlock ::="); } //$NON-NLS-1$
+ consumeOpenBlock() ;
+ break;
- //identifiers stacks
- protected int identifierLengthPtr;
- protected int[] identifierLengthStack;
- protected long[] identifierPositionStack;
- protected int identifierPtr;
- protected char[][] identifierStack;
+ case 67 : if (DEBUG) { System.out.println("ProgramElements ::= ProgramElements ProgramElement"); } //$NON-NLS-1$
+ consumeProgramElements() ;
+ break;
- protected boolean ignoreNextOpeningBrace;
- //positions , dimensions , .... (int stacks)
- protected int intPtr;
- protected int[] intStack;
- public int lastAct ; //handle for multiple parsing goals
+ case 70 : if (DEBUG) { System.out.println("BlockStatements ::= BlockStatements BlockStatement"); } //$NON-NLS-1$
+ consumeBlockStatements() ;
+ break;
- //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;
+ case 74 : if (DEBUG) { System.out.println("LocalVariableDeclarationStatement ::=..."); } //$NON-NLS-1$
+ consumeLocalVariableDeclarationStatement();
+ break;
- // statement recovery
-// public boolean statementRecoveryEnabled = true;
- public boolean methodRecoveryActivated = false;
- protected boolean statementRecoveryActivated = false;
- protected TypeDeclaration[] recoveredTypes;
- protected int recoveredTypePtr;
- protected int nextTypeStart;
- protected TypeDeclaration pendingRecoveredType;
+ case 75 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= var PushModifiers..."); } //$NON-NLS-1$
+ consumeLocalVariableDeclaration();
+ break;
- public RecoveryScanner recoveryScanner;
+ case 76 : if (DEBUG) { System.out.println("LocalVariableDeclarationNoIn ::= var PushModifiers..."); } //$NON-NLS-1$
+ consumeLocalVariableDeclaration();
+ break;
- //scanner token
- public Scanner scanner;
- protected int[] stack = new int[StackIncrement];
- protected int stateStackTop;
-// protected int synchronizedBlockSourceStart;
- protected int[] variablesCounter;
+ case 77 : if (DEBUG) { System.out.println("PushModifiers ::="); } //$NON-NLS-1$
+ consumePushModifiers();
+ break;
- protected boolean checkExternalizeStrings;
- protected boolean recordStringLiterals;
+ case 102 : if (DEBUG) { System.out.println("EmptyStatement ::= PushPosition SEMICOLON"); } //$NON-NLS-1$
+ consumeEmptyStatement();
+ break;
- // javadoc
- public Javadoc javadoc;
- public JavadocParser javadocParser;
- // used for recovery
- protected int lastJavadocEnd;
+ case 103 : if (DEBUG) { System.out.println("LabeledStatement ::= Label COLON Statement"); } //$NON-NLS-1$
+ consumeStatementLabel() ;
+ break;
- private boolean enteredRecoverStatements;
+ case 104 : if (DEBUG) { System.out.println("LabeledStatementNoShortIf ::= Label COLON..."); } //$NON-NLS-1$
+ consumeStatementLabel() ;
+ break;
- private int insertedSemicolonPosition=-1;
+ case 105 : if (DEBUG) { System.out.println("Label ::= Identifier"); } //$NON-NLS-1$
+ consumeLabel() ;
+ break;
- private Set errorAction = new HashSet();
-
- private static final int UNCONSUMED_LIT_ELEMENT=0x4;
- private static final int UNCONSUMED_ELISION=0x2;
- private static final int WAS_ARRAY_LIT_ELEMENT=0x1;
+ case 106 : if (DEBUG) { System.out.println("ExpressionStatement ::= StatementExpression SEMICOLON"); } //$NON-NLS-1$
+ consumeExpressionStatement();
+ break;
- public static final byte FLAG_EMPTY_STATEMENT = 1;
+ case 108 : if (DEBUG) { System.out.println("IfThenStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$
+ consumeStatementIfNoElse();
+ break;
- public IInferEngine[] inferenceEngines;
-
- static {
- try{
- initTables();
- } catch(java.io.IOException ex){
- throw new ExceptionInInitializerError(ex.getMessage());
- }
- }
-public static int asi(int state) {
+ case 109 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$
+ consumeStatementIfWithElse();
+ break;
- 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) {
- BufferedWriter writer = null;
- try {
- writer = new BufferedWriter(new FileWriter(filename));
- for (Iterator iterator = listToDump.iterator(); iterator.hasNext(); ) {
- writer.write(String.valueOf(iterator.next()));
- }
- writer.flush();
- } catch(IOException e) {
- // ignore
- } finally {
- if (writer != null) {
- try {
- writer.close();
- } catch (IOException e1) {
- // ignore
- }
- }
- }
- System.out.println(filename + " creation complete"); //$NON-NLS-1$
-}
-private final static String[] buildFileForName(String filename, String contents) {
- String[] result = new String[contents.length()];
- result[0] = null;
- int resultCount = 1;
+ case 110 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); } //$NON-NLS-1$
+ consumeStatementIfWithElse();
+ break;
- StringBuffer buffer = new StringBuffer();
+ case 111 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$
+ consumeStatementIfWithElse();
+ break;
- int start = contents.indexOf("name[]"); //$NON-NLS-1$
- start = contents.indexOf('\"', start);
- int end = contents.indexOf("};", start); //$NON-NLS-1$
+ case 112 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); } //$NON-NLS-1$
+ consumeStatementIfWithElse();
+ break;
- contents = contents.substring(start, end);
+ case 113 : if (DEBUG) { System.out.println("SwitchStatement ::= switch LPAREN Expression RPAREN..."); } //$NON-NLS-1$
+ consumeStatementSwitch() ;
+ break;
- 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();
- }
+ case 114 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE RBRACE"); } //$NON-NLS-1$
+ consumeEmptySwitchBlock() ;
+ break;
- buildFileForTable(filename, buffer.toString().toCharArray());
+ case 117 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE SwitchBlockStatements..."); } //$NON-NLS-1$
+ consumeSwitchBlock() ;
+ break;
- 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) {
+ case 119 : if (DEBUG) { System.out.println("SwitchBlockStatements ::= SwitchBlockStatements..."); } //$NON-NLS-1$
+ consumeSwitchBlockStatements() ;
+ break;
- ArrayList entries = new ArrayList();
+ case 120 : if (DEBUG) { System.out.println("SwitchBlockStatement ::= SwitchLabels BlockStatements"); } //$NON-NLS-1$
+ consumeSwitchBlockStatement() ;
+ break;
- boolean[] alreadyAdded = new boolean[newName.length];
+ case 122 : if (DEBUG) { System.out.println("SwitchLabels ::= SwitchLabels SwitchLabel"); } //$NON-NLS-1$
+ consumeSwitchLabels() ;
+ break;
- 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 buildFilesForRecoveryTemplates(
- String indexFilename,
- String templatesFilename,
- char[] newTerminalIndex,
- char[] newNonTerminalIndex,
- String[] newName,
- char[] newLhs,
- String[] tokens) {
+ case 123 : if (DEBUG) { System.out.println("SwitchLabel ::= case ConstantExpression COLON"); } //$NON-NLS-1$
+ consumeCaseLabel();
+ break;
- int[] newReverse = computeReverseTable(newTerminalIndex, newNonTerminalIndex, newName);
+ case 124 : if (DEBUG) { System.out.println("SwitchLabel ::= default COLON"); } //$NON-NLS-1$
+ consumeDefaultLabel();
+ break;
- char[] newRecoveyTemplatesIndex = new char[newNonTerminalIndex.length];
- char[] newRecoveyTemplates = new char[newNonTerminalIndex.length];
- int newRecoveyTemplatesPtr = 0;
+ case 125 : if (DEBUG) { System.out.println("WhileStatement ::= while LPAREN Expression RPAREN..."); } //$NON-NLS-1$
+ consumeStatementWhile() ;
+ break;
- for (int i = 0; i < tokens.length; i = i + 3) {
- if("3".equals(tokens[i])) { //$NON-NLS-1$
- int length = newRecoveyTemplates.length;
- if(length == newRecoveyTemplatesPtr + 1) {
- System.arraycopy(newRecoveyTemplates, 0, newRecoveyTemplates = new char[length * 2], 0, length);
- }
- newRecoveyTemplates[newRecoveyTemplatesPtr++] = 0;
+ case 126 : if (DEBUG) { System.out.println("WhileStatementNoShortIf ::= while LPAREN Expression..."); } //$NON-NLS-1$
+ consumeStatementWhile() ;
+ break;
- int index = newLhs[Integer.parseInt(tokens[i + 1])];
+ case 127 : if (DEBUG) { System.out.println("WithStatement ::= with LPAREN Expression RPAREN..."); } //$NON-NLS-1$
+ consumeStatementWith() ;
+ break;
- newRecoveyTemplatesIndex[index] = (char)newRecoveyTemplatesPtr;
+ case 128 : if (DEBUG) { System.out.println("WithStatementNoShortIf ::= with LPAREN Expression RPAREN"); } //$NON-NLS-1$
+ consumeStatementWith() ;
+ break;
- String token = tokens[i + 2].trim();
- java.util.StringTokenizer st = new java.util.StringTokenizer(new String(token), " "); //$NON-NLS-1$
- String[] terminalNames = new String[st.countTokens()];
- int t = 0;
- while (st.hasMoreTokens()) {
- terminalNames[t++] = st.nextToken();
- }
+ case 129 : if (DEBUG) { System.out.println("DoStatement ::= do Statement while LPAREN Expression..."); } //$NON-NLS-1$
+ consumeStatementDo() ;
+ break;
- for (int j = 0; j < terminalNames.length; j++) {
- int symbol = getSymbol(terminalNames[j], newName, newReverse);
- if(symbol > -1) {
- length = newRecoveyTemplates.length;
- if(length == newRecoveyTemplatesPtr + 1) {
- System.arraycopy(newRecoveyTemplates, 0, newRecoveyTemplates = new char[length * 2], 0, length);
- }
- newRecoveyTemplates[newRecoveyTemplatesPtr++] = (char)symbol;
- }
- }
- }
- }
- newRecoveyTemplates[newRecoveyTemplatesPtr++] = 0;
- System.arraycopy(newRecoveyTemplates, 0, newRecoveyTemplates = new char[newRecoveyTemplatesPtr], 0, newRecoveyTemplatesPtr);
+ case 130 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInitopt SEMICOLON..."); } //$NON-NLS-1$
+ consumeStatementFor() ;
+ break;
- buildFileForTable(indexFilename, newRecoveyTemplatesIndex);
- buildFileForTable(templatesFilename, newRecoveyTemplates);
-}
-private static void buildFilesForStatementsRecoveryFilter(
- String filename,
- char[] newNonTerminalIndex,
- char[] newLhs,
- String[] tokens) {
+ case 131 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInInit in Expression..."); } //$NON-NLS-1$
+ consumeStatementForIn() ;
+ break;
- char[] newStatementsRecoveryFilter = new char[newNonTerminalIndex.length];
+ case 132 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInitopt..."); } //$NON-NLS-1$
+ consumeStatementFor() ;
+ break;
- for (int i = 0; i < tokens.length; i = i + 3) {
- if("4".equals(tokens[i])) { //$NON-NLS-1$
- int index = newLhs[Integer.parseInt(tokens[i + 1])];
+ case 133 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInInit in..."); } //$NON-NLS-1$
+ consumeStatementForIn() ;
+ break;
- newStatementsRecoveryFilter[index] = 1;
- }
- }
- buildFileForTable(filename, newStatementsRecoveryFilter);
- }
+ case 134 : if (DEBUG) { System.out.println("ForInInit ::= LeftHandSideExpression"); } //$NON-NLS-1$
+ consumeForInInit() ;
+ break;
-private static void buildFilesForFlags(
- String filename,
- int size,
- String[] tokens) {
+ case 136 : if (DEBUG) { System.out.println("ForInit ::= ExpressionNoIn"); } //$NON-NLS-1$
+ consumeForInit() ;
+ break;
- byte[] flags = new byte[size];
+ case 140 : if (DEBUG) { System.out.println("StatementExpressionList ::= StatementExpressionList..."); } //$NON-NLS-1$
+ consumeStatementExpressionList() ;
+ break;
- for (int i = 0; i < tokens.length; i = i + 3) {
- if("5".equals(tokens[i])) { //$NON-NLS-1$
- int index = Integer.parseInt(tokens[i + 1]);
- byte value =(byte) Integer.parseInt(tokens[i + 2].trim());
- flags[index]=value;
- }
- }
- buildFileForTable(filename, flags);
- }
+ case 141 : if (DEBUG) { System.out.println("BreakStatement ::= break SEMICOLON"); } //$NON-NLS-1$
+ consumeStatementBreak() ;
+ break;
-private static void buildFileForCompliance(
- String file,
- int length,
- String[] tokens) {
+ case 142 : if (DEBUG) { System.out.println("BreakStatement ::= break Identifier SEMICOLON"); } //$NON-NLS-1$
+ consumeStatementBreakWithLabel() ;
+ break;
- byte[] result = new byte[length * 8];
+ case 143 : if (DEBUG) { System.out.println("ContinueStatement ::= continue SEMICOLON"); } //$NON-NLS-1$
+ consumeStatementContinue() ;
+ break;
- 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;
- }
+ case 144 : if (DEBUG) { System.out.println("ContinueStatement ::= continue Identifier SEMICOLON"); } //$NON-NLS-1$
+ consumeStatementContinueWithLabel() ;
+ break;
- 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);
- }
- }
+ case 145 : if (DEBUG) { System.out.println("ReturnStatement ::= return Expressionopt SEMICOLON"); } //$NON-NLS-1$
+ consumeStatementReturn() ;
+ break;
- buildFileForTable(file, result);
- }
-private final static void buildFileForTable(String filename, byte[] bytes) {
- java.io.FileOutputStream stream = null;
- try {
- stream = new java.io.FileOutputStream(filename);
- stream.write(bytes);
- } catch(IOException e) {
- // ignore
- } finally {
- if (stream != null) {
- try {
- stream.close();
- } catch (IOException e1) {
- // ignore
- }
- }
- }
- System.out.println(filename + " creation complete"); //$NON-NLS-1$
- }
- private final static void buildFileForTable(String filename, char[] chars) {
- 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);
- }
+ case 146 : if (DEBUG) { System.out.println("ThrowStatement ::= throw Expression SEMICOLON"); } //$NON-NLS-1$
+ consumeStatementThrow();
+ break;
- java.io.FileOutputStream stream = null;
- try {
- stream = new java.io.FileOutputStream(filename);
- stream.write(bytes);
- } catch(IOException e) {
- // ignore
- } finally {
- if (stream != null) {
- try {
- stream.close();
- } catch (IOException e1) {
- // ignore
- }
- }
- }
- System.out.println(filename + " creation complete"); //$NON-NLS-1$
- }
- private final static byte[] buildFileOfByteFor(String filename, String tag, String[] tokens) {
+ case 147 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catches"); } //$NON-NLS-1$
+ consumeStatementTry(false);
+ break;
- //transform the String tokens into chars before dumping then into file
+ case 148 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catchesopt Finally"); } //$NON-NLS-1$
+ consumeStatementTry(true);
+ break;
- int i = 0;
- //read upto the tag
- while (!tokens[i++].equals(tag)){/*empty*/}
- //read upto the }
+ case 150 : if (DEBUG) { System.out.println("ExitTryBlock ::="); } //$NON-NLS-1$
+ consumeExitTryBlock();
+ break;
- 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;
- }
+ case 152 : if (DEBUG) { System.out.println("Catches ::= Catches CatchClause"); } //$NON-NLS-1$
+ consumeCatches();
+ break;
- //resize
- System.arraycopy(bytes, 0, bytes = new byte[ic], 0, ic);
+ case 153 : if (DEBUG) { System.out.println("CatchClause ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$
+ consumeStatementCatch() ;
+ break;
- buildFileForTable(filename, bytes);
- return bytes;
- }
- private final static char[] buildFileOfIntFor(String filename, String tag, String[] tokens) {
+ case 155 : if (DEBUG) { System.out.println("DebuggerStatement ::= debugger SEMICOLON"); } //$NON-NLS-1$
+ consumeDebuggerStatement() ;
+ break;
- //transform the String tokens into chars before dumping then into file
+ case 156 : if (DEBUG) { System.out.println("PushLPAREN ::= LPAREN"); } //$NON-NLS-1$
+ consumeLeftParen();
+ break;
- int i = 0;
- //read upto the tag
- while (!tokens[i++].equals(tag)){/*empty*/}
- //read upto the }
+ case 157 : if (DEBUG) { System.out.println("PushRPAREN ::= RPAREN"); } //$NON-NLS-1$
+ consumeRightParen();
+ break;
- 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;
- }
+ case 162 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= SimpleName"); } //$NON-NLS-1$
+ consumePrimarySimpleName();
+ break;
- //resize
- System.arraycopy(chars, 0, chars = new char[ic], 0, ic);
+ case 163 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= this"); } //$NON-NLS-1$
+ consumePrimaryNoNewArrayThis();
+ break;
- buildFileForTable(filename, chars);
- return chars;
- }
- private final static void buildFileOfShortFor(String filename, String tag, String[] tokens) {
+ case 164 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Expression PushRPAREN"); } //$NON-NLS-1$
+ consumePrimaryNoNewArray();
+ break;
- //transform the String tokens into chars before dumping then into file
+ case 165 : if (DEBUG) { System.out.println("ObjectLiteral ::= LBRACE PushLeftBraceObjectLiteral..."); } //$NON-NLS-1$
+ consumeEmptyObjectLiteral();
+ break;
- int i = 0;
- //read upto the tag
- while (!tokens[i++].equals(tag)){/*empty*/}
- //read upto the }
+ case 166 : if (DEBUG) { System.out.println("ObjectLiteral ::= LBRACE PushLeftBraceObjectLiteral..."); } //$NON-NLS-1$
+ consumeObjectLiteral();
+ break;
- 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);
- }
+ case 167 : if (DEBUG) { System.out.println("ObjectLiteral ::= LBRACE PushLeftBraceObjectLiteral..."); } //$NON-NLS-1$
+ consumeObjectLiteral();
+ break;
- //resize
- System.arraycopy(chars, 0, chars = new char[ic], 0, ic);
+ case 169 : if (DEBUG) { System.out.println("PropertyNameAndValueList ::= PropertyNameAndValueList..."); } //$NON-NLS-1$
+ consumePropertyNameAndValueList();
+ break;
- buildFileForTable(filename, chars);
- }
-public final static void buildFilesFromLPG(String dataFilename, String dataFilename2) {
+ case 170 : if (DEBUG) { System.out.println("PropertyAssignment ::= PropertyName COLON..."); } //$NON-NLS-1$
+ consumePropertyAssignment();
+ break;
- //RUN THIS METHOD TO GENERATE PARSER*.RSC FILES
+ case 171 : if (DEBUG) { System.out.println("PropertyAssignment ::= PropertyName PropertyName LPAREN"); } //$NON-NLS-1$
+ consumeGetSetPropertyAssignment(false);
+ break;
- //build from the lpg javadcl.java files that represents the parser tables
- //lhs check_table asb asr symbol_index
+ case 172 : if (DEBUG) { System.out.println("PropertyAssignment ::= PropertyName PropertyName LPAREN"); } //$NON-NLS-1$
+ consumeGetSetPropertyAssignment(true);
+ break;
- //[org.eclipse.wst.jsdt.internal.compiler.parser.Parser.buildFilesFromLPG("d:/leapfrog/grammar/javadcl.java")]
- char[] contents = CharOperation.NO_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;
+ case 173 : if (DEBUG) { System.out.println("PropertySetParameterList ::= SimpleName"); } //$NON-NLS-1$
+ consumePropertySetParameterList();
+ break;
- 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$
- char[] newTerminalIndex = 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$
+ case 174 : if (DEBUG) { System.out.println("FunctionBody ::= NestedMethod LBRACE PostDoc..."); } //$NON-NLS-1$
+ consumeMethodBody();
+ break;
- 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$
+ case 175 : if (DEBUG) { System.out.println("ProgramElementsopt ::="); } //$NON-NLS-1$
+ consumeEmptyProgramElements();
+ break;
- 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$
+ case 177 : if (DEBUG) { System.out.println("PropertyName ::= SimpleName"); } //$NON-NLS-1$
+ consumePropertyName();
+ break;
- String[] newName = buildFileForName(prefix + (++i) + ".rsc", new String(contents)); //$NON-NLS-1$
+ case 181 : if (DEBUG) { System.out.println("ArrayLiteral ::= ArrayLiteralHeader ElisionOpt RBRACKET"); } //$NON-NLS-1$
+ consumeArrayLiteral(false);
+ break;
- contents = CharOperation.NO_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();
- }
+ case 182 : if (DEBUG) { System.out.println("ArrayLiteral ::= ArrayLiteralHeader..."); } //$NON-NLS-1$
+ consumeArrayLiteral(false);
+ break;
- buildFileForCompliance(prefix + (++i) + ".rsc", newRhs.length, tokens);//$NON-NLS-1$
- buildFileForReadableName(READABLE_NAMES_FILE+".properties", newLhs, newNonTerminalIndex, newName, tokens);//$NON-NLS-1$
+ case 183 : if (DEBUG) { System.out.println("ArrayLiteral ::= ArrayLiteralHeader..."); } //$NON-NLS-1$
+ consumeArrayLiteral(true);
+ break;
- buildFilesForRecoveryTemplates(
- prefix + (++i) + ".rsc", //$NON-NLS-1$
- prefix + (++i) + ".rsc", //$NON-NLS-1$
- newTerminalIndex,
- newNonTerminalIndex,
- newName,
- newLhs,
- tokens);
+ case 184 : if (DEBUG) { System.out.println("ArrayLiteralHeader ::= LBRACKET"); } //$NON-NLS-1$
+ consumeArrayLiteralHeader();
+ break;
- buildFilesForStatementsRecoveryFilter(
- prefix + (++i) + ".rsc", //$NON-NLS-1$
- newNonTerminalIndex,
- newLhs,
- tokens);
+ case 185 : if (DEBUG) { System.out.println("ElisionOpt ::="); } //$NON-NLS-1$
+ consumeElisionEmpty();
+ break;
- buildFilesForFlags(
- prefix + (++i) + ".rsc", //$NON-NLS-1$
- rhs.length,
- tokens);
+ case 187 : if (DEBUG) { System.out.println("Elision ::= COMMA"); } //$NON-NLS-1$
+ consumeElisionOne();
+ break;
+ case 188 : if (DEBUG) { System.out.println("Elision ::= Elision COMMA"); } //$NON-NLS-1$
+ consumeElisionList();
+ break;
- 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 {
+ case 189 : if (DEBUG) { System.out.println("ArrayLiteralElementList ::= ElisionOpt..."); } //$NON-NLS-1$
+ consumeArrayLiteralListOne();
+ break;
- 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$
+ case 190 : if (DEBUG) { System.out.println("ArrayLiteralElementList ::= ArrayLiteralElementList..."); } //$NON-NLS-1$
+ consumeArrayLiteralList();
+ break;
- 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$
+ case 191 : if (DEBUG) { System.out.println("ArrayLiteralElement ::= AssignmentExpression"); } //$NON-NLS-1$
+ consumeArrayLiteralElement();
+ break;
- 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$
+ case 194 : if (DEBUG) { System.out.println("MemberExpression ::= MemberExpression LBRACKET..."); } //$NON-NLS-1$
+ consumeMemberExpressionWithArrayReference();
+ break;
- name = readNameTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
+ case 195 : if (DEBUG) { System.out.println("MemberExpression ::= MemberExpression DOT SimpleName"); } //$NON-NLS-1$
+ consumeMemberExpressionWithSimpleName();
+ break;
- rules_compliance = readLongTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
+ case 196 : if (DEBUG) { System.out.println("MemberExpression ::= new MemberExpression Arguments"); } //$NON-NLS-1$
+ consumeNewMemberExpressionWithArguments();
+ break;
- readableName = readReadableNameTable(READABLE_NAMES_FILE_NAME);
+ case 198 : if (DEBUG) { System.out.println("NewExpression ::= new NewExpression"); } //$NON-NLS-1$
+ consumeNewExpression();
+ break;
- reverse_index = computeReverseTable(terminal_index, non_terminal_index, name);
+ case 199 : if (DEBUG) { System.out.println("CallExpression ::= MemberExpression Arguments"); } //$NON-NLS-1$
+ consumeCallExpressionWithArguments();
+ break;
- recovery_templates_index = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
- recovery_templates = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
+ case 200 : if (DEBUG) { System.out.println("CallExpression ::= CallExpression Arguments"); } //$NON-NLS-1$
+ consumeCallExpressionWithArguments();
+ break;
- statements_recovery_filter = readTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
- state_flags = readByteTable(prefix + (++i) + ".rsc"); //$NON-NLS-1$
+ case 201 : if (DEBUG) { System.out.println("CallExpression ::= CallExpression LBRACKET Expression..."); } //$NON-NLS-1$
+ consumeCallExpressionWithArrayReference();
+ break;
- base_action = lhs;
+ case 202 : if (DEBUG) { System.out.println("CallExpression ::= CallExpression DOT SimpleName"); } //$NON-NLS-1$
+ consumeCallExpressionWithSimpleName();
+ break;
- optionalSemicolonState =new boolean[base_action.length];
- for ( i = 0; i < optionalSemicolonState.length; i++) {
- if (base_action[i]+TokenNameSEMICOLON<term_check.length
- && (term_check[base_action[i]+TokenNameSEMICOLON] == TokenNameSEMICOLON))
- {
- int act=term_action[base_action[i]+TokenNameSEMICOLON];
- if (act>ERROR_ACTION)
- act-=ERROR_ACTION;
- boolean isEmptyStatementsState = false;
- if (act<NUM_RULES)
- isEmptyStatementsState = (state_flags[act]&FLAG_EMPTY_STATEMENT)>0;
- if (!isEmptyStatementsState)
- optionalSemicolonState[i]=true;
- }
- }
+ case 206 : if (DEBUG) { System.out.println("PostfixExpression ::= LeftHandSideExpression PLUS_PLUS"); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.PLUS, true);
+ break;
-}
-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 int[] computeReverseTable(char[] newTerminalIndex, char[] newNonTerminalIndex, String[] newName) {
- int[] newReverseTable = new int[newName.length];
- for (int j = 0; j < newName.length; j++) {
- found : {
- for (int k = 0; k < newTerminalIndex.length; k++) {
- if(newTerminalIndex[k] == j) {
- newReverseTable[j] = k;
- break found;
- }
- }
- for (int k = 0; k < newNonTerminalIndex.length; k++) {
- if(newNonTerminalIndex[k] == j) {
- newReverseTable[j] = -k;
- break found;
- }
- }
- }
- }
- return newReverseTable;
-}
+ case 207 : if (DEBUG) { System.out.println("PostfixExpression ::= LeftHandSideExpression MINUS_MINUS"); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.MINUS, true);
+ break;
-private static int getSymbol(String terminalName, String[] newName, int[] newReverse) {
- for (int j = 0; j < newName.length; j++) {
- if(terminalName.equals(newName[j])) {
- return newReverse[j];
- }
- }
- return -1;
-}
+ case 209 : if (DEBUG) { System.out.println("ListExpression ::= ListExpression COMMA..."); } //$NON-NLS-1$
+ consumeListExpression();
+ break;
-protected static byte[] readByteTable(String filename) throws java.io.IOException {
+ case 211 : if (DEBUG) { System.out.println("ListExpressionNoIn ::= ListExpressionNoIn COMMA..."); } //$NON-NLS-1$
+ consumeListExpression();
+ break;
- //files are located at Parser.class directory
+ case 213 : if (DEBUG) { System.out.println("ListExpressionStmt ::= ListExpressionStmt COMMA..."); } //$NON-NLS-1$
+ consumeListExpression();
+ break;
- 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;
-}
+ case 215 : if (DEBUG) { System.out.println("ArgumentList ::= ArgumentList COMMA AssignmentExpression"); } //$NON-NLS-1$
+ consumeArgumentList();
+ break;
-protected static String[] readNameTable(String filename) throws java.io.IOException {
- char[] contents = readTable(filename);
- char[][] nameAsChar = CharOperation.splitOn('\n', contents);
+ case 216 : if (DEBUG) { System.out.println("PushPosition ::="); } //$NON-NLS-1$
+ consumePushPosition();
+ break;
- 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]);
- }
+ case 219 : if (DEBUG) { System.out.println("UnaryExpression ::= PLUS PushPosition UnaryExpression"); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.PLUS);
+ break;
- return result;
-}
-protected static String[] readReadableNameTable(String filename) {
- String[] result = new String[name.length];
+ case 220 : if (DEBUG) { System.out.println("UnaryExpression ::= MINUS PushPosition UnaryExpression"); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.MINUS);
+ break;
- 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 {
+ case 222 : if (DEBUG) { System.out.println("PreIncrementExpression ::= PLUS_PLUS PushPosition..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.PLUS, false);
+ break;
- //files are located at Parser.class directory
+ case 223 : if (DEBUG) { System.out.println("PreDecrementExpression ::= MINUS_MINUS PushPosition..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.MINUS, false);
+ break;
- 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
- }
- }
+ case 225 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= TWIDDLE PushPosition..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.TWIDDLE);
+ break;
- //minimal integrity check (even size expected)
- int length = bytes.length;
- if ((length & 1) != 0)
- throw new java.io.IOException(Messages.bind(Messages.parser_corruptedFile, filename));
+ case 226 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= NOT PushPosition..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.NOT);
+ break;
- // convert bytes into chars
- char[] chars = new char[length / 2];
- int i = 0;
- int charIndex = 0;
+ case 227 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= delete PushPosition..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.DELETE);
+ break;
- 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 {
+ case 228 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= void PushPosition..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.VOID);
+ break;
- //files are located at Parser.class directory
+ case 229 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= typeof PushPosition..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.TYPEOF);
+ break;
- 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
- }
- }
+ case 231 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.MULTIPLY);
+ break;
- //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));
+ case 232 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.DIVIDE);
+ break;
- // convert bytes into longs
- long[] longs = new long[length / 8];
- int i = 0;
- int longIndex = 0;
+ case 233 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.REMAINDER);
+ break;
- 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);
+ case 235 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression PLUS..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.PLUS);
+ break;
- 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]];
-}
+ case 236 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression MINUS..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.MINUS);
+ break;
-public Parser(ProblemReporter problemReporter, boolean optimizeStringLiterals) {
+ case 238 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression LEFT_SHIFT..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
+ break;
- 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];
+ case 239 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression RIGHT_SHIFT..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
+ break;
- // javadoc support
- this.javadocParser = createJavadocParser();
-
-}
-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.
+ case 240 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
+ break;
- 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(){
+ case 242 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.LESS);
+ break;
- /* initialize recovery by retrieving available reduced nodes
- * also rebuild bracket balance
- */
- this.lastCheckPoint = 0;
- this.lastErrorEndPositionBeforeRecovery = this.scanner.currentPosition;
+ case 243 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression GREATER..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.GREATER);
+ break;
- RecoveredElement element = null;
- if (this.referenceContext instanceof CompilationUnitDeclaration){
- if (!DO_DIET_PARSE)
- {
- this.methodRecoveryActivated=true;
-// this.statementRecoveryActivated=true;
- }
- element = new RecoveredUnit(this.compilationUnit, 0, this);
+ case 244 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS_EQUAL"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.LESS_EQUAL);
+ break;
- /* ignore current stack state, since restarting from the beginnning
- since could not trust simple brace count */
- if (false){ // experimenting restart recovery from scratch
- this.compilationUnit.currentPackage = null;
- this.compilationUnit.imports = null;
- this.compilationUnit.types = null;
- this.compilationUnit.statements = null;
- this.currentToken = 0;
- this.listLength = 0;
- this.listTypeParameterLength = 0;
- this.endPosition = 0;
- this.endStatementPosition = 0;
- return element;
- }
- else
- {
- this.currentToken = 0;
-// if (this.astPtr<0&&this.compilationUnit.sourceEnd>0)
-// this.lastCheckPoint = this.compilationUnit.sourceEnd;
+ case 245 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
+ break;
- }
+ case 246 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression instanceof"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.INSTANCEOF);
+ break;
- 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;
- if(this.statementRecoveryActivated) {
- element = element.add(new Block(0), 0);
- }
- } 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;
- }
- }
- }
- }
- }
+ case 247 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression in..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.IN);
+ break;
- if (element == null) return element;
+ case 249 : if (DEBUG) { System.out.println("RelationalExpressionNoIn ::= RelationalExpressionNoIn..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.LESS);
+ break;
- element = recoverAST(element);
- if (this.statementRecoveryActivated) {
- if (this.pendingRecoveredType != null &&
- this.scanner.startPosition - 1 <= this.pendingRecoveredType.declarationSourceEnd) {
- // Add the pending type to the AST if this type isn't already added in the AST.
- element = element.add(this.pendingRecoveredType, 0);
- this.lastCheckPoint = this.pendingRecoveredType.declarationSourceEnd + 1;
- this.pendingRecoveredType = null;
- }
- }
- ProgramElement[] compUnitStatments = this.compilationUnit.statements;
- if (compUnitStatments!=null && compUnitStatments.length>0 &&
- this.lastCheckPoint<compUnitStatments[compUnitStatments.length-1].sourceEnd)
- {
- ProgramElement programElement = compUnitStatments[compUnitStatments.length-1];
+ case 250 : if (DEBUG) { System.out.println("RelationalExpressionNoIn ::= RelationalExpressionNoIn..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.GREATER);
+ break;
- this.lastCheckPoint=((programElement instanceof Expression) ? ((Expression)programElement).statementEnd : programElement.sourceEnd)+1;
- }
- return element;
-}
+ case 251 : if (DEBUG) { System.out.println("RelationalExpressionNoIn ::= RelationalExpressionNoIn..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.LESS_EQUAL);
+ break;
-public RecoveredElement recoverAST(RecoveredElement element) {
- for(int i = 0; i <= this.astPtr; i++){
- ASTNode node = this.astStack[i];
- if (node instanceof AbstractMethodDeclaration){
- AbstractMethodDeclaration method = (AbstractMethodDeclaration) node;
- if (method.getName()!=null)
- {
- if (method.declarationSourceEnd == 0){
- element = element.add(method, 0);
- this.lastCheckPoint = method.bodyStart;
- } else {
- element = element.add(method, 0);
- this.lastCheckPoint = method.declarationSourceEnd + 1;
- }
- }
- else
- element = recoverFunctionExpression(element,method);
- 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 LocalDeclaration){
- LocalDeclaration localDecl = (LocalDeclaration) node;
- if (localDecl.declarationSourceEnd == 0){
- element = element.add(localDecl, 0);
- if (localDecl.initialization == null){
- this.lastCheckPoint = localDecl.sourceEnd + 1;
- } else {
- this.lastCheckPoint = localDecl.initialization.sourceEnd + 1;
- }
- } else {
- element = element.add(localDecl, 0);
- this.lastCheckPoint = localDecl.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 Statement){
- Statement statement = (Statement) node;
- if (statement.sourceEnd == 0){
- element = element.add(statement, 1);
- this.lastCheckPoint = statement.sourceStart;
- } else {
- element = element.add(statement, 0);
- this.lastCheckPoint = statement.sourceEnd + 1;
- }
- continue;
- }
- if (node instanceof ImportReference){
- ImportReference importRef = (ImportReference) node;
- element = element.add(importRef, 0);
- this.lastCheckPoint = importRef.declarationSourceEnd + 1;
- }
- if(this.statementRecoveryActivated) {
- if(node instanceof Block) {
- Block block = (Block) node;
- element = element.add(block, 0);
- this.lastCheckPoint = block.sourceEnd + 1;
- } else if(node instanceof LocalDeclaration) {
- LocalDeclaration statement = (LocalDeclaration) node;
- element = element.add(statement, 0);
- this.lastCheckPoint = statement.declarationSourceEnd + 1;
- } else if(node instanceof Expression) {
- if(node instanceof Assignment ||
- node instanceof PrefixExpression ||
- node instanceof PostfixExpression ||
- node instanceof MessageSend ||
- node instanceof AllocationExpression) {
- // recover only specific expressions
- Expression statement = (Expression) node;
- element = element.add(statement, 0);
- if(statement.statementEnd != -1) {
- this.lastCheckPoint = statement.statementEnd + 1;
- } else {
- this.lastCheckPoint = statement.sourceEnd + 1;
- }
- }
- } else if(node instanceof Statement) {
- Statement statement = (Statement) node;
- element = element.add(statement, 0);
- this.lastCheckPoint = statement.sourceEnd + 1;
- }
- }
- }
- return element;
-}
+ case 252 : if (DEBUG) { System.out.println("RelationalExpressionNoIn ::= RelationalExpressionNoIn..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
+ break;
-protected RecoveredElement recoverFunctionExpression(RecoveredElement element, AbstractMethodDeclaration method) {
- int start = method.exprStackPtr;
-// int end=this.expressionPtr;
- boolean isAssignment=true;
- Statement expression=null;
+ case 253 : if (DEBUG) { System.out.println("RelationalExpressionNoIn ::= RelationalExpressionNoIn..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.INSTANCEOF);
+ break;
- FunctionExpression funcExpr=new FunctionExpression((MethodDeclaration)method);
- funcExpr.sourceEnd=method.declarationSourceEnd;
- funcExpr.sourceStart=method.sourceStart;
+ case 255 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression EQUAL_EQUAL..."); } //$NON-NLS-1$
+ consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
+ break;
+ case 256 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression NOT_EQUAL..."); } //$NON-NLS-1$
+ consumeEqualityExpression(OperatorIds.NOT_EQUAL);
+ break;
- if (isAssignment && start>=0)
- {
- expression=new Assignment(this.expressionStack[start],funcExpr,method.sourceEnd);
- }
- if (expression!=null)
- {
- element = element.add(expression, 1);
- if (method.declarationSourceEnd == 0){
- element = element.add(method, 0);
- this.lastCheckPoint = method.bodyStart;
- } else {
- element = element.add(method, 0);
- this.lastCheckPoint = method.declarationSourceEnd + 1;
- }
- if (element instanceof RecoveredMethod)
- element.add(new Block(0), 0);
- }
+ case 257 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression..."); } //$NON-NLS-1$
+ consumeEqualityExpression(OperatorIds.EQUAL_EQUAL_EQUAL);
+ break;
- 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. */
+ case 258 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression..."); } //$NON-NLS-1$
+ consumeEqualityExpression(OperatorIds.NOT_EQUAL_EQUAL);
+ break;
- if ((this.modifiers & flag) != 0){ // duplicate modifier
- this.modifiers |= ExtraCompilerModifiers.AccAlternateModifierProblem;
- }
- this.modifiers |= flag;
+ case 260 : if (DEBUG) { System.out.println("EqualityExpressionNoIn ::= EqualityExpressionNoIn..."); } //$NON-NLS-1$
+ consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
+ break;
- if (this.modifiersSourceStart < 0) this.modifiersSourceStart = this.scanner.startPosition;
-}
-public void checkComment() {
+ case 261 : if (DEBUG) { System.out.println("EqualityExpressionNoIn ::= EqualityExpressionNoIn..."); } //$NON-NLS-1$
+ consumeEqualityExpression(OperatorIds.NOT_EQUAL);
+ break;
- // discard obsolete comments while inside methods or fields initializer (see bug 74369)
- // don't discard if the expression being worked on is an ObjectLiteral (see bug 322412 )
- if (!(this.diet && this.dietInt == 0) && this.scanner.commentPtr >= 0 && !(expressionPtr >= 0 && expressionStack[expressionPtr] instanceof ObjectLiteral)) {
- flushCommentsDefinedPriorTo(this.endStatementPosition);
- }
+ case 262 : if (DEBUG) { System.out.println("EqualityExpressionNoIn ::= EqualityExpressionNoIn..."); } //$NON-NLS-1$
+ consumeEqualityExpression(OperatorIds.EQUAL_EQUAL_EQUAL);
+ break;
- int lastComment = this.scanner.commentPtr;
+ case 263 : if (DEBUG) { System.out.println("EqualityExpressionNoIn ::= EqualityExpressionNoIn..."); } //$NON-NLS-1$
+ consumeEqualityExpression(OperatorIds.NOT_EQUAL_EQUAL);
+ break;
-// 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];
+ case 265 : if (DEBUG) { System.out.println("AndExpression ::= AndExpression AND EqualityExpression"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.AND);
+ break;
- // 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, boolean isShort) {
- // ClassInstanceCreationExpression ::= 'new' ClassType '(' ArgumentListopt ')' ClassBodyopt
+ case 267 : if (DEBUG) { System.out.println("AndExpressionNoIn ::= AndExpressionNoIn AND..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.AND);
+ break;
- // 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.....
+ case 269 : if (DEBUG) { System.out.println("ExclusiveOrExpression ::= ExclusiveOrExpression XOR..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.XOR);
+ break;
- AllocationExpression alloc = new AllocationExpression();
- 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();
-// }
+ case 271 : if (DEBUG) { System.out.println("ExclusiveOrExpressionNoIn ::= ExclusiveOrExpressionNoIn"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.XOR);
+ break;
- alloc.isShort=isShort;
- if (!isShort)
- {
- alloc.sourceEnd = this.intStack[this.intPtr--]; //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);
- }
+ case 273 : if (DEBUG) { System.out.println("InclusiveOrExpression ::= InclusiveOrExpression OR..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.OR);
+ break;
- }
+ case 275 : if (DEBUG) { System.out.println("InclusiveOrExpressionNoIn ::= InclusiveOrExpressionNoIn"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.OR);
+ break;
- alloc.member = this.expressionStack[this.expressionPtr--];
- this.expressionLengthPtr--;
+ case 277 : if (DEBUG) { System.out.println("ConditionalAndExpression ::= ConditionalAndExpression..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.AND_AND);
+ break;
- //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--];
- if (isShort)
- alloc.sourceEnd=alloc.member.sourceEnd;
- 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 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.
- */
+ case 279 : if (DEBUG) { System.out.println("ConditionalAndExpressionNoIn ::=..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.AND_AND);
+ break;
- this.astLengthStack[this.astLengthPtr - 1] += this.astLengthStack[this.astLengthPtr--];
-}
-protected void consumeAnnotationAsModifier() {
- Expression expression = this.expressionStack[this.expressionPtr];
- int sourceStart = expression.sourceStart;
- if (this.modifiersSourceStart < 0) {
- this.modifiersSourceStart = sourceStart;
- }
-}
-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 consumeAssignment() {
- // Assignment ::= LeftHandSide AssignmentOperator AssignmentExpression
- //optimize the push/pop
+ case 281 : if (DEBUG) { System.out.println("ConditionalOrExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.OR_OR);
+ break;
- int op = this.intStack[this.intPtr--] ; //<--the encoded operator
+ case 283 : if (DEBUG) { System.out.println("ConditionalOrExpressionNoIn ::=..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.OR_OR);
+ break;
- this.expressionPtr -- ; this.expressionLengthPtr -- ;
- checkComment();
+ case 285 : if (DEBUG) { System.out.println("ConditionalExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$
+ consumeConditionalExpression(OperatorIds.QUESTIONCOLON);
+ break;
- if(op != EQUAL) {
- CompoundAssignment compoundAssignment = new CompoundAssignment(
- this.expressionStack[this.expressionPtr] ,
- this.expressionStack[this.expressionPtr+1],
- op,
- this.scanner.startPosition - 1);
- if (this.javadoc != null) {
- compoundAssignment.javadoc = this.javadoc;
- this.javadoc = null;
- }
- this.expressionStack[this.expressionPtr] = compoundAssignment;
- }
- else {
- Assignment assignment = new Assignment(
- this.expressionStack[this.expressionPtr] ,
- this.expressionStack[this.expressionPtr+1],
- this.scanner.startPosition - 1);
- if (this.javadoc != null) {
- assignment.javadoc = this.javadoc;
- this.javadoc = null;
- }
- this.expressionStack[this.expressionPtr] = assignment;
- }
+ case 287 : if (DEBUG) { System.out.println("ConditionalExpressionNoIn ::=..."); } //$NON-NLS-1$
+ consumeConditionalExpression(OperatorIds.QUESTIONCOLON);
+ break;
- if (this.pendingRecoveredType != null) {
- // Used only in statements recovery.
- // This is not a real assignment but a placeholder for an existing anonymous type.
- // The assignment must be replace by the anonymous type.
- if (this.pendingRecoveredType.allocation != null &&
- this.scanner.startPosition - 1 <= this.pendingRecoveredType.declarationSourceEnd) {
- this.expressionStack[this.expressionPtr] = this.pendingRecoveredType.allocation;
- this.pendingRecoveredType = null;
- return;
- }
- this.pendingRecoveredType = null;
- }
-}
-protected void consumeAssignmentOperator(int pos) {
- // AssignmentOperator ::= '='
- // AssignmentOperator ::= '*='
- // AssignmentOperator ::= '/='
- // AssignmentOperator ::= '%='
- // AssignmentOperator ::= '+='
- // AssignmentOperator ::= '-='
- // AssignmentOperator ::= '<<='
- // AssignmentOperator ::= '>>='
- // AssignmentOperator ::= '>>>='
- // AssignmentOperator ::= '&='
- // AssignmentOperator ::= '^='
- // AssignmentOperator ::= '|='
+ case 292 : if (DEBUG) { System.out.println("Assignment ::= PostfixExpression AssignmentOperator..."); } //$NON-NLS-1$
+ consumeAssignment();
+ break;
- 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
+ case 293 : if (DEBUG) { System.out.println("AssignmentNoIn ::= PostfixExpression AssignmentOperator"); } //$NON-NLS-1$
+ consumeAssignment();
+ break;
- //optimize the push/pop
+ case 294 : if (DEBUG) { System.out.println("AssignmentOperator ::= EQUAL"); } //$NON-NLS-1$
+ consumeAssignmentOperator(EQUAL);
+ break;
- 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"
- // look for "string1" + "string2"
- if (this.optimizeStringLiterals) {
- if (expr1 instanceof StringLiteral) {
- 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 if (expr1 instanceof CombinedBinaryExpression) {
- CombinedBinaryExpression cursor;
- // left branch is comprised of PLUS BEs
- // cursor is shifted upwards, while needed BEs are added
- // on demand; past the arityMax-th
- // consecutive BE, a CBE is inserted that holds a
- // full-fledged references table
- if ((cursor = (CombinedBinaryExpression)expr1).arity <
- cursor.arityMax) {
- cursor.left = new BinaryExpression(cursor.left,
- cursor.right, PLUS);
- cursor.arity++;
- } else {
- cursor.left = new CombinedBinaryExpression(cursor.left,
- cursor.right, PLUS, cursor.arity);
- cursor.arity = 0;
- cursor.tuneArityMax();
- }
- cursor.right = expr2;
- cursor.sourceEnd = expr2.sourceEnd;
- this.expressionStack[this.expressionPtr] = cursor;
- // BE_INSTRUMENTATION: neutralized in the released code
-// cursor.depthTracker = ((BinaryExpression)cursor.left).
-// depthTracker + 1;
- } else if (expr1 instanceof BinaryExpression &&
- // single out the a + b case, which is a BE
- // instead of a CBE (slightly more than a half of
- // strings concatenation are one-deep binary
- // expressions)
- ((expr1.bits & ASTNode.OperatorMASK) >>
- ASTNode.OperatorSHIFT) == OperatorIds.PLUS) {
- this.expressionStack[this.expressionPtr] =
- new CombinedBinaryExpression(expr1, expr2, PLUS, 1);
- } 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 {
- // single out the a + b case
- this.expressionStack[this.expressionPtr] =
- new BinaryExpression(expr1, expr2, PLUS);
- }
- } else if (expr1 instanceof CombinedBinaryExpression) {
- CombinedBinaryExpression cursor;
- // shift cursor; create BE/CBE as needed
- if ((cursor = (CombinedBinaryExpression)expr1).arity <
- cursor.arityMax) {
- cursor.left = new BinaryExpression(cursor.left,
- cursor.right, PLUS);
- cursor.arity++;
- } else {
- cursor.left = new CombinedBinaryExpression(cursor.left,
- cursor.right, PLUS, cursor.arity);
- cursor.arity = 0;
- cursor.tuneArityMax();
- }
- cursor.right = expr2;
- cursor.sourceEnd = expr2.sourceEnd;
- // BE_INSTRUMENTATION: neutralized in the released code
-// cursor.depthTracker = ((BinaryExpression)cursor.left).
-// depthTracker + 1;
- this.expressionStack[this.expressionPtr] = cursor;
- } else if (expr1 instanceof BinaryExpression &&
- // single out the a + b case
- ((expr1.bits & ASTNode.OperatorMASK) >>
- ASTNode.OperatorSHIFT) == OperatorIds.PLUS) {
- this.expressionStack[this.expressionPtr] =
- new CombinedBinaryExpression(expr1, expr2, PLUS, 1);
- } else {
- this.expressionStack[this.expressionPtr] =
- new BinaryExpression(expr1, expr2, PLUS);
- }
- 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
+ case 295 : if (DEBUG) { System.out.println("AssignmentOperator ::= MULTIPLY_EQUAL"); } //$NON-NLS-1$
+ consumeAssignmentOperator(MULTIPLY);
+ break;
- 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 consumeProgramElements() {
- // BlockStatements ::= BlockStatements BlockStatement
- concatNodeLists();
-}
-protected void consumeCallExpressionWithArguments() {
- //optimize the push/pop
- //FunctionInvocation ::= Primary '.' 'Identifier' '(' ArgumentListopt ')'
+ case 296 : if (DEBUG) { System.out.println("AssignmentOperator ::= DIVIDE_EQUAL"); } //$NON-NLS-1$
+ consumeAssignmentOperator(DIVIDE);
+ break;
- MessageSend m = newMessageSend();
-// m.sourceStart =
-// (int) ((m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr]) >>> 32);
-// m.selector = this.identifierStack[this.identifierPtr--];
-// this.identifierLengthPtr--;
+ case 297 : if (DEBUG) { System.out.println("AssignmentOperator ::= REMAINDER_EQUAL"); } //$NON-NLS-1$
+ consumeAssignmentOperator(REMAINDER);
+ break;
- Expression receiver = this.expressionStack[this.expressionPtr];
- m.sourceStart = receiver.sourceStart;
- if (receiver instanceof SingleNameReference)
- {
- SingleNameReference singleNameReference = (SingleNameReference)receiver;
- m.selector=singleNameReference.token;
- m.nameSourcePosition = (((long) singleNameReference.sourceStart) << 32)+(singleNameReference.sourceStart+m.selector.length-1);
- receiver=null;
+ case 298 : if (DEBUG) { System.out.println("AssignmentOperator ::= PLUS_EQUAL"); } //$NON-NLS-1$
+ consumeAssignmentOperator(PLUS);
+ break;
- } else if (receiver instanceof FieldReference) {
- FieldReference fieldReference = (FieldReference) receiver;
- m.selector=fieldReference.token;
- m.nameSourcePosition= (((long) (fieldReference.sourceEnd-(m.selector.length-1))) << 32)+(fieldReference.sourceEnd);
- receiver=fieldReference.receiver;
- }
+ case 299 : if (DEBUG) { System.out.println("AssignmentOperator ::= MINUS_EQUAL"); } //$NON-NLS-1$
+ consumeAssignmentOperator(MINUS);
+ break;
+ case 300 : if (DEBUG) { System.out.println("AssignmentOperator ::= LEFT_SHIFT_EQUAL"); } //$NON-NLS-1$
+ consumeAssignmentOperator(LEFT_SHIFT);
+ break;
- m.receiver = receiver;
- m.sourceEnd = this.intStack[this.intPtr--];
- this.expressionStack[this.expressionPtr] = m;
-}
-protected void consumeCallExpressionWithArrayReference() {
- this.expressionPtr--;
- this.expressionLengthPtr--;
- Expression exp =
- this.expressionStack[this.expressionPtr] =
- new ArrayReference(
- this.expressionStack[this.expressionPtr],
- this.expressionStack[this.expressionPtr + 1]);
- exp.sourceEnd = this.endPosition;
-}
-protected void consumeCallExpressionWithSimpleName() {
- FieldReference fr =
- new FieldReference(
- this.identifierStack[this.identifierPtr],
- this.identifierPositionStack[this.identifierPtr--]);
- this.identifierLengthPtr--;
- //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 consumeCaseLabel() {
- // SwitchLabel ::= 'case' ConstantExpression ':'
- this.expressionLengthPtr--;
- Expression expression = this.expressionStack[this.expressionPtr--];
- pushOnAstStack(new CaseStatement(expression, expression.sourceEnd, this.intStack[this.intPtr--]));
-}
-protected void consumeCatches() {
- // Catches ::= Catches CatchClause
- optimizedConcatNodeLists();
-}
-protected void consumeCatchHeader() {
- // CatchDeclaration ::= 'catch' '(' FormalParameter ')' '{'
+ case 301 : if (DEBUG) { System.out.println("AssignmentOperator ::= RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$
+ consumeAssignmentOperator(RIGHT_SHIFT);
+ break;
- 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;
- }
- }
+ case 302 : if (DEBUG) { System.out.println("AssignmentOperator ::= UNSIGNED_RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$
+ consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT);
+ break;
- 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;
+ case 303 : if (DEBUG) { System.out.println("AssignmentOperator ::= AND_EQUAL"); } //$NON-NLS-1$
+ consumeAssignmentOperator(AND);
+ break;
- 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 consumeClassOrInterfaceName() {
- pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
- pushOnGenericsLengthStack(0); // handle type arguments
-}
-protected void consumeCompilationUnit() {
- // JavaScriptUnit ::= 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]);
-}
-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 consumeDebuggerStatement() {
- pushOnAstStack(new DebuggerStatement(this.intStack[this.intPtr--], this.endStatementPosition));
-}
-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 consumeEmptyBlockStatementsopt() {
- // BlockStatementsopt ::= $empty
- pushOnAstLengthStack(0);
-}
-protected void consumeEmptyCatchesopt() {
- // Catchesopt ::= $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 consumeEmptyInternalCompilationUnit() {
- // InternalCompilationUnit ::= $empty
- // nothing to do by default
- 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;
- this.compilationUnit.types[0] = declaration;
- declaration.javadoc = this.compilationUnit.javadoc;
- }
-}
-protected void consumeEmptyProgramElements() {
- pushOnAstLengthStack(0);
-}
-protected void consumeEmptyObjectLiteral() {
- ObjectLiteral objectLiteral = new ObjectLiteral();
- objectLiteral.sourceEnd = this.endStatementPosition;
- objectLiteral.sourceStart = this.intStack[this.intPtr--];
+ case 304 : if (DEBUG) { System.out.println("AssignmentOperator ::= XOR_EQUAL"); } //$NON-NLS-1$
+ consumeAssignmentOperator(XOR);
+ break;
- pushOnExpressionStack(objectLiteral);
-}
-protected void consumeEmptyPropertySetParameterList() {
- pushOnExpressionStackLengthStack(0);
-}
-protected void consumeEmptyStatement() {
- this.intPtr--;
- // EmptyStatement ::= ';'
- char[] source = this.scanner.source;
- if (this.endStatementPosition >= source.length) {
- // this would be inserted as a fake empty statement
- pushOnAstStack(new EmptyStatement(this.endStatementPosition, this.endStatementPosition));
- return;
- }
- int sourceStart = this.endStatementPosition;
-
- if (source[this.endStatementPosition] != ';') {
- if(source.length > 5 && this.endStatementPosition >= 4) {
- int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
- int pos = this.endStatementPosition - 4;
- while (source[pos] == 'u') {
- pos--;
- }
- if (source[pos] == '\\' &&
- !((c1 = ScannerHelper.getNumericValue(source[this.endStatementPosition - 3])) > 15
- || c1 < 0
- || (c2 = ScannerHelper.getNumericValue(source[this.endStatementPosition - 2])) > 15
- || c2 < 0
- || (c3 = ScannerHelper.getNumericValue(source[this.endStatementPosition - 1])) > 15
- || c3 < 0
- || (c4 = ScannerHelper.getNumericValue(source[this.endStatementPosition])) > 15
- || c4 < 0) &&
- ((char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4)) == ';'){
- // we have a Unicode for the ';' (/u003B)
- sourceStart = pos;
- }
- }
- }
- if (this.astPtr > -1) {
- if (this.astStack[this.astPtr] instanceof IDoStatement) {
- ASTNode node = this.astStack[this.astPtr];
- node.setSourceEnd(this.endStatementPosition);
- pushOnAstLengthStack(0);
- return;
- }
- }
- pushOnAstStack(new EmptyStatement(sourceStart, this.endStatementPosition));
-}
-protected void consumeEmptySwitchBlock() {
- // SwitchBlock ::= '{' '}'
- pushOnAstLengthStack(0);
-}
-protected void consumeEnterCompilationUnit() {
- // EnterCompilationUnit ::= $empty
- // do nothing by default
-}
-protected void consumeEnterVariable() {
- // EnterVariable ::= $empty
- // do nothing by default
- checkComment();
- resetModifiers();
-
- 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);
-// }
+ case 305 : if (DEBUG) { System.out.println("AssignmentOperator ::= OR_EQUAL"); } //$NON-NLS-1$
+ consumeAssignmentOperator(OR);
+ break;
- 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);
- int modifiersStart = this.intStack[this.intPtr--];
- declaration.modifiers = this.intStack[this.intPtr--];
- int varPosition = this.intStack[this.intPtr--];
- declaration.declarationSourceStart=(modifiersStart>=0)?modifiersStart:varPosition;
- this.expressionLengthPtr--;
-
- // Store javadoc only on first declaration as it is the same for all ones
- LocalDeclaration fieldDeclaration = (LocalDeclaration) 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;
-// final Annotation[] annotations = previousVariable.annotations;
-// if (annotations != null) {
-// final int annotationsLength = annotations.length;
-// System.arraycopy(annotations, 0, declaration.annotations = new Annotation[annotationsLength], 0, annotationsLength);
-// }
- }
+ case 308 : if (DEBUG) { System.out.println("Expressionopt ::="); } //$NON-NLS-1$
+ consumeEmptyExpression();
+ break;
-// 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 RecoveredUnit)
- && (this.currentToken == TokenNameDOT
- //|| declaration.modifiers != 0
- || (Util.getLineNumber(declaration.sourceStart, this.scanner.lineEnds, 0, this.scanner.linePtr)
- != Util.getLineNumber((int) (namePosition >>> 32), this.scanner.lineEnds, 0, this.scanner.linePtr)))){
- 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 {
- LocalDeclaration fieldDecl = (LocalDeclaration) this.astStack[this.astPtr];
- this.lastCheckPoint = fieldDecl.sourceEnd + 1;
- this.currentElement = this.currentElement.add(fieldDecl, 0);
-// }
- this.lastIgnoredToken = -1;
- }
-}
-protected void consumeEqualityExpression(int op) {
- // EqualityExpression ::= EqualityExpression '==' RelationalExpression
- // EqualityExpression ::= EqualityExpression '!=' RelationalExpression
+ case 314 : if (DEBUG) { System.out.println("PrimaryNoNewArrayStmt ::= SimpleName"); } //$NON-NLS-1$
+ consumePrimarySimpleName();
+ break;
- //optimize the push/pop
+ case 315 : if (DEBUG) { System.out.println("PrimaryNoNewArrayStmt ::= this"); } //$NON-NLS-1$
+ consumePrimaryNoNewArrayThis();
+ break;
- this.expressionPtr--;
- this.expressionLengthPtr--;
- this.expressionStack[this.expressionPtr] =
- new EqualExpression(
- this.expressionStack[this.expressionPtr],
- this.expressionStack[this.expressionPtr + 1],
- op);
-}
-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;
+ case 316 : if (DEBUG) { System.out.println("PrimaryNoNewArrayStmt ::= PushLPAREN Expression..."); } //$NON-NLS-1$
+ consumePrimaryNoNewArray();
+ break;
- this.recoveryExitFromVariable();
-}
-protected void consumeExitVariableWithoutInitialization() {
- // ExitVariableWithoutInitialization ::= $empty
- // do nothing by default
+ case 318 : if (DEBUG) { System.out.println("MemberExpressionStmt ::= MemberExpressionStmt LBRACKET"); } //$NON-NLS-1$
+ consumeMemberExpressionWithArrayReference();
+ break;
- 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 consumeExpressionStatement() {
- // ExpressionStatement ::= StatementExpression ';'
- this.expressionLengthPtr--;
- Expression expression = this.expressionStack[this.expressionPtr--];
- expression.statementEnd = this.endStatementPosition;
- pushOnAstStack(expression);
-}
-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 :
- */
+ case 319 : if (DEBUG) { System.out.println("MemberExpressionStmt ::= MemberExpressionStmt DOT..."); } //$NON-NLS-1$
+ consumeMemberExpressionWithSimpleName();
+ break;
- 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--;
- int modifierPositions=(int) (namePositions >>> 32);
- Argument arg =
- new Argument(
- identifierName,
- namePositions,
- null,
- ClassFileConstants.AccDefault);
-// 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);
-// }
- if (this.options.inferOptions.saveArgumentComments)
- {
- handleArgumentComment(arg);
- }
-
-
- pushOnAstStack(arg);
+ case 320 : if (DEBUG) { System.out.println("MemberExpressionStmt ::= new MemberExpression Arguments"); } //$NON-NLS-1$
+ consumeNewMemberExpressionWithArguments();
+ break;
- /* if incomplete method header, this.listLength counter will not have been reset,
- indicating that some arguments are available on the stack */
- this.listLength++;
-}
+ case 322 : if (DEBUG) { System.out.println("NewExpressionStmt ::= new NewExpression"); } //$NON-NLS-1$
+ consumeNewExpression();
+ break;
-protected void handleArgumentComment(Argument arg)
-{
- int lastComment = this.scanner.commentPtr;
+ case 323 : if (DEBUG) { System.out.println("CallExpressionStmt ::= MemberExpressionStmt Arguments"); } //$NON-NLS-1$
+ consumeCallExpressionWithArguments();
+ break;
-// if (this.modifiersSourceStart >= 0) {
-// // eliminate comments located after modifierSourceStart if positionned
-// while (lastComment >= 0 && this.scanner.commentStarts[lastComment] > this.modifiersSourceStart) lastComment--;
-// }
- if (lastComment >= 0 && this.scanner.commentStops[0]<0) {
- // consider all remaining leading comments to be part of current declaration
- int start=this.scanner.commentStarts[0];
- int end=this.scanner.commentStops[0];
- arg.comment=CharOperation.subarray(this.scanner.source, start+2, (-end)-2);
- this.scanner.commentPtr=-1;
- }
-}
-protected void consumeFormalParameterList() {
- // FormalParameterList ::= FormalParameterList ',' FormalParameter
- optimizedConcatNodeLists();
-}
-protected void consumeFormalParameterListopt() {
- // FormalParameterListopt ::= $empty
- pushOnAstLengthStack(0);
-}
-protected void consumeGetSetPropertyAssignment(boolean isSetter) {
- // remove two expressions property name/remove an optional property set parameter list
- // remove all statement from function body
- this.intPtr -= 2; // int pushed by consumeNestedMethod() and consumeOpenBlock() (called inside consumeMethodBody())
- int length = this.astLengthStack[this.astLengthPtr--];
- Statement[] statements = new Statement[length];
- this.astPtr -= length;
- System.arraycopy(
- this.astStack,
- this.astPtr + 1,
- statements,
- 0,
- length);
- Expression varName = null;
- if (isSetter) {
- this.expressionLengthPtr--;
- varName = this.expressionStack[this.expressionPtr--];
- }
- // property name
- this.expressionLengthPtr--;
- Expression propertyName = this.expressionStack[this.expressionPtr--];
- // set or get
- this.expressionLengthPtr--;
- Expression expression = this.expressionStack[this.expressionPtr--];
- int end = this.endStatementPosition;
- int start = expression.sourceStart;
+ case 324 : if (DEBUG) { System.out.println("CallExpressionStmt ::= CallExpressionStmt Arguments"); } //$NON-NLS-1$
+ consumeCallExpressionWithArguments();
+ break;
- if (expression instanceof SingleNameReference) {
- SingleNameReference reference = (SingleNameReference) expression;
- if (isSetter) {
- if (!CharOperation.equals(reference.token, "set".toCharArray())) {
- // report error
- //this.problemReporter().invalidValueForGetterSetter(expression, true);
- }
- } else {
- if (!CharOperation.equals(reference.token, "get".toCharArray())) {
- // report error
- //this.problemReporter().invalidValueForGetterSetter(expression, false);
- }
- }
- }
- ObjectGetterSetterField getterSetterField = new ObjectGetterSetterField(propertyName, statements, varName, start, end);
- pushOnExpressionStack(getterSetterField);
-}
-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) {
- this.compilationUnit.statements = new ProgramElement[length];
- this.astPtr -= length;
- System.arraycopy(this.astStack, this.astPtr + 1, this.compilationUnit.statements, 0, length);
- }
-}
-protected void consumeLabel() {
- // Do nothing
-}
-protected void consumeLeftParen() {
- // PushLPAREN ::= '('
- pushOnIntStack(this.lParenPos);
-}
-protected void consumeLocalVariableDeclaration() {
- // LocalVariableDeclaration ::= Modifiers Type VariableDeclarators ';'
+ case 325 : if (DEBUG) { System.out.println("CallExpressionStmt ::= CallExpressionStmt LBRACKET..."); } //$NON-NLS-1$
+ consumeCallExpressionWithArrayReference();
+ break;
- /*
- 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 :
+ case 326 : if (DEBUG) { System.out.println("CallExpressionStmt ::= CallExpressionStmt DOT SimpleName"); } //$NON-NLS-1$
+ consumeCallExpressionWithSimpleName();
+ break;
- */
-// 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]++;
+ case 327 : if (DEBUG) { System.out.println("Arguments ::= LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$
+ consumeArguments();
+ break;
- // update source end to include the semi-colon
- int variableDeclaratorsCounter = this.astLengthStack[this.astLengthPtr];
- AbstractVariableDeclaration nextDeclaration =null;
- for (int i = 0; i<variableDeclaratorsCounter; i++) {
- AbstractVariableDeclaration localDeclaration = (AbstractVariableDeclaration) this.astStack[this.astPtr - i];
- localDeclaration.declarationSourceEnd = this.endStatementPosition;
- localDeclaration.declarationEnd = this.endStatementPosition; // semi-colon included
- localDeclaration.nextLocal=nextDeclaration;
- nextDeclaration=localDeclaration;
- }
- this.astPtr-=variableDeclaratorsCounter-1;
- this.astLengthStack[this.astLengthPtr]=1;
- this.lastCheckPoint = endStatementPosition+1;
+ case 331 : if (DEBUG) { System.out.println("PostfixExpressionStmt ::= LeftHandSideExpressionStmt..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.PLUS, true);
+ break;
-}
-protected void consumeMemberExpressionWithArrayReference() {
- this.expressionPtr--;
- this.expressionLengthPtr--;
- Expression exp =
- this.expressionStack[this.expressionPtr] =
- new ArrayReference(
- this.expressionStack[this.expressionPtr],
- this.expressionStack[this.expressionPtr + 1]);
- exp.sourceEnd = this.endPosition;
-}
-protected void consumeMemberExpressionWithSimpleName() {
- FieldReference fr =
- new FieldReference(
- this.identifierStack[this.identifierPtr],
- this.identifierPositionStack[this.identifierPtr--]);
- this.identifierLengthPtr--;
- //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 consumeMethodBody() {
- // MethodBody ::= NestedMethod '{' BlockStatementsopt '}'
- this.nestedMethod[this.nestedType] --;
-}
-protected void consumeMethodDeclaration(boolean isNotAbstract) {
- // FunctionDeclaration ::= MethodHeader MethodBody
- // AbstractMethodDeclaration ::= MethodHeader ';'
+ case 332 : if (DEBUG) { System.out.println("PostfixExpressionStmt ::= LeftHandSideExpressionStmt..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.MINUS, true);
+ break;
- /*
- this.astStack : modifiers arguments throws statements
- this.identifierStack : type name
- this.intStack : dim dim dim
- ==>
- this.astStack : FunctionDeclaration
- this.identifierStack :
- this.intStack :
- */
+ case 333 : if (DEBUG) { System.out.println("PreIncrementExpressionStmt ::= PLUS_PLUS PushPosition..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.PLUS, false);
+ break;
+ case 334 : if (DEBUG) { System.out.println("PreDecrementExpressionStmt ::= MINUS_MINUS PushPosition"); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.MINUS, false);
+ break;
- this.nestedType--;
- int length;
- if (isNotAbstract) {
- // pop the position of the { (body of the method) pushed in block decl
- this.intPtr--;
- this.intPtr--;
- }
+ case 337 : if (DEBUG) { System.out.println("UnaryExpressionStmt ::= PLUS PushPosition..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.PLUS);
+ break;
- 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);
- }
- }
+ case 338 : if (DEBUG) { System.out.println("UnaryExpressionStmt ::= MINUS PushPosition..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.MINUS);
+ break;
- // 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;
+ case 341 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinusStmt ::= TWIDDLE PushPosition"); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.TWIDDLE);
+ break;
- // 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 && this.dietInt == 0) && statements == null && !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.sourceEnd = 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
+ case 342 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinusStmt ::= NOT PushPosition..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.NOT);
+ break;
- // retrieve end position of method declarator
- AbstractMethodDeclaration method = (AbstractMethodDeclaration)this.astStack[this.astPtr];
+ case 343 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinusStmt ::= delete PushPosition"); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.DELETE);
+ break;
- if (this.currentToken == TokenNameLBRACE){
- method.bodyStart = this.scanner.currentPosition;
- }
- else if (currentToken != TokenNameSEMICOLON) { // insert semicolon
- currentToken = TokenNameSEMICOLON;
- scanner.pushBack();
- }
- // 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;
-// }
- } else if(this.currentToken == TokenNameLBRACE) {
- if (this.currentElement instanceof RecoveredMethod &&
- ((RecoveredMethod)this.currentElement).methodDeclaration != method) {
- this.ignoreNextOpeningBrace = true;
- this.currentElement.bracketBalance++;
- } }
- this.restartRecovery = true; // used to avoid branching back into the regular automaton
- }
-}
-protected void consumeMethodHeaderName(boolean isAnonymous) {
- // 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);
-// }
+ case 344 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinusStmt ::= void PushPosition..."); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.VOID);
+ break;
- md.exprStackPtr=this.expressionPtr;
- //name
- long selectorSource =-1;
- if (!isAnonymous)
- {
- md.setSelector(this.identifierStack[this.identifierPtr]);
- selectorSource = this.identifierPositionStack[this.identifierPtr--];
- this.identifierLengthPtr--;
- }
+ case 345 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinusStmt ::= typeof PushPosition"); } //$NON-NLS-1$
+ consumeUnaryExpression(OperatorIds.TYPEOF);
+ break;
+ case 347 : if (DEBUG) { System.out.println("MultiplicativeExpressionStmt ::=..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.MULTIPLY);
+ break;
- if (this.nestedType>0)
- markEnclosingMemberWithLocalType();
+ case 348 : if (DEBUG) { System.out.println("MultiplicativeExpressionStmt ::=..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.DIVIDE);
+ break;
- //type
-// md.returnType = getTypeReference(this.intStack[this.intPtr--]);
- //modifiers
- int functionPos = this.intStack[this.intPtr--];
- int modifierPos = this.intStack[this.intPtr--];
- md.declarationSourceStart = (functionPos>modifierPos)? modifierPos:functionPos;
- 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;
+ case 349 : if (DEBUG) { System.out.println("MultiplicativeExpressionStmt ::=..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.REMAINDER);
+ break;
- //highlight starts at selector start
- if (selectorSource>=0)
- md.sourceStart = (int) (selectorSource >>> 32);
- else
- md.sourceStart=md.declarationSourceStart;
- pushOnAstStack(md);
- md.sourceEnd = this.lParenPos;
- md.bodyStart = this.lParenPos+1;
- this.listLength = 0; // initialize this.listLength before reading parameters/throws
+ case 351 : if (DEBUG) { System.out.println("AdditiveExpressionStmt ::= AdditiveExpressionStmt PLUS"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.PLUS);
+ break;
+ case 352 : if (DEBUG) { System.out.println("AdditiveExpressionStmt ::= AdditiveExpressionStmt MINUS"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.MINUS);
+ break;
+ case 354 : if (DEBUG) { System.out.println("ShiftExpressionStmt ::= ShiftExpressionStmt LEFT_SHIFT"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
+ break;
+ case 355 : if (DEBUG) { System.out.println("ShiftExpressionStmt ::= ShiftExpressionStmt RIGHT_SHIFT"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
+ break;
- incrementNestedType();
+ case 356 : if (DEBUG) { System.out.println("ShiftExpressionStmt ::= ShiftExpressionStmt..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
+ break;
- // recovery
- if (this.currentElement != null){
- if (this.currentElement instanceof RecoveredType
- //|| md.modifiers != 0
- || true/* (this.scanner.getLineNumber(md.returnType.sourceStart)
- == this.scanner.getLineNumber(md.sourceStart))*/){
- this.lastCheckPoint = md.bodyStart;
- this.currentElement = this.currentElement.add(md, 0);
- this.lastIgnoredToken = -1;
- } else {
- this.lastCheckPoint = md.sourceStart;
- this.restartRecovery = true;
- }
- }
-}
-protected void consumeMethodHeaderRightParen() {
- // MethodHeaderParameters ::= FormalParameterListopt ')'
- int length = this.astLengthStack[this.astLengthPtr--];
- this.astPtr -= length;
- AbstractMethodDeclaration md = (AbstractMethodDeclaration) this.astStack[this.astPtr];
- md.sourceEnd = this.rParenPos;
- //arguments
- if (length != 0) {
- System.arraycopy(
- this.astStack,
- this.astPtr + 1,
- md.arguments = new Argument[length],
- 0,
- length);
- }
- md.bodyStart = this.rParenPos+1;
- this.listLength = 0; // reset this.listLength after having read all parameters
- // recovery
- if (this.currentElement != null){
- this.lastCheckPoint = md.bodyStart;
- if (this.currentElement.parseTree() == md) return;
+ case 358 : if (DEBUG) { System.out.println("RelationalExpressionStmt ::= RelationalExpressionStmt..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.LESS);
+ break;
- // 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 consumeModifiers2() {
- this.expressionLengthStack[this.expressionLengthPtr - 1] += this.expressionLengthStack[this.expressionLengthPtr--];
-}
-protected void consumeNestedMethod() {
- // NestedMethod ::= $empty
- jumpOverMethodBody();
- this.nestedMethod[this.nestedType] ++;
- pushOnIntStack(this.scanner.currentPosition);
- consumeOpenBlock();
-}
-protected void consumeNestedType() {
- // NestedType ::= $empty
- incrementNestedType();
-}
-protected void incrementNestedType() {
- 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 consumeNewExpression() {
- classInstanceCreation(false, true);
-}
-protected void consumeNewMemberExpressionWithArguments() {
- classInstanceCreation(false, false);
-}
-protected void consumeOpenBlock() {
- // OpenBlock ::= $empty
+ case 359 : if (DEBUG) { System.out.println("RelationalExpressionStmt ::= RelationalExpressionStmt..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.GREATER);
+ break;
- 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 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 consumePrimaryNoNewArrayThis() {
- // PrimaryNoNewArray ::= 'this'
- pushOnExpressionStack(new ThisReference(this.intStack[this.intPtr--], this.endPosition));
-}
-protected void consumePrimarySimpleName() {
- // PrimaryNoNewArray ::= SimpleName
- pushOnExpressionStack(getUnspecifiedReferenceOptimized());
-}
-protected void consumePropertyAssignment() {
- // MemberValuePair ::= SimpleName '=' MemberValue
- this.modifiersSourceStart=-1;
- this.checkComment();
- this.resetModifiers();
+ case 360 : if (DEBUG) { System.out.println("RelationalExpressionStmt ::= RelationalExpressionStmt..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.LESS_EQUAL);
+ break;
- Expression value = this.expressionStack[this.expressionPtr--];
- this.expressionLengthPtr--;
+ case 361 : if (DEBUG) { System.out.println("RelationalExpressionStmt ::= RelationalExpressionStmt..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
+ break;
- Expression field = this.expressionStack[this.expressionPtr--];
- this.expressionLengthPtr--;
- int end = value.sourceEnd;
- int start = field.sourceStart;
+ case 362 : if (DEBUG) { System.out.println("RelationalExpressionStmt ::= RelationalExpressionStmt..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.INSTANCEOF);
+ break;
- ObjectLiteralField literalField = new ObjectLiteralField(field, value, start, end);
- pushOnExpressionStack(literalField);
+ case 363 : if (DEBUG) { System.out.println("RelationalExpressionStmt ::= RelationalExpressionStmt in"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.IN);
+ break;
- if (this.javadoc!=null) {
- literalField.javaDoc = this.javadoc;
- }
- else if (value instanceof FunctionExpression)
- {
- MethodDeclaration methodDeclaration = ((FunctionExpression)value).methodDeclaration;
- literalField.javaDoc=methodDeclaration.javadoc;
- methodDeclaration.javadoc=null;
- }
- this.javadoc = null;
+ case 365 : if (DEBUG) { System.out.println("EqualityExpressionStmt ::= EqualityExpressionStmt..."); } //$NON-NLS-1$
+ consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
+ break;
- // discard obsolete comments while inside methods or fields initializer (see bug 74369)
- if (!(this.diet && this.dietInt==0) && this.scanner.commentPtr >= 0) {
- flushCommentsDefinedPriorTo(literalField.sourceEnd);
- }
- resetModifiers();
-}
-protected void consumePropertyName() {
- pushOnExpressionStack(getUnspecifiedReferenceOptimized());
-}
-protected void consumePropertyNameAndValueList() {
- concatExpressionLists();
-}
-protected void consumePropertySetParameterList() {
- pushOnExpressionStack(getUnspecifiedReferenceOptimized());
-}
-protected void consumePushLeftBrace() {
- pushOnIntStack(this.endPosition); // modifiers
-}
+ case 366 : if (DEBUG) { System.out.println("EqualityExpressionStmt ::= EqualityExpressionStmt..."); } //$NON-NLS-1$
+ consumeEqualityExpression(OperatorIds.NOT_EQUAL);
+ break;
-protected void consumeArrayLiteralHeader() {
- pushOnIntStack(this.endPosition); // modifiers
- pushOnIntStack(0); // numExprs
-}
-protected void consumePushModifiers() {
- 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*/
+ case 367 : if (DEBUG) { System.out.println("EqualityExpressionStmt ::= EqualityExpressionStmt..."); } //$NON-NLS-1$
+ consumeEqualityExpression(OperatorIds.EQUAL_EQUAL_EQUAL);
+ break;
- 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(false);
-}
-protected void consumeRestoreDiet() {
- // RestoreDiet ::= $empty
- this.dietInt--;
-}
-protected void consumeRightParen() {
- // PushRPAREN ::= ')'
- pushOnIntStack(this.rParenPos);
-}
-private void consumeFunctionExpression() {
+ case 368 : if (DEBUG) { System.out.println("EqualityExpressionStmt ::= EqualityExpressionStmt..."); } //$NON-NLS-1$
+ consumeEqualityExpression(OperatorIds.NOT_EQUAL_EQUAL);
+ break;
- consumeMethodDeclaration(true);
- MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr--];
- this.astLengthPtr--;
- FunctionExpression funcExpr=new FunctionExpression(md);
- funcExpr.sourceEnd=md.declarationSourceEnd;
- funcExpr.sourceStart=md.declarationSourceStart;
- pushOnExpressionStack(funcExpr);
-}
+ case 370 : if (DEBUG) { System.out.println("AndExpressionStmt ::= AndExpressionStmt AND..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.AND);
+ break;
-private void consumeStatementForIn() {
-// int length;
- Expression collection = null;
- Statement iteratorVar;
- boolean scope = true;
+ case 372 : if (DEBUG) { System.out.println("ExclusiveOrExpressionStmt ::= ExclusiveOrExpressionStmt"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.XOR);
+ break;
- //statements
- this.astLengthPtr--;
- Statement statement = (Statement) this.astStack[this.astPtr--];
+ case 374 : if (DEBUG) { System.out.println("InclusiveOrExpressionStmt ::= InclusiveOrExpressionStmt"); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.OR);
+ break;
- if (this.expressionLengthStack[this.expressionLengthPtr--] != 0)
- collection = this.expressionStack[this.expressionPtr--];
+ case 376 : if (DEBUG) { System.out.println("ConditionalAndExpressionStmt ::=..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.AND_AND);
+ break;
- this.astLengthPtr--;
- iteratorVar = (Statement) this.astStack[this.astPtr--];
- pushOnAstStack(
- new ForInStatement(
- iteratorVar,
- collection,
- statement,
- scope,
- this.intStack[this.intPtr--],
- this.endStatementPosition));
+ case 378 : if (DEBUG) { System.out.println("ConditionalOrExpressionStmt ::=..."); } //$NON-NLS-1$
+ consumeBinaryExpression(OperatorIds.OR_OR);
+ break;
-}
+ case 380 : if (DEBUG) { System.out.println("ConditionalExpressionStmt ::=..."); } //$NON-NLS-1$
+ consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;
+ break;
-private void consumeArrayLiteralList() {
- concatExpressionLists();
- this.intStack[this.intPtr]&= ~(UNCONSUMED_ELISION|UNCONSUMED_LIT_ELEMENT);
-}
-private void consumeArrayLiteralListOne() {
- if ( (this.intStack[this.intPtr]&UNCONSUMED_ELISION)!=0)
- {
- concatExpressionLists();
- this.intStack[this.intPtr]&= ~(UNCONSUMED_ELISION|UNCONSUMED_LIT_ELEMENT);
- }
+ case 383 : if (DEBUG) { System.out.println("AssignmentStmt ::= PostfixExpressionStmt..."); } //$NON-NLS-1$
+ consumeAssignment();
+ break;
+ case 384 : if (DEBUG) { System.out.println("Modifiersopt ::="); } //$NON-NLS-1$
+ consumeDefaultModifiers();
+ break;
-}
+ case 385 : if (DEBUG) { System.out.println("BlockStatementsopt ::="); } //$NON-NLS-1$
+ consumeEmptyBlockStatementsopt();
+ break;
-private void consumeListExpression() {
- this.expressionPtr--;
- this.expressionLengthPtr--;
- Expression expr1 = this.expressionStack[this.expressionPtr];
- Expression expr2 = this.expressionStack[this.expressionPtr + 1];
- this.expressionStack[this.expressionPtr] =
- new ListExpression(
- expr1,
- expr2);
+ case 387 : if (DEBUG) { System.out.println("ArgumentListopt ::="); } //$NON-NLS-1$
+ consumeEmptyArgumentListopt();
+ break;
-}
+ case 389 : if (DEBUG) { System.out.println("FormalParameterListopt ::="); } //$NON-NLS-1$
+ consumeFormalParameterListopt();
+ break;
-protected void consumePostDoc() {
-
- if (this.options.inferOptions.docLocation==InferOptions.DOC_LOCATION_AFTER)
- {
-
- }
-}
+ case 391 : if (DEBUG) { System.out.println("ForInitopt ::="); } //$NON-NLS-1$
+ consumeEmptyForInitopt();
+ break;
-// This method is part of an automatic generation : do NOT edit-modify
-protected void consumeRule(int act) {
- switch ( act ) {
- case 23 : if (DEBUG) { System.out.println("CompilationUnit ::= EnterCompilationUnit..."); } //$NON-NLS-1$
- consumeCompilationUnit();
- break;
-
- case 24 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ProgramElements"); } //$NON-NLS-1$
- consumeInternalCompilationUnitWithTypes();
- break;
-
- case 25 : if (DEBUG) { System.out.println("InternalCompilationUnit ::="); } //$NON-NLS-1$
- consumeEmptyInternalCompilationUnit();
- break;
-
- case 26 : if (DEBUG) { System.out.println("EnterCompilationUnit ::="); } //$NON-NLS-1$
- consumeEnterCompilationUnit();
- break;
-
- case 30 : if (DEBUG) { System.out.println("CatchHeader ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$
- consumeCatchHeader();
- break;
-
- case 32 : if (DEBUG) { System.out.println("VariableDeclarators ::= VariableDeclarators COMMA..."); } //$NON-NLS-1$
- consumeVariableDeclarators();
- break;
-
- case 34 : if (DEBUG) { System.out.println("VariableDeclaratorsNoIn ::= VariableDeclaratorsNoIn COMMA"); } //$NON-NLS-1$
- consumeVariableDeclarators();
- break;
-
- case 39 : if (DEBUG) { System.out.println("EnterVariable ::="); } //$NON-NLS-1$
- consumeEnterVariable();
- break;
-
- case 40 : if (DEBUG) { System.out.println("ExitVariableWithInitialization ::="); } //$NON-NLS-1$
- consumeExitVariableWithInitialization();
- break;
-
- case 41 : if (DEBUG) { System.out.println("ExitVariableWithoutInitialization ::="); } //$NON-NLS-1$
- consumeExitVariableWithoutInitialization();
- break;
-
- case 42 : if (DEBUG) { System.out.println("ForceNoDiet ::="); } //$NON-NLS-1$
- consumeForceNoDiet();
- break;
-
- case 43 : if (DEBUG) { System.out.println("RestoreDiet ::="); } //$NON-NLS-1$
- consumeRestoreDiet();
- break;
-
- case 47 : if (DEBUG) { System.out.println("FunctionExpression ::= FunctionExpressionHeader..."); } //$NON-NLS-1$
- // set to true to consume a method with a body
- consumeFunctionExpression();
- break;
-
- case 48 : if (DEBUG) { System.out.println("FunctionExpressionHeader ::= FunctionExpressionHeaderName"); } //$NON-NLS-1$
- consumeMethodHeader();
- break;
-
- case 49 : if (DEBUG) { System.out.println("FunctionExpressionHeaderName ::= Modifiersopt function..."); } //$NON-NLS-1$
- consumeMethodHeaderName(false);
- break;
-
- case 50 : if (DEBUG) { System.out.println("FunctionExpressionHeaderName ::= Modifiersopt function..."); } //$NON-NLS-1$
- consumeMethodHeaderName(true);
- break;
-
- case 52 : 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 53 : if (DEBUG) { System.out.println("AbstractMethodDeclaration ::= MethodHeader SEMICOLON"); } //$NON-NLS-1$
- // set to false to consume a method without body
- consumeMethodDeclaration(false);
- break;
-
- case 54 : if (DEBUG) { System.out.println("MethodHeader ::= MethodHeaderName FormalParameterListopt"); } //$NON-NLS-1$
- consumeMethodHeader();
- break;
-
- case 55 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt function Identifier..."); } //$NON-NLS-1$
- consumeMethodHeaderName(false);
- break;
-
- case 56 : if (DEBUG) { System.out.println("MethodHeaderRightParen ::= RPAREN"); } //$NON-NLS-1$
- consumeMethodHeaderRightParen();
- break;
-
- case 58 : if (DEBUG) { System.out.println("FormalParameterList ::= FormalParameterList COMMA..."); } //$NON-NLS-1$
- consumeFormalParameterList();
- break;
-
- case 59 : if (DEBUG) { System.out.println("FormalParameter ::= VariableDeclaratorId"); } //$NON-NLS-1$
- consumeFormalParameter(false);
- break;
-
- case 60 : if (DEBUG) { System.out.println("MethodBody ::= NestedMethod LBRACE PostDoc..."); } //$NON-NLS-1$
- consumeMethodBody();
- break;
-
- case 61 : if (DEBUG) { System.out.println("NestedMethod ::="); } //$NON-NLS-1$
- consumeNestedMethod();
- break;
-
- case 62 : if (DEBUG) { System.out.println("PostDoc ::="); } //$NON-NLS-1$
- consumePostDoc();
- break;
-
- case 63 : if (DEBUG) { System.out.println("PushLeftBraceObjectLiteral ::="); } //$NON-NLS-1$
- consumePushLeftBrace();
- break;
-
- case 64 : if (DEBUG) { System.out.println("Block ::= OpenBlock LBRACE BlockStatementsopt RBRACE"); } //$NON-NLS-1$
- consumeBlock();
- break;
-
- case 65 : if (DEBUG) { System.out.println("OpenBlock ::="); } //$NON-NLS-1$
- consumeOpenBlock() ;
- break;
-
- case 67 : if (DEBUG) { System.out.println("ProgramElements ::= ProgramElements ProgramElement"); } //$NON-NLS-1$
- consumeProgramElements() ;
- break;
-
- case 70 : if (DEBUG) { System.out.println("BlockStatements ::= BlockStatements BlockStatement"); } //$NON-NLS-1$
- consumeBlockStatements() ;
- break;
-
- case 74 : if (DEBUG) { System.out.println("LocalVariableDeclarationStatement ::=..."); } //$NON-NLS-1$
- consumeLocalVariableDeclarationStatement();
- break;
-
- case 75 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= var PushModifiers..."); } //$NON-NLS-1$
- consumeLocalVariableDeclaration();
- break;
-
- case 76 : if (DEBUG) { System.out.println("LocalVariableDeclarationNoIn ::= var PushModifiers..."); } //$NON-NLS-1$
- consumeLocalVariableDeclaration();
- break;
-
- case 77 : if (DEBUG) { System.out.println("PushModifiers ::="); } //$NON-NLS-1$
- consumePushModifiers();
- break;
-
- case 102 : if (DEBUG) { System.out.println("EmptyStatement ::= PushPosition SEMICOLON"); } //$NON-NLS-1$
- consumeEmptyStatement();
- break;
-
- case 103 : if (DEBUG) { System.out.println("LabeledStatement ::= Label COLON Statement"); } //$NON-NLS-1$
- consumeStatementLabel() ;
- break;
-
- case 104 : if (DEBUG) { System.out.println("LabeledStatementNoShortIf ::= Label COLON..."); } //$NON-NLS-1$
- consumeStatementLabel() ;
- break;
-
- case 105 : if (DEBUG) { System.out.println("Label ::= Identifier"); } //$NON-NLS-1$
- consumeLabel() ;
- break;
-
- case 106 : if (DEBUG) { System.out.println("ExpressionStatement ::= StatementExpression SEMICOLON"); } //$NON-NLS-1$
- consumeExpressionStatement();
- break;
-
- case 108 : if (DEBUG) { System.out.println("IfThenStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$
- consumeStatementIfNoElse();
- break;
-
- case 109 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$
- consumeStatementIfWithElse();
- break;
-
- case 110 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); } //$NON-NLS-1$
- consumeStatementIfWithElse();
- break;
-
- case 111 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); } //$NON-NLS-1$
- consumeStatementIfWithElse();
- break;
-
- case 112 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); } //$NON-NLS-1$
- consumeStatementIfWithElse();
- break;
-
- case 113 : if (DEBUG) { System.out.println("SwitchStatement ::= switch LPAREN Expression RPAREN..."); } //$NON-NLS-1$
- consumeStatementSwitch() ;
- break;
-
- case 114 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE RBRACE"); } //$NON-NLS-1$
- consumeEmptySwitchBlock() ;
- break;
-
- case 117 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE SwitchBlockStatements..."); } //$NON-NLS-1$
- consumeSwitchBlock() ;
- break;
-
- case 119 : if (DEBUG) { System.out.println("SwitchBlockStatements ::= SwitchBlockStatements..."); } //$NON-NLS-1$
- consumeSwitchBlockStatements() ;
- break;
-
- case 120 : if (DEBUG) { System.out.println("SwitchBlockStatement ::= SwitchLabels BlockStatements"); } //$NON-NLS-1$
- consumeSwitchBlockStatement() ;
- break;
-
- case 122 : if (DEBUG) { System.out.println("SwitchLabels ::= SwitchLabels SwitchLabel"); } //$NON-NLS-1$
- consumeSwitchLabels() ;
- break;
-
- case 123 : if (DEBUG) { System.out.println("SwitchLabel ::= case ConstantExpression COLON"); } //$NON-NLS-1$
- consumeCaseLabel();
- break;
-
- case 124 : if (DEBUG) { System.out.println("SwitchLabel ::= default COLON"); } //$NON-NLS-1$
- consumeDefaultLabel();
- break;
-
- case 125 : if (DEBUG) { System.out.println("WhileStatement ::= while LPAREN Expression RPAREN..."); } //$NON-NLS-1$
- consumeStatementWhile() ;
- break;
-
- case 126 : if (DEBUG) { System.out.println("WhileStatementNoShortIf ::= while LPAREN Expression..."); } //$NON-NLS-1$
- consumeStatementWhile() ;
- break;
-
- case 127 : if (DEBUG) { System.out.println("WithStatement ::= with LPAREN Expression RPAREN..."); } //$NON-NLS-1$
- consumeStatementWith() ;
- break;
-
- case 128 : if (DEBUG) { System.out.println("WithStatementNoShortIf ::= with LPAREN Expression RPAREN"); } //$NON-NLS-1$
- consumeStatementWith() ;
- break;
-
- case 129 : if (DEBUG) { System.out.println("DoStatement ::= do Statement while LPAREN Expression..."); } //$NON-NLS-1$
- consumeStatementDo() ;
- break;
-
- case 130 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInitopt SEMICOLON..."); } //$NON-NLS-1$
- consumeStatementFor() ;
- break;
-
- case 131 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInInit in Expression..."); } //$NON-NLS-1$
- consumeStatementForIn() ;
- break;
-
- case 132 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInitopt..."); } //$NON-NLS-1$
- consumeStatementFor() ;
- break;
-
- case 133 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInInit in..."); } //$NON-NLS-1$
- consumeStatementForIn() ;
- break;
-
- case 134 : if (DEBUG) { System.out.println("ForInInit ::= LeftHandSideExpression"); } //$NON-NLS-1$
- consumeForInInit() ;
- break;
-
- case 136 : if (DEBUG) { System.out.println("ForInit ::= ExpressionNoIn"); } //$NON-NLS-1$
- consumeForInit() ;
- break;
-
- case 140 : if (DEBUG) { System.out.println("StatementExpressionList ::= StatementExpressionList..."); } //$NON-NLS-1$
- consumeStatementExpressionList() ;
- break;
-
- case 141 : if (DEBUG) { System.out.println("BreakStatement ::= break SEMICOLON"); } //$NON-NLS-1$
- consumeStatementBreak() ;
- break;
-
- case 142 : if (DEBUG) { System.out.println("BreakStatement ::= break Identifier SEMICOLON"); } //$NON-NLS-1$
- consumeStatementBreakWithLabel() ;
- break;
-
- case 143 : if (DEBUG) { System.out.println("ContinueStatement ::= continue SEMICOLON"); } //$NON-NLS-1$
- consumeStatementContinue() ;
- break;
-
- case 144 : if (DEBUG) { System.out.println("ContinueStatement ::= continue Identifier SEMICOLON"); } //$NON-NLS-1$
- consumeStatementContinueWithLabel() ;
- break;
-
- case 145 : if (DEBUG) { System.out.println("ReturnStatement ::= return Expressionopt SEMICOLON"); } //$NON-NLS-1$
- consumeStatementReturn() ;
- break;
-
- case 146 : if (DEBUG) { System.out.println("ThrowStatement ::= throw Expression SEMICOLON"); } //$NON-NLS-1$
- consumeStatementThrow();
- break;
-
- case 147 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catches"); } //$NON-NLS-1$
- consumeStatementTry(false);
- break;
-
- case 148 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catchesopt Finally"); } //$NON-NLS-1$
- consumeStatementTry(true);
- break;
-
- case 150 : if (DEBUG) { System.out.println("ExitTryBlock ::="); } //$NON-NLS-1$
- consumeExitTryBlock();
- break;
-
- case 152 : if (DEBUG) { System.out.println("Catches ::= Catches CatchClause"); } //$NON-NLS-1$
- consumeCatches();
- break;
-
- case 153 : if (DEBUG) { System.out.println("CatchClause ::= catch LPAREN FormalParameter RPAREN..."); } //$NON-NLS-1$
- consumeStatementCatch() ;
- break;
-
- case 155 : if (DEBUG) { System.out.println("DebuggerStatement ::= debugger SEMICOLON"); } //$NON-NLS-1$
- consumeDebuggerStatement() ;
- break;
-
- case 156 : if (DEBUG) { System.out.println("PushLPAREN ::= LPAREN"); } //$NON-NLS-1$
- consumeLeftParen();
- break;
-
- case 157 : if (DEBUG) { System.out.println("PushRPAREN ::= RPAREN"); } //$NON-NLS-1$
- consumeRightParen();
- break;
-
- case 162 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= SimpleName"); } //$NON-NLS-1$
- consumePrimarySimpleName();
- break;
-
- case 163 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= this"); } //$NON-NLS-1$
- consumePrimaryNoNewArrayThis();
- break;
-
- case 164 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Expression PushRPAREN"); } //$NON-NLS-1$
- consumePrimaryNoNewArray();
- break;
-
- case 165 : if (DEBUG) { System.out.println("ObjectLiteral ::= LBRACE PushLeftBraceObjectLiteral..."); } //$NON-NLS-1$
- consumeEmptyObjectLiteral();
- break;
-
- case 166 : if (DEBUG) { System.out.println("ObjectLiteral ::= LBRACE PushLeftBraceObjectLiteral..."); } //$NON-NLS-1$
- consumeObjectLiteral();
- break;
-
- case 167 : if (DEBUG) { System.out.println("ObjectLiteral ::= LBRACE PushLeftBraceObjectLiteral..."); } //$NON-NLS-1$
- consumeObjectLiteral();
- break;
-
- case 169 : if (DEBUG) { System.out.println("PropertyNameAndValueList ::= PropertyNameAndValueList..."); } //$NON-NLS-1$
- consumePropertyNameAndValueList();
- break;
-
- case 170 : if (DEBUG) { System.out.println("PropertyAssignment ::= PropertyName COLON..."); } //$NON-NLS-1$
- consumePropertyAssignment();
- break;
-
- case 171 : if (DEBUG) { System.out.println("PropertyAssignment ::= PropertyName PropertyName LPAREN"); } //$NON-NLS-1$
- consumeGetSetPropertyAssignment(false);
- break;
-
- case 172 : if (DEBUG) { System.out.println("PropertyAssignment ::= PropertyName PropertyName LPAREN"); } //$NON-NLS-1$
- consumeGetSetPropertyAssignment(true);
- break;
-
- case 173 : if (DEBUG) { System.out.println("PropertySetParameterList ::= SimpleName"); } //$NON-NLS-1$
- consumePropertySetParameterList();
- break;
-
- case 174 : if (DEBUG) { System.out.println("FunctionBody ::= NestedMethod LBRACE PostDoc..."); } //$NON-NLS-1$
- consumeMethodBody();
- break;
-
- case 175 : if (DEBUG) { System.out.println("ProgramElementsopt ::="); } //$NON-NLS-1$
- consumeEmptyProgramElements();
- break;
-
- case 177 : if (DEBUG) { System.out.println("PropertyName ::= SimpleName"); } //$NON-NLS-1$
- consumePropertyName();
- break;
-
- case 181 : if (DEBUG) { System.out.println("ArrayLiteral ::= ArrayLiteralHeader ElisionOpt RBRACKET"); } //$NON-NLS-1$
- consumeArrayLiteral(false);
- break;
-
- case 182 : if (DEBUG) { System.out.println("ArrayLiteral ::= ArrayLiteralHeader..."); } //$NON-NLS-1$
- consumeArrayLiteral(false);
- break;
-
- case 183 : if (DEBUG) { System.out.println("ArrayLiteral ::= ArrayLiteralHeader..."); } //$NON-NLS-1$
- consumeArrayLiteral(true);
- break;
-
- case 184 : if (DEBUG) { System.out.println("ArrayLiteralHeader ::= LBRACKET"); } //$NON-NLS-1$
- consumeArrayLiteralHeader();
- break;
-
- case 185 : if (DEBUG) { System.out.println("ElisionOpt ::="); } //$NON-NLS-1$
- consumeElisionEmpty();
- break;
-
- case 187 : if (DEBUG) { System.out.println("Elision ::= COMMA"); } //$NON-NLS-1$
- consumeElisionOne();
- break;
-
- case 188 : if (DEBUG) { System.out.println("Elision ::= Elision COMMA"); } //$NON-NLS-1$
- consumeElisionList();
- break;
-
- case 189 : if (DEBUG) { System.out.println("ArrayLiteralElementList ::= ElisionOpt..."); } //$NON-NLS-1$
- consumeArrayLiteralListOne();
- break;
-
- case 190 : if (DEBUG) { System.out.println("ArrayLiteralElementList ::= ArrayLiteralElementList..."); } //$NON-NLS-1$
- consumeArrayLiteralList();
- break;
-
- case 191 : if (DEBUG) { System.out.println("ArrayLiteralElement ::= AssignmentExpression"); } //$NON-NLS-1$
- consumeArrayLiteralElement();
- break;
-
- case 194 : if (DEBUG) { System.out.println("MemberExpression ::= MemberExpression LBRACKET..."); } //$NON-NLS-1$
- consumeMemberExpressionWithArrayReference();
- break;
-
- case 195 : if (DEBUG) { System.out.println("MemberExpression ::= MemberExpression DOT SimpleName"); } //$NON-NLS-1$
- consumeMemberExpressionWithSimpleName();
- break;
-
- case 196 : if (DEBUG) { System.out.println("MemberExpression ::= new MemberExpression Arguments"); } //$NON-NLS-1$
- consumeNewMemberExpressionWithArguments();
- break;
-
- case 198 : if (DEBUG) { System.out.println("NewExpression ::= new NewExpression"); } //$NON-NLS-1$
- consumeNewExpression();
- break;
-
- case 199 : if (DEBUG) { System.out.println("CallExpression ::= MemberExpression Arguments"); } //$NON-NLS-1$
- consumeCallExpressionWithArguments();
- break;
-
- case 200 : if (DEBUG) { System.out.println("CallExpression ::= CallExpression Arguments"); } //$NON-NLS-1$
- consumeCallExpressionWithArguments();
- break;
-
- case 201 : if (DEBUG) { System.out.println("CallExpression ::= CallExpression LBRACKET Expression..."); } //$NON-NLS-1$
- consumeCallExpressionWithArrayReference();
- break;
-
- case 202 : if (DEBUG) { System.out.println("CallExpression ::= CallExpression DOT SimpleName"); } //$NON-NLS-1$
- consumeCallExpressionWithSimpleName();
- break;
-
- case 206 : if (DEBUG) { System.out.println("PostfixExpression ::= LeftHandSideExpression PLUS_PLUS"); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.PLUS, true);
- break;
-
- case 207 : if (DEBUG) { System.out.println("PostfixExpression ::= LeftHandSideExpression MINUS_MINUS"); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.MINUS, true);
- break;
-
- case 209 : if (DEBUG) { System.out.println("ListExpression ::= ListExpression COMMA..."); } //$NON-NLS-1$
- consumeListExpression();
- break;
-
- case 211 : if (DEBUG) { System.out.println("ListExpressionNoIn ::= ListExpressionNoIn COMMA..."); } //$NON-NLS-1$
- consumeListExpression();
- break;
-
- case 213 : if (DEBUG) { System.out.println("ListExpressionStmt ::= ListExpressionStmt COMMA..."); } //$NON-NLS-1$
- consumeListExpression();
- break;
-
- case 215 : if (DEBUG) { System.out.println("ArgumentList ::= ArgumentList COMMA AssignmentExpression"); } //$NON-NLS-1$
- consumeArgumentList();
- break;
-
- case 216 : if (DEBUG) { System.out.println("PushPosition ::="); } //$NON-NLS-1$
- consumePushPosition();
- break;
-
- case 219 : if (DEBUG) { System.out.println("UnaryExpression ::= PLUS PushPosition UnaryExpression"); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.PLUS);
- break;
-
- case 220 : if (DEBUG) { System.out.println("UnaryExpression ::= MINUS PushPosition UnaryExpression"); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.MINUS);
- break;
-
- case 222 : if (DEBUG) { System.out.println("PreIncrementExpression ::= PLUS_PLUS PushPosition..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.PLUS, false);
- break;
-
- case 223 : if (DEBUG) { System.out.println("PreDecrementExpression ::= MINUS_MINUS PushPosition..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.MINUS, false);
- break;
-
- case 225 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= TWIDDLE PushPosition..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.TWIDDLE);
- break;
-
- case 226 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= NOT PushPosition..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.NOT);
- break;
-
- case 227 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= delete PushPosition..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.DELETE);
- break;
-
- case 228 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= void PushPosition..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.VOID);
- break;
-
- case 229 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= typeof PushPosition..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.TYPEOF);
- break;
-
- case 231 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.MULTIPLY);
- break;
-
- case 232 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.DIVIDE);
- break;
-
- case 233 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.REMAINDER);
- break;
-
- case 235 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression PLUS..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.PLUS);
- break;
-
- case 236 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression MINUS..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.MINUS);
- break;
-
- case 238 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression LEFT_SHIFT..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
- break;
-
- case 239 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression RIGHT_SHIFT..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
- break;
-
- case 240 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression UNSIGNED_RIGHT_SHIFT"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
- break;
-
- case 242 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.LESS);
- break;
-
- case 243 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression GREATER..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.GREATER);
- break;
-
- case 244 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS_EQUAL"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.LESS_EQUAL);
- break;
-
- case 245 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
- break;
-
- case 246 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression instanceof"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.INSTANCEOF);
- break;
-
- case 247 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression in..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.IN);
- break;
-
- case 249 : if (DEBUG) { System.out.println("RelationalExpressionNoIn ::= RelationalExpressionNoIn..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.LESS);
- break;
-
- case 250 : if (DEBUG) { System.out.println("RelationalExpressionNoIn ::= RelationalExpressionNoIn..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.GREATER);
- break;
-
- case 251 : if (DEBUG) { System.out.println("RelationalExpressionNoIn ::= RelationalExpressionNoIn..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.LESS_EQUAL);
- break;
-
- case 252 : if (DEBUG) { System.out.println("RelationalExpressionNoIn ::= RelationalExpressionNoIn..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
- break;
-
- case 253 : if (DEBUG) { System.out.println("RelationalExpressionNoIn ::= RelationalExpressionNoIn..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.INSTANCEOF);
- break;
-
- case 255 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression EQUAL_EQUAL..."); } //$NON-NLS-1$
- consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
- break;
-
- case 256 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression NOT_EQUAL..."); } //$NON-NLS-1$
- consumeEqualityExpression(OperatorIds.NOT_EQUAL);
- break;
-
- case 257 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression..."); } //$NON-NLS-1$
- consumeEqualityExpression(OperatorIds.EQUAL_EQUAL_EQUAL);
- break;
-
- case 258 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression..."); } //$NON-NLS-1$
- consumeEqualityExpression(OperatorIds.NOT_EQUAL_EQUAL);
- break;
-
- case 260 : if (DEBUG) { System.out.println("EqualityExpressionNoIn ::= EqualityExpressionNoIn..."); } //$NON-NLS-1$
- consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
- break;
-
- case 261 : if (DEBUG) { System.out.println("EqualityExpressionNoIn ::= EqualityExpressionNoIn..."); } //$NON-NLS-1$
- consumeEqualityExpression(OperatorIds.NOT_EQUAL);
- break;
-
- case 262 : if (DEBUG) { System.out.println("EqualityExpressionNoIn ::= EqualityExpressionNoIn..."); } //$NON-NLS-1$
- consumeEqualityExpression(OperatorIds.EQUAL_EQUAL_EQUAL);
- break;
-
- case 263 : if (DEBUG) { System.out.println("EqualityExpressionNoIn ::= EqualityExpressionNoIn..."); } //$NON-NLS-1$
- consumeEqualityExpression(OperatorIds.NOT_EQUAL_EQUAL);
- break;
-
- case 265 : if (DEBUG) { System.out.println("AndExpression ::= AndExpression AND EqualityExpression"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.AND);
- break;
-
- case 267 : if (DEBUG) { System.out.println("AndExpressionNoIn ::= AndExpressionNoIn AND..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.AND);
- break;
-
- case 269 : if (DEBUG) { System.out.println("ExclusiveOrExpression ::= ExclusiveOrExpression XOR..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.XOR);
- break;
-
- case 271 : if (DEBUG) { System.out.println("ExclusiveOrExpressionNoIn ::= ExclusiveOrExpressionNoIn"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.XOR);
- break;
-
- case 273 : if (DEBUG) { System.out.println("InclusiveOrExpression ::= InclusiveOrExpression OR..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.OR);
- break;
-
- case 275 : if (DEBUG) { System.out.println("InclusiveOrExpressionNoIn ::= InclusiveOrExpressionNoIn"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.OR);
- break;
-
- case 277 : if (DEBUG) { System.out.println("ConditionalAndExpression ::= ConditionalAndExpression..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.AND_AND);
- break;
-
- case 279 : if (DEBUG) { System.out.println("ConditionalAndExpressionNoIn ::=..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.AND_AND);
- break;
-
- case 281 : if (DEBUG) { System.out.println("ConditionalOrExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.OR_OR);
- break;
-
- case 283 : if (DEBUG) { System.out.println("ConditionalOrExpressionNoIn ::=..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.OR_OR);
- break;
-
- case 285 : if (DEBUG) { System.out.println("ConditionalExpression ::= ConditionalOrExpression..."); } //$NON-NLS-1$
- consumeConditionalExpression(OperatorIds.QUESTIONCOLON);
- break;
-
- case 287 : if (DEBUG) { System.out.println("ConditionalExpressionNoIn ::=..."); } //$NON-NLS-1$
- consumeConditionalExpression(OperatorIds.QUESTIONCOLON);
- break;
-
- case 292 : if (DEBUG) { System.out.println("Assignment ::= PostfixExpression AssignmentOperator..."); } //$NON-NLS-1$
- consumeAssignment();
- break;
-
- case 293 : if (DEBUG) { System.out.println("AssignmentNoIn ::= PostfixExpression AssignmentOperator"); } //$NON-NLS-1$
- consumeAssignment();
- break;
-
- case 294 : if (DEBUG) { System.out.println("AssignmentOperator ::= EQUAL"); } //$NON-NLS-1$
- consumeAssignmentOperator(EQUAL);
- break;
-
- case 295 : if (DEBUG) { System.out.println("AssignmentOperator ::= MULTIPLY_EQUAL"); } //$NON-NLS-1$
- consumeAssignmentOperator(MULTIPLY);
- break;
-
- case 296 : if (DEBUG) { System.out.println("AssignmentOperator ::= DIVIDE_EQUAL"); } //$NON-NLS-1$
- consumeAssignmentOperator(DIVIDE);
- break;
-
- case 297 : if (DEBUG) { System.out.println("AssignmentOperator ::= REMAINDER_EQUAL"); } //$NON-NLS-1$
- consumeAssignmentOperator(REMAINDER);
- break;
-
- case 298 : if (DEBUG) { System.out.println("AssignmentOperator ::= PLUS_EQUAL"); } //$NON-NLS-1$
- consumeAssignmentOperator(PLUS);
- break;
-
- case 299 : if (DEBUG) { System.out.println("AssignmentOperator ::= MINUS_EQUAL"); } //$NON-NLS-1$
- consumeAssignmentOperator(MINUS);
- break;
-
- case 300 : if (DEBUG) { System.out.println("AssignmentOperator ::= LEFT_SHIFT_EQUAL"); } //$NON-NLS-1$
- consumeAssignmentOperator(LEFT_SHIFT);
- break;
-
- case 301 : if (DEBUG) { System.out.println("AssignmentOperator ::= RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$
- consumeAssignmentOperator(RIGHT_SHIFT);
- break;
-
- case 302 : if (DEBUG) { System.out.println("AssignmentOperator ::= UNSIGNED_RIGHT_SHIFT_EQUAL"); } //$NON-NLS-1$
- consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT);
- break;
-
- case 303 : if (DEBUG) { System.out.println("AssignmentOperator ::= AND_EQUAL"); } //$NON-NLS-1$
- consumeAssignmentOperator(AND);
- break;
-
- case 304 : if (DEBUG) { System.out.println("AssignmentOperator ::= XOR_EQUAL"); } //$NON-NLS-1$
- consumeAssignmentOperator(XOR);
- break;
-
- case 305 : if (DEBUG) { System.out.println("AssignmentOperator ::= OR_EQUAL"); } //$NON-NLS-1$
- consumeAssignmentOperator(OR);
- break;
-
- case 308 : if (DEBUG) { System.out.println("Expressionopt ::="); } //$NON-NLS-1$
- consumeEmptyExpression();
- break;
-
- case 314 : if (DEBUG) { System.out.println("PrimaryNoNewArrayStmt ::= SimpleName"); } //$NON-NLS-1$
- consumePrimarySimpleName();
- break;
-
- case 315 : if (DEBUG) { System.out.println("PrimaryNoNewArrayStmt ::= this"); } //$NON-NLS-1$
- consumePrimaryNoNewArrayThis();
- break;
-
- case 316 : if (DEBUG) { System.out.println("PrimaryNoNewArrayStmt ::= PushLPAREN Expression..."); } //$NON-NLS-1$
- consumePrimaryNoNewArray();
- break;
-
- case 318 : if (DEBUG) { System.out.println("MemberExpressionStmt ::= MemberExpressionStmt LBRACKET"); } //$NON-NLS-1$
- consumeMemberExpressionWithArrayReference();
- break;
-
- case 319 : if (DEBUG) { System.out.println("MemberExpressionStmt ::= MemberExpressionStmt DOT..."); } //$NON-NLS-1$
- consumeMemberExpressionWithSimpleName();
- break;
-
- case 320 : if (DEBUG) { System.out.println("MemberExpressionStmt ::= new MemberExpression Arguments"); } //$NON-NLS-1$
- consumeNewMemberExpressionWithArguments();
- break;
-
- case 322 : if (DEBUG) { System.out.println("NewExpressionStmt ::= new NewExpression"); } //$NON-NLS-1$
- consumeNewExpression();
- break;
-
- case 323 : if (DEBUG) { System.out.println("CallExpressionStmt ::= MemberExpressionStmt Arguments"); } //$NON-NLS-1$
- consumeCallExpressionWithArguments();
- break;
-
- case 324 : if (DEBUG) { System.out.println("CallExpressionStmt ::= CallExpressionStmt Arguments"); } //$NON-NLS-1$
- consumeCallExpressionWithArguments();
- break;
-
- case 325 : if (DEBUG) { System.out.println("CallExpressionStmt ::= CallExpressionStmt LBRACKET..."); } //$NON-NLS-1$
- consumeCallExpressionWithArrayReference();
- break;
-
- case 326 : if (DEBUG) { System.out.println("CallExpressionStmt ::= CallExpressionStmt DOT SimpleName"); } //$NON-NLS-1$
- consumeCallExpressionWithSimpleName();
- break;
-
- case 327 : if (DEBUG) { System.out.println("Arguments ::= LPAREN ArgumentListopt RPAREN"); } //$NON-NLS-1$
- consumeArguments();
- break;
-
- case 331 : if (DEBUG) { System.out.println("PostfixExpressionStmt ::= LeftHandSideExpressionStmt..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.PLUS, true);
- break;
-
- case 332 : if (DEBUG) { System.out.println("PostfixExpressionStmt ::= LeftHandSideExpressionStmt..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.MINUS, true);
- break;
-
- case 333 : if (DEBUG) { System.out.println("PreIncrementExpressionStmt ::= PLUS_PLUS PushPosition..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.PLUS, false);
- break;
-
- case 334 : if (DEBUG) { System.out.println("PreDecrementExpressionStmt ::= MINUS_MINUS PushPosition"); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.MINUS, false);
- break;
-
- case 337 : if (DEBUG) { System.out.println("UnaryExpressionStmt ::= PLUS PushPosition..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.PLUS);
- break;
-
- case 338 : if (DEBUG) { System.out.println("UnaryExpressionStmt ::= MINUS PushPosition..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.MINUS);
- break;
-
- case 341 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinusStmt ::= TWIDDLE PushPosition"); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.TWIDDLE);
- break;
-
- case 342 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinusStmt ::= NOT PushPosition..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.NOT);
- break;
-
- case 343 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinusStmt ::= delete PushPosition"); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.DELETE);
- break;
-
- case 344 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinusStmt ::= void PushPosition..."); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.VOID);
- break;
-
- case 345 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinusStmt ::= typeof PushPosition"); } //$NON-NLS-1$
- consumeUnaryExpression(OperatorIds.TYPEOF);
- break;
-
- case 347 : if (DEBUG) { System.out.println("MultiplicativeExpressionStmt ::=..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.MULTIPLY);
- break;
-
- case 348 : if (DEBUG) { System.out.println("MultiplicativeExpressionStmt ::=..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.DIVIDE);
- break;
-
- case 349 : if (DEBUG) { System.out.println("MultiplicativeExpressionStmt ::=..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.REMAINDER);
- break;
-
- case 351 : if (DEBUG) { System.out.println("AdditiveExpressionStmt ::= AdditiveExpressionStmt PLUS"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.PLUS);
- break;
-
- case 352 : if (DEBUG) { System.out.println("AdditiveExpressionStmt ::= AdditiveExpressionStmt MINUS"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.MINUS);
- break;
-
- case 354 : if (DEBUG) { System.out.println("ShiftExpressionStmt ::= ShiftExpressionStmt LEFT_SHIFT"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
- break;
-
- case 355 : if (DEBUG) { System.out.println("ShiftExpressionStmt ::= ShiftExpressionStmt RIGHT_SHIFT"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
- break;
-
- case 356 : if (DEBUG) { System.out.println("ShiftExpressionStmt ::= ShiftExpressionStmt..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
- break;
-
- case 358 : if (DEBUG) { System.out.println("RelationalExpressionStmt ::= RelationalExpressionStmt..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.LESS);
- break;
-
- case 359 : if (DEBUG) { System.out.println("RelationalExpressionStmt ::= RelationalExpressionStmt..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.GREATER);
- break;
-
- case 360 : if (DEBUG) { System.out.println("RelationalExpressionStmt ::= RelationalExpressionStmt..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.LESS_EQUAL);
- break;
-
- case 361 : if (DEBUG) { System.out.println("RelationalExpressionStmt ::= RelationalExpressionStmt..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
- break;
-
- case 362 : if (DEBUG) { System.out.println("RelationalExpressionStmt ::= RelationalExpressionStmt..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.INSTANCEOF);
- break;
-
- case 363 : if (DEBUG) { System.out.println("RelationalExpressionStmt ::= RelationalExpressionStmt in"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.IN);
- break;
-
- case 365 : if (DEBUG) { System.out.println("EqualityExpressionStmt ::= EqualityExpressionStmt..."); } //$NON-NLS-1$
- consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
- break;
-
- case 366 : if (DEBUG) { System.out.println("EqualityExpressionStmt ::= EqualityExpressionStmt..."); } //$NON-NLS-1$
- consumeEqualityExpression(OperatorIds.NOT_EQUAL);
- break;
-
- case 367 : if (DEBUG) { System.out.println("EqualityExpressionStmt ::= EqualityExpressionStmt..."); } //$NON-NLS-1$
- consumeEqualityExpression(OperatorIds.EQUAL_EQUAL_EQUAL);
- break;
-
- case 368 : if (DEBUG) { System.out.println("EqualityExpressionStmt ::= EqualityExpressionStmt..."); } //$NON-NLS-1$
- consumeEqualityExpression(OperatorIds.NOT_EQUAL_EQUAL);
- break;
-
- case 370 : if (DEBUG) { System.out.println("AndExpressionStmt ::= AndExpressionStmt AND..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.AND);
- break;
-
- case 372 : if (DEBUG) { System.out.println("ExclusiveOrExpressionStmt ::= ExclusiveOrExpressionStmt"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.XOR);
- break;
-
- case 374 : if (DEBUG) { System.out.println("InclusiveOrExpressionStmt ::= InclusiveOrExpressionStmt"); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.OR);
- break;
-
- case 376 : if (DEBUG) { System.out.println("ConditionalAndExpressionStmt ::=..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.AND_AND);
- break;
-
- case 378 : if (DEBUG) { System.out.println("ConditionalOrExpressionStmt ::=..."); } //$NON-NLS-1$
- consumeBinaryExpression(OperatorIds.OR_OR);
- break;
-
- case 380 : if (DEBUG) { System.out.println("ConditionalExpressionStmt ::=..."); } //$NON-NLS-1$
- consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;
- break;
-
- case 383 : if (DEBUG) { System.out.println("AssignmentStmt ::= PostfixExpressionStmt..."); } //$NON-NLS-1$
- consumeAssignment();
- break;
-
- case 384 : if (DEBUG) { System.out.println("Modifiersopt ::="); } //$NON-NLS-1$
- consumeDefaultModifiers();
- break;
-
- case 385 : if (DEBUG) { System.out.println("BlockStatementsopt ::="); } //$NON-NLS-1$
- consumeEmptyBlockStatementsopt();
- break;
-
- case 387 : if (DEBUG) { System.out.println("ArgumentListopt ::="); } //$NON-NLS-1$
- consumeEmptyArgumentListopt();
- break;
-
- case 389 : if (DEBUG) { System.out.println("FormalParameterListopt ::="); } //$NON-NLS-1$
- consumeFormalParameterListopt();
- break;
-
- case 391 : if (DEBUG) { System.out.println("ForInitopt ::="); } //$NON-NLS-1$
- consumeEmptyForInitopt();
- break;
-
- case 393 : if (DEBUG) { System.out.println("ForUpdateopt ::="); } //$NON-NLS-1$
- consumeEmptyForUpdateopt();
- break;
-
- case 395 : if (DEBUG) { System.out.println("Catchesopt ::="); } //$NON-NLS-1$
- consumeEmptyCatchesopt();
- break;
-
- case 397 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt function..."); } //$NON-NLS-1$
- consumeRecoveryMethodHeaderName();
- break;
-
- case 398 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$
- consumeMethodHeader();
- break;
-
- }
-}
-
-private void consumeElisionList() {
- int flag=this.intStack[this.intPtr];
- if ((flag&UNCONSUMED_ELISION)!=0)
- {
- pushOnExpressionStack(new EmptyExpression(this.endPosition,this.endPosition));
- }
- concatExpressionLists();
-// this.intStack[this.intPtr]&= ~(UNCONSUMED_ELISION|UNCONSUMED_LIT_ELEMENT);
-}
-private void consumeElisionOne() {
- pushOnExpressionStack(new EmptyExpression(this.endPosition,this.endPosition));
- if ( (this.intStack[this.intPtr]&UNCONSUMED_LIT_ELEMENT)!=0 || (this.intStack[this.intPtr]&WAS_ARRAY_LIT_ELEMENT)!=0)
- concatExpressionLists();
- this.intStack[this.intPtr]|=(WAS_ARRAY_LIT_ELEMENT|UNCONSUMED_ELISION) ;
-
-}
-private void consumeArrayLiteralElement() {
- this.intStack[this.intPtr]|= (WAS_ARRAY_LIT_ELEMENT|UNCONSUMED_LIT_ELEMENT);
-}
-private void consumeElisionEmpty() {
-}
-private void consumeForInInit() {
- Expression expression = this.expressionStack[this.expressionPtr--];
- this.expressionLengthPtr--;
- Statement var = expression;
- pushOnAstStack(var);
-
-}
-private void consumeStatementWith() {
- this.expressionLengthPtr--;
- Statement statement = (Statement) this.astStack[this.astPtr];
- this.astStack[this.astPtr] =
- new WithStatement(
- this.expressionStack[this.expressionPtr--],
- statement,
- this.intStack[this.intPtr--],
- this.endStatementPosition);
-}
-
-private void consumeArrayLiteral(boolean addElision) {
- int flag=this.intStack[this.intPtr--];
- if (addElision || (flag&UNCONSUMED_ELISION)!=0)
- {
- pushOnExpressionStack(new EmptyExpression(this.endPosition,this.endPosition));
- concatExpressionLists();
- }
- int length = ((flag&WAS_ARRAY_LIT_ELEMENT)>0)? this.expressionLengthStack[this.expressionLengthPtr--] : 0;
- arrayInitializer(length);
-
-}
-private void consumeObjectLiteral() {
- ObjectLiteral objectLiteral = new ObjectLiteral();
- int length;
- if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
- this.expressionPtr -= length;
- System.arraycopy(
- this.expressionStack,
- this.expressionPtr + 1,
- objectLiteral.fields = new ObjectLiteralField[length],
- 0,
- length);
- }
- objectLiteral.sourceEnd = this.endStatementPosition;
- objectLiteral.sourceStart = this.intStack[this.intPtr--];
-
- pushOnExpressionStack(objectLiteral);
-}
-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.endStatementPosition));
- if (this.pendingRecoveredType != null) {
- // Used only in statements recovery.
- // This is not a real break statement but a placeholder for an existing local type.
- // The break statement must be replace by the local type.
- if (this.pendingRecoveredType.allocation == null &&
- this.endPosition <= this.pendingRecoveredType.declarationSourceEnd) {
- this.astStack[this.astPtr] = this.pendingRecoveredType;
- this.pendingRecoveredType = null;
- return;
- }
- this.pendingRecoveredType = null;
- }
-}
-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.endStatementPosition));
- 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.endStatementPosition));
-}
-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.endStatementPosition));
- 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.endStatementPosition);
-}
-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.endStatementPosition)
- );
- } else {
- pushOnAstStack(new ReturnStatement(null, this.intStack[this.intPtr--], this.endStatementPosition));
- }
-}
-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 consumeStatementThrow() {
- // ThrowStatement ::= 'throw' Expression ';'
- this.expressionLengthPtr--;
- pushOnAstStack(new ThrowStatement(this.expressionStack[this.expressionPtr--], this.intStack[this.intPtr--], this.endStatementPosition));
-}
-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 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();
- 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 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 :
- pushOnExpressionStackLengthStack(0);
- break;
- case TokenNamevolatile :
- 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 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 :
- case TokenNameFloatingPointLiteral :
- case TokenNameDoubleLiteral :
- pushOnExpressionStack(
- new DoubleLiteral(
- this.scanner.getCurrentTokenSource(),
- this.scanner.startPosition,
- this.scanner.currentPosition - 1));
- break;
- case TokenNameCharacterLiteral :
- StringLiteral stringLiteral;
- if (this.recordStringLiterals && this.checkExternalizeStrings && !this.statementRecoveryActivated) {
- stringLiteral = this.createStringLiteral(
- this.scanner.getCurrentTokenSourceString(),
- this.scanner.startPosition,
- this.scanner.currentPosition - 1,
- Util.getLineNumber(this.scanner.startPosition, this.scanner.lineEnds, 0, this.scanner.linePtr));
- this.compilationUnit.recordStringLiteral(stringLiteral);
- } else {
- stringLiteral = this.createStringLiteral(
- this.scanner.getCurrentTokenSourceString(),
- this.scanner.startPosition,
- this.scanner.currentPosition - 1,
- 0);
- }
- pushOnExpressionStack(stringLiteral);
- break;
- case TokenNameRegExLiteral :
- pushOnExpressionStack(
- new RegExLiteral(
- this.scanner.getCurrentTokenSource(),
- this.scanner.startPosition,
- this.scanner.currentPosition - 1));
- break;
-
- case TokenNameStringLiteral :
- if (this.recordStringLiterals && this.checkExternalizeStrings && !this.statementRecoveryActivated) {
- stringLiteral = this.createStringLiteral(
- this.scanner.getCurrentTokenSourceString(),
- this.scanner.startPosition,
- this.scanner.currentPosition - 1,
- Util.getLineNumber(this.scanner.startPosition, this.scanner.lineEnds, 0, this.scanner.linePtr));
- this.compilationUnit.recordStringLiteral(stringLiteral);
- } else {
- stringLiteral = this.createStringLiteral(
- 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 TokenNameundefined :
- pushOnExpressionStack(
- new UndefinedLiteral(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 :
- case TokenNamedebugger :
- case TokenNameexport :
- case TokenNamefunction :
- case TokenNamevar :
-// case TokenNamein :
-// case TokenNameinfinity :
- case TokenNamewith :
- 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 TokenNameLBRACKET :
- this.endPosition = this.scanner.startPosition;
- break;
- case TokenNameLBRACE :
- this.endStatementPosition = this.scanner.currentPosition - 1;
- case TokenNamePLUS :
- case TokenNameMINUS :
- case TokenNameNOT :
- case TokenNameTWIDDLE :
- case TokenNamedelete :
- case TokenNamevoid :
- case TokenNametypeof :
- 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 TokenNameSEMICOLON :
- if (this.insertedSemicolonPosition>0)
- {
- if (this.insertedSemicolonPosition>=this.scanner.source.length)
- this.insertedSemicolonPosition--;
- this.endStatementPosition = this.insertedSemicolonPosition;
- this.endPosition = this.insertedSemicolonPosition;
- this.insertedSemicolonPosition=-1;
- this.problemReporter().missingSemiColon(null, this.endPosition-1,this.endPosition);
- break;
- }// else fallthru
- case TokenNameRBRACE:
- this.endStatementPosition = this.scanner.currentPosition - 1;
- this.endPosition = this.scanner.startPosition - 1;
- //the item is not part of the potential future 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 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 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 {
- 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.getOne(),
- op,
- this.endStatementPosition);
- } else {
- this.expressionStack[this.expressionPtr] =
- new PrefixExpression(
- leftHandSide,
- IntLiteral.getOne(),
- op,
- this.intStack[this.intPtr--]);
- }
- } else {
- //the ++ or the -- is NOT taken into account if code gen proceeds
- if (!post) {
- this.intPtr--;
- }
- if(!this.statementRecoveryActivated) problemReporter().invalidUnaryExpression(leftHandSide);
- }
-}
-protected void consumeVariableDeclarators() {
- // VariableDeclarators ::= VariableDeclarators ',' VariableDeclarator
- optimizedConcatNodeLists();
-}
-protected void consumeVariableInitializers() {
- // VariableInitializers ::= VariableInitializers ',' VariableInitializer
- concatExpressionLists();
-}
-/**
- * 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.sourceStart = c.sourceStart;
- m.sourceEnd = c.sourceEnd;
- m.bodyStart = c.bodyStart;
- m.bodyEnd = c.bodyEnd;
- m.declarationSourceEnd = c.declarationSourceEnd;
- m.declarationSourceStart = c.declarationSourceStart;
- m.setSelector(c.getName());
- m.statements = c.statements;
- m.modifiers = c.modifiers;
- m.arguments = c.arguments;
- 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 JavadocParser createJavadocParser() {
- return new JavadocParser(this);
-}
-protected LocalDeclaration createLocalDeclaration(char[] localDeclarationName, int sourceStart, int sourceEnd) {
- return new LocalDeclaration(localDeclarationName, sourceStart, sourceEnd);
-}
-protected StringLiteral createStringLiteral(char[] token, int start, int end, int lineNumber) {
- return new StringLiteral(token, start, end, lineNumber);
-}
-
- 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 = DO_DIET_PARSE;
- 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.statementRecoveryActivated ) {
- RecoveredElement recoveredElement = this.buildInitialRecoveryState();
- recoveredElement.topElement().updateParseTree();
- if(this.hasError) this.resetStacks();
- } else if (this.currentElement != null){
- 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$
- }
- recoverAST(this.currentElement);
- this.currentElement.topElement().updateParseTree();
- } 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++){
- if(!this.statementRecoveryActivated) 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]);
- }
- if (this.compilationUnit.statements==null)
- this.compilationUnit.statements=new ProgramElement[0];
- 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 (Util.getLineNumber(position, this.scanner.lineEnds, 0, this.scanner.linePtr)
- == Util.getLineNumber(immediateCommentEnd, this.scanner.lineEnds, 0, this.scanner.linePtr)){
- 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;
-}
-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 ::= '++' JavaScriptUnit
- // 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;
- char[] contents = compilationResult.compilationUnit.getContents();
- this.scanner.setSource(contents, compilationResult);
-
- if (this.javadocParser != null && this.javadocParser.checkDocComment) {
- 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 = ScannerHelper.getNumericValue(comment[index[0]++])) > 15
- || c1 < 0)
- || ((c2 = ScannerHelper.getNumericValue(comment[index[0]++])) > 15 || c2 < 0)
- || ((c3 = ScannerHelper.getNumericValue(comment[index[0]++])) > 15 || c3 < 0)
- || ((c4 = ScannerHelper.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) {
- ref = null;
- } 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 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 goForProgramElements() {
- //tells the scanner to go for block statements opt parsing
-
- this.firstToken = TokenNamePLUS;
- this.scanner.recordLineSeparator = true;
-}
-
-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.firstToken = TokenNamePLUS;
- 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 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 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 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 -- ;
-}
-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 = 0;
- 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;
-
- this.errorAction= new HashSet();
-
-}
-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;
-}
-private void jumpOverType(){
- if (this.recoveredTypes != null && this.nextTypeStart > -1 && this.nextTypeStart < this.scanner.currentPosition) {
-
- if (DEBUG_AUTOMATON) {
- System.out.println("Jump -"); //$NON-NLS-1$
- }
-
- TypeDeclaration typeDeclaration = this.recoveredTypes[this.recoveredTypePtr];
- boolean isAnonymous = typeDeclaration.allocation != null;
-
- int end = this.scanner.eofPosition;
- this.scanner.resetTo(typeDeclaration.declarationSourceEnd + 1, end - 1);
- if(!isAnonymous) {
- ((RecoveryScanner)this.scanner).setPendingTokens(new int[]{TokenNameSEMICOLON, TokenNamebreak});
- } else {
- ((RecoveryScanner)this.scanner).setPendingTokens(new int[]{TokenNameIdentifier, TokenNameEQUAL, TokenNameIdentifier});
- }
-
- this.pendingRecoveredType = typeDeclaration;
-
- try {
- this.currentToken = this.scanner.getNextToken();
- } catch(InvalidInputException e){
- // it's impossible because we added pending tokens before
- }
-
- if(++this.recoveredTypePtr < this.recoveredTypes.length) {
- TypeDeclaration nextTypeDeclaration = this.recoveredTypes[this.recoveredTypePtr];
- this.nextTypeStart =
- nextTypeDeclaration.allocation == null
- ? nextTypeDeclaration.declarationSourceStart
- : nextTypeDeclaration.allocation.sourceStart;
- } else {
- this.nextTypeStart = Integer.MAX_VALUE;
- }
- }
-}
-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
- // and enclosing type must not be closed (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=147485)
- && ((TypeDeclaration) node).declarationSourceEnd == 0)) {
- 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.currentToken=this.scanner.currentNonWhitespaceToken=TokenNameUNKNOWN;
- 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.currentToken=TokenNameUNKNOWN;
- 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 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]++;
-}
-
-protected boolean isErrorState(int act) {
- int stackTop=this.stateStackTop;
- int [] tempStack=new int[this.stack.length+2];
- System.arraycopy(this.stack, 0, tempStack, 0, this.stack.length);
- boolean first=true;
- int currentAction = act;
- ProcessTerminals : for (;;) {
- int stackLength = tempStack.length;
- if (!first)
- {
- if (++stackTop >= stackLength) {
- System.arraycopy(
- tempStack, 0,
- tempStack = new int[stackLength + StackIncrement], 0,
- stackLength);
- }
- tempStack[stackTop] = currentAction;
- }
- first=false;
- currentAction = tAction(currentAction, this.currentToken);
- if (currentAction == ERROR_ACTION) {
- return true;
- }
- if (currentAction <= NUM_RULES) {
- stackTop--;
-
- } else if (currentAction > ERROR_ACTION) { /* shift-reduce */
- if (DEBUG) System.out.println("<<shift-reduce consume Token: "+scanner.toStringAction(this.currentToken)); //$NON-NLS-1$
- return false;
-// consumeToken(this.currentToken);
-// if (this.currentElement != null) this.recoveryTokenCheck();
-// try {
-// prevPos = scanner.currentPosition;
-// prevToken = currentToken;
-// insertedSemicolon = false;
-// this.currentToken = this.scanner.getNextToken();
-// if (DEBUG) System.out.println(">>shift-reduce Next Token: "+scanner.dumpCurrent());
-// } catch(InvalidInputException e){
-// if (!this.hasReportedError){
-// this.problemReporter().scannerError(this, e.getMessage());
-// this.hasReportedError = true;
-// }
-// this.lastCheckPoint = this.scanner.currentPosition;
-// this.restartRecovery = true;
-// }
-// if(this.statementRecoveryActivated) {
-// jumpOverTypeAfterReduce = true;
-// }
-// act -= ERROR_ACTION;
-
- } else {
- if (currentAction < ACCEPT_ACTION) { /* shift */
- if (DEBUG) System.out.println("<<shift consume Token: "+scanner.toStringAction(this.currentToken)); //$NON-NLS-1$
- return false;
-// consumeToken(this.currentToken);
-// if (this.currentElement != null) this.recoveryTokenCheck();
-// try{
-// prevPos = scanner.currentPosition;
-// prevToken = currentToken;
-// insertedSemicolon = false;
-// this.currentToken = this.scanner.getNextToken();
-// if (DEBUG) System.out.println(">>shift next Token: "+scanner.dumpCurrent());
-// } catch(InvalidInputException e){
-// if (!this.hasReportedError){
-// this.problemReporter().scannerError(this, e.getMessage());
-// this.hasReportedError = true;
-// }
-// this.lastCheckPoint = this.scanner.currentPosition;
-// this.restartRecovery = true;
-// }
-// if(this.statementRecoveryActivated) {
-// this.jumpOverType();
-// }
-// continue ProcessTerminals;
- }
- break ProcessTerminals;
- }
-
- // ProcessNonTerminals :
- do { /* reduce */
- stackTop -= (rhs[currentAction] - 1);
- currentAction = ntAction(tempStack[stackTop], lhs[currentAction]);
- } while (currentAction <= NUM_RULES);
- }
-return false;
-}
-
-
-/*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$
-
- if (DEBUG_AUTOMATON) {
- System.out.println("- Start --------------------------------"); //$NON-NLS-1$
- }
-
- boolean isDietParse = this.diet;
- int oldFirstToken = getFirstToken();
- this.hasError = false;
-
- this.hasReportedError = false;
- boolean insertedSemicolon = false;
- int prevAct = START_STATE,
- prevToken = getFirstToken(),
- prevPos = scanner.startPosition;
-
- 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;
-
- if (DEBUG)
- System.out.println("action="+act+ ((term_check[base_action[act]+this.currentToken] == this.currentToken)?"":" - take default") ); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
- prevAct=act;
-
- if (optionalSemicolonState[act])
- {
- if (term_check[base_action[act]+this.currentToken] != this.currentToken)
- {
- if (isErrorState(act))
- {
- if (!insertedSemicolon && shouldInsertSemicolon(prevPos, prevToken) )
- {
- currentToken = TokenNameSEMICOLON;
- this.insertedSemicolonPosition=prevPos;
- scanner.pushBack();
- insertedSemicolon = true;
-
- }
- }
- }
- }
-
- act = tAction(act, this.currentToken);
- if (act == ERROR_ACTION || this.restartRecovery) {
-// if ( act == ERROR_ACTION &&
-// !insertedSemicolon &&
-// shouldInsertSemicolon(prevPos, prevToken)
-// ) {
-// act = prevAct;
-// --stateStackTop;
-// currentToken = TokenNameSEMICOLON;
-// scanner.pushBack();
-// insertedSemicolon = true;
-// continue ProcessTerminals;
-// }
-
- if (DEBUG_AUTOMATON) {
- if (this.restartRecovery) {
- System.out.println("Restart - "); //$NON-NLS-1$
- } else {
- System.out.println("Error - "); //$NON-NLS-1$
- }
- }
-
- 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();
- if (DEBUG) System.out.println("!! Resume on syntax error"); //$NON-NLS-1$
- continue ProcessTerminals;
- }
- act = ERROR_ACTION;
- break ProcessTerminals;
- }
- if (act <= NUM_RULES) {
- insertedSemicolon = false;
- this.stateStackTop--;
-
- if (DEBUG_AUTOMATON) {
- System.out.print("Reduce - "); //$NON-NLS-1$
- }
-
- } else if (act > ERROR_ACTION) { /* shift-reduce */
- if (DEBUG) System.out.println("<<shift-reduce consume Token: "+scanner.toStringAction(this.currentToken)); //$NON-NLS-1$
- consumeToken(this.currentToken);
- if (this.currentElement != null) this.recoveryTokenCheck();
- try {
- prevPos = scanner.currentPosition;
- prevToken = currentToken;
- insertedSemicolon = false;
- this.currentToken = this.scanner.getNextToken();
- if (DEBUG) System.out.println(">>shift-reduce Next Token: "+scanner.dumpCurrent()); //$NON-NLS-1$
- } catch(InvalidInputException e){
- if (!this.hasReportedError){
- this.problemReporter().scannerError(this, e.getMessage());
- this.hasReportedError = true;
- }
- this.lastCheckPoint = this.scanner.currentPosition;
- this.restartRecovery = true;
- }
- if(this.statementRecoveryActivated) {
- this.jumpOverType();
- }
- act -= ERROR_ACTION;
-
- if (DEBUG_AUTOMATON) {
- System.out.print("Shift/Reduce - (" + name[terminal_index[this.currentToken]]+") "); //$NON-NLS-1$ //$NON-NLS-2$
- }
-
- } else {
- if (act < ACCEPT_ACTION) { /* shift */
- if (DEBUG) System.out.println("<<shift consume Token: "+scanner.toStringAction(this.currentToken)); //$NON-NLS-1$
- consumeToken(this.currentToken);
- if (this.currentElement != null) this.recoveryTokenCheck();
- try{
- prevPos = scanner.currentPosition;
- prevToken = currentToken;
- insertedSemicolon = false;
- this.currentToken = this.scanner.getNextToken();
- if (DEBUG) System.out.println(">>shift next Token: "+scanner.dumpCurrent()); //$NON-NLS-1$
- } catch(InvalidInputException e){
- if (!this.hasReportedError){
- this.problemReporter().scannerError(this, e.getMessage());
- this.hasReportedError = true;
- }
- this.lastCheckPoint = this.scanner.currentPosition;
- this.restartRecovery = true;
- }
- if(this.statementRecoveryActivated) {
- this.jumpOverType();
- }
- if (DEBUG_AUTOMATON) {
- System.out.println("Shift - (" + name[terminal_index[this.currentToken]]+")"); //$NON-NLS-1$ //$NON-NLS-2$
- }
- continue ProcessTerminals;
- }
- break ProcessTerminals;
- }
-
- // ProcessNonTerminals :
- do { /* reduce */
-
- if (DEBUG_AUTOMATON) {
- System.out.println(name[non_terminal_index[lhs[act]]]);
- }
-
- consumeRule(act);
- this.stateStackTop -= (rhs[act] - 1);
- act = ntAction(this.stack[this.stateStackTop], lhs[act]);
- if (DEBUG_AUTOMATON && act <= NUM_RULES) {
- System.out.print(" - "); //$NON-NLS-1$
- }
-
- } while (act <= NUM_RULES);
- if (DEBUG_AUTOMATON) {
- System.out.println("----------------------------------------"); //$NON-NLS-1$
- }
- }
- if (DEBUG_AUTOMATON) {
- System.out.println("- End ----------------------------------"); //$NON-NLS-1$
- }
-
- 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 && !(this.statementRecoveryActivated && DO_DIET_PARSE)) {
- if(!this.options.performStatementsRecovery) {
- reportSyntaxErrors(isDietParse, oldFirstToken);
- } else {
- RecoveryScannerData data = this.referenceContext.compilationResult().recoveryScannerData;
-
- if(this.recoveryScanner == null) {
- this.recoveryScanner = new RecoveryScanner(this.scanner, data);
- } else {
- this.recoveryScanner.setData(data);
- }
-
- this.recoveryScanner.setSource(scanner.source);
- this.recoveryScanner.lineEnds = this.scanner.lineEnds;
- this.recoveryScanner.linePtr = this.scanner.linePtr;
-
- reportSyntaxErrors(isDietParse, oldFirstToken);
-
- if(data == null) {
- this.referenceContext.compilationResult().recoveryScannerData =
- this.recoveryScanner.getData();
- }
-
- if (this.methodRecoveryActivated && this.options.performStatementsRecovery && !this.enteredRecoverStatements) {
- this.methodRecoveryActivated = false;
- this.enteredRecoverStatements=true;
- this.recoverStatements();
- this.methodRecoveryActivated = true;
-
- this.lastAct = ERROR_ACTION;
- }
- }
- }
-
- 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
-
- boolean oldMethodRecoveryActivated = this.methodRecoveryActivated;
- if(this.options.performMethodsFullRecovery) {
- this.methodRecoveryActivated = true;
- }
-
- 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]--;
- if(this.options.performStatementsRecovery) {
- this.methodRecoveryActivated = oldMethodRecoveryActivated;
- }
- }
-
- checkNonNLSAfterBodyEnd(cd.declarationSourceEnd);
-
- if (this.lastAct == ERROR_ACTION) {
- initialize();
- return;
- }
-
- //statements
- cd.explicitDeclarations = this.realBlockStack[this.realBlockPtr--];
- int length;
- if (astLengthPtr > -1 && (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();
-
- /* unit creation */
- this.referenceContext =
- this.compilationUnit =
- new CompilationUnitDeclaration(
- this.problemReporter,
- compilationResult,
- 0);
-
-
- initializeInferenceEngine(this.compilationUnit);
-
- /* scanners initialization */
- char[] contents;
- try {
- contents = sourceUnit.getContents();
- } catch(AbortCompilationUnit abortException) {
- this.problemReporter().cannotReadSource(this.compilationUnit, abortException, this.options.verbose);
- contents = CharOperation.NO_CHAR; // pretend empty from thereon
- }
- this.scanner.setSource(contents);
- this.compilationUnit.sourceEnd = this.scanner.source.length - 1;
- 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);
- }
- }
- /* run automaton */
-if (false)
- System.out.println("parsing "+new String(sourceUnit.getFileName())); //$NON-NLS-1$
- 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;
-}
-
-public void initializeInferenceEngine(CompilationUnitDeclaration compilationUnitDeclaration) {
- if (this.inferenceEngines==null)
- this.inferenceEngines = InferrenceManager.getInstance().getInferenceEngines(compilationUnitDeclaration);
- for (int i = 0; i < this.inferenceEngines.length; i++) {
- this.inferenceEngines[i].initializeOptions(this.options.inferOptions);
- }
-}
-
-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
-
- boolean oldMethodRecoveryActivated = this.methodRecoveryActivated;
- if(this.options.performMethodsFullRecovery) {
- this.methodRecoveryActivated = true;
- }
-
- 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]--;
- if(this.options.performStatementsRecovery) {
- this.methodRecoveryActivated = oldMethodRecoveryActivated;
- }
- }
-
- checkNonNLSAfterBodyEnd(initializer.declarationSourceEnd);
-
- if (this.lastAct == ERROR_ACTION) {
- return;
- }
-
- //refill statements
- initializer.block.explicitDeclarations = this.realBlockStack[this.realBlockPtr--];
- int length;
- if (astLengthPtr > -1 && (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.modifiers & ExtraCompilerModifiers.AccSemicolonBody) != 0)
- return;
-
- boolean oldMethodRecoveryActivated = this.methodRecoveryActivated;
- if(this.options.performMethodsFullRecovery) {
- this.methodRecoveryActivated = true;
- this.rParenPos = md.sourceEnd;
- }
- 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]--;
- if(this.options.performStatementsRecovery) {
- this.methodRecoveryActivated = oldMethodRecoveryActivated;
- }
- }
-
- checkNonNLSAfterBodyEnd(md.declarationSourceEnd);
-
- if (this.lastAct == ERROR_ACTION) {
- return;
- }
-
- //refill statements
- md.explicitDeclarations = this.realBlockStack[this.realBlockPtr--];
- int length;
- if (astLengthPtr > -1 && (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 || this.hasError) {
- return null;
- }
- int astLength;
- if (astLengthPtr > -1 && (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 parseStatements(ReferenceContext rc, int start, int end, TypeDeclaration[] types, CompilationUnitDeclaration unit) {
- boolean oldStatementRecoveryEnabled = this.statementRecoveryActivated;
- this.statementRecoveryActivated = true;
-
- initialize();
-
- if (rc instanceof CompilationUnitDeclaration)
- goForCompilationUnit();
- else
- goForBlockStatementsopt();
- this.nestedMethod[this.nestedType]++;
- pushOnRealBlockStack(0);
-
- //pushOnAstLengthStack(0);
-
- this.referenceContext = rc;
- this.compilationUnit = unit;
-
- this.pendingRecoveredType = null;
-
- if(types != null && types.length > 0) {
- this.recoveredTypes = types;
- this.recoveredTypePtr = 0;
- this.nextTypeStart =
- this.recoveredTypes[0].allocation == null
- ? this.recoveredTypes[0].declarationSourceStart
- : this.recoveredTypes[0].allocation.sourceStart;
- } else {
- this.recoveredTypes = null;
- this.recoveredTypePtr = -1;
- this.nextTypeStart = -1;
- }
-
- this.scanner.resetTo(start, end);
- // reset the scanner to parser from { down to }
-
- this.lastCheckPoint = this.scanner.initialPosition;
-
-
- this.stateStackTop = -1;
-
- try {
- parse();
- } catch (AbortCompilation ex) {
- this.lastAct = ERROR_ACTION;
- } finally {
- this.nestedMethod[this.nestedType]--;
- this.recoveredTypes = null;
- this.statementRecoveryActivated = oldStatementRecoveryEnabled;
- }
-
- checkNonNLSAfterBodyEnd(end);
-}
-public void persistLineSeparatorPositions() {
- if (this.scanner.recordLineSeparator) {
- this.compilationUnit.compilationResult.lineSeparatorPositions = this.scanner.getLineEnds();
- }
-}
-/*
- * Prepares the state of the parser to go for BlockStatements.
- */
-protected void prepareForBlockStatements() {
- this.nestedMethod[this.nestedType = 0] = 1;
- this.variablesCounter[this.nestedType] = 0;
- this.realBlockStack[this.realBlockPtr = 1] = 0;
-}
-/**
- * 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) {
- if (this.compilationUnit!=null)
- 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;
-}
-protected void recoverStatements() {
- class MethodVisitor extends ASTVisitor {
- public ASTVisitor typeVisitor;
-
- TypeDeclaration enclosingType; // used only for initializer
-
- TypeDeclaration[] types = new TypeDeclaration[0];
- int typePtr = -1;
- public boolean visit(ConstructorDeclaration constructorDeclaration, ClassScope scope) {
- typePtr = -1;
- return true;
- }
- public boolean visit(Initializer initializer, MethodScope scope) {
- typePtr = -1;
- return true;
- }
- public boolean visit(MethodDeclaration methodDeclaration,Scope scope) {
- typePtr = -1;
- return true;
- }
- public boolean visit(TypeDeclaration typeDeclaration, BlockScope scope) {
- return this.visit(typeDeclaration);
- }
- public boolean visit(TypeDeclaration typeDeclaration, Scope scope) {
- return this.visit(typeDeclaration);
- }
- private boolean visit(TypeDeclaration typeDeclaration) {
- if(this.types.length <= ++this.typePtr) {
- int length = this.typePtr;
- System.arraycopy(this.types, 0, this.types = new TypeDeclaration[length * 2 + 1], 0, length);
- }
- this.types[this.typePtr] = typeDeclaration;
- return false;
- }
- public void endVisit(ConstructorDeclaration constructorDeclaration, ClassScope scope) {
- this.endVisitMethod(constructorDeclaration, scope);
- }
- public void endVisit(MethodDeclaration methodDeclaration, Scope scope) {
- this.endVisitMethod(methodDeclaration, scope);
- }
- private void endVisitMethod(AbstractMethodDeclaration methodDeclaration, Scope scope) {
- TypeDeclaration[] foundTypes = null;
-// int length = 0;
-// if(this.typePtr > -1) {
-// length = this.typePtr + 1;
-// foundTypes = new TypeDeclaration[length];
-// System.arraycopy(this.types, 0, foundTypes, 0, length);
-// }
- ReferenceContext oldContext = Parser.this.referenceContext;
- Parser.this.recoveryScanner.resetTo(methodDeclaration.bodyStart, methodDeclaration.bodyEnd);
- Scanner oldScanner = Parser.this.scanner;
- Parser.this.scanner = Parser.this.recoveryScanner;
- Parser.this.parseStatements(
- methodDeclaration,
- methodDeclaration.bodyStart,
- methodDeclaration.bodyEnd,
- foundTypes,
- compilationUnit);
- Parser.this.scanner = oldScanner;
- Parser.this.referenceContext = oldContext;
-
-// for (int i = 0; i < length; i++) {
-// foundTypes[i].traverse(typeVisitor, scope);
-// }
- }
- public void endVisit(Initializer initializer, MethodScope scope) {
- TypeDeclaration[] foundTypes = null;
- int length = 0;
- if(this.typePtr > -1) {
- length = this.typePtr + 1;
- foundTypes = new TypeDeclaration[length];
- System.arraycopy(this.types, 0, foundTypes, 0, length);
- }
- ReferenceContext oldContext = Parser.this.referenceContext;
- Parser.this.recoveryScanner.resetTo(initializer.bodyStart, initializer.bodyEnd);
- Scanner oldScanner = Parser.this.scanner;
- Parser.this.scanner = Parser.this.recoveryScanner;
- Parser.this.parseStatements(
- this.enclosingType,
- initializer.bodyStart,
- initializer.bodyEnd,
- foundTypes,
- compilationUnit);
- Parser.this.scanner = oldScanner;
- Parser.this.referenceContext = oldContext;
-
- for (int i = 0; i < length; i++) {
- foundTypes[i].traverse(typeVisitor, scope);
- }
- }
- }
- class TypeVisitor extends ASTVisitor {
- public MethodVisitor methodVisitor;
-
- TypeDeclaration[] types = new TypeDeclaration[0];
- int typePtr = -1;
-
- public void endVisit(TypeDeclaration typeDeclaration, BlockScope scope) {
- endVisitType();
- }
- public void endVisit(TypeDeclaration typeDeclaration, ClassScope scope) {
- endVisitType();
- }
- private void endVisitType() {
- this.typePtr--;
- }
- public boolean visit(TypeDeclaration typeDeclaration, BlockScope scope) {
- return this.visit(typeDeclaration);
- }
- public boolean visit(TypeDeclaration typeDeclaration, ClassScope scope) {
- return this.visit(typeDeclaration);
- }
- private boolean visit(TypeDeclaration typeDeclaration) {
- if(this.types.length <= ++this.typePtr) {
- int length = this.typePtr;
- System.arraycopy(this.types, 0, this.types = new TypeDeclaration[length * 2 + 1], 0, length);
- }
- this.types[this.typePtr] = typeDeclaration;
- return true;
- }
- public boolean visit(ConstructorDeclaration constructorDeclaration, ClassScope scope) {
- if(constructorDeclaration.isDefaultConstructor()) return false;
-
- constructorDeclaration.traverse(methodVisitor, scope);
- return false;
- }
- public boolean visit(Initializer initializer, MethodScope scope) {
- methodVisitor.enclosingType = this.types[typePtr];
- initializer.traverse(methodVisitor, scope);
- return false;
- }
- public boolean visit(MethodDeclaration methodDeclaration, Scope scope) {
- methodDeclaration.traverse(methodVisitor, scope);
- return false;
- }
- }
-
- if (false)
- {
- MethodVisitor methodVisitor = new MethodVisitor();
- TypeVisitor typeVisitor = new TypeVisitor();
- methodVisitor.typeVisitor = typeVisitor;
- typeVisitor.methodVisitor = methodVisitor;
-
- if(this.referenceContext instanceof AbstractMethodDeclaration) {
- ((AbstractMethodDeclaration)this.referenceContext).traverse(methodVisitor, (Scope)null);
- }else if(this.referenceContext instanceof CompilationUnitDeclaration) {
- CompilationUnitDeclaration compilationUnitDeclaration=(CompilationUnitDeclaration)this.referenceContext;
- if (compilationUnitDeclaration.statements!=null)
- for (int i = 0; i < compilationUnitDeclaration.statements.length; i++) {
- if( compilationUnitDeclaration.statements[i] instanceof AbstractMethodDeclaration)
- ((AbstractMethodDeclaration)compilationUnitDeclaration.statements[i] ).traverse(methodVisitor, (Scope)null);
- }
- } else if(this.referenceContext instanceof TypeDeclaration) {
- TypeDeclaration typeContext = (TypeDeclaration)this.referenceContext;
-
- int length = typeContext.fields.length;
- for (int i = 0; i < length; i++) {
- final FieldDeclaration fieldDeclaration = typeContext.fields[i];
- switch(fieldDeclaration.getKind()) {
- case AbstractVariableDeclaration.INITIALIZER:
- methodVisitor.enclosingType = typeContext;
- ((Initializer) fieldDeclaration).traverse(methodVisitor, (MethodScope)null);
- break;
- }
- }
- }
- }
- else
- {
- CompilationUnitDeclaration compilationUnitDeclaration=(CompilationUnitDeclaration)this.referenceContext;
-
- ReferenceContext oldContext = Parser.this.referenceContext;
- int start = compilationUnitDeclaration.sourceStart;
- int end = compilationUnitDeclaration.sourceEnd;
- Parser.this.recoveryScanner.resetTo(start, end);
- Scanner oldScanner = Parser.this.scanner;
- Parser.this.scanner = Parser.this.recoveryScanner;
- /* unit creation */
- this.referenceContext =
- this.compilationUnit = compilationUnitDeclaration=
- new CompilationUnitDeclaration(
- this.problemReporter,
- compilationUnitDeclaration.compilationResult,
- end);
-
- Parser.this.parseStatements(
- compilationUnitDeclaration,
- start,
- end,
- null,
- compilationUnit);
- Parser.this.scanner = oldScanner;
- Parser.this.referenceContext = oldContext;
- }
-
-
-}
-
-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;
- this.lastCheckPoint=this.scanner.currentPosition;
-// 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;
-}
-
-protected boolean shouldInsertSemicolon(int prevpos, int prevtoken) {
- Integer position = new Integer(prevpos);
- if (this.errorAction.contains(position)) {
- // should not insert a semi-colon at a location that has already be tried
- return false;
- }
- this.errorAction.add(position);
- return this.currentToken == TokenNameRBRACE
- || scanner.getLineNumber(scanner.currentPosition) > scanner.getLineNumber(prevpos)
- || this.currentToken==TokenNameEOF;
-}
-
-// 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 : this.scanner.eofPosition - 1;
- if(isDietParse) {
- ProgramElement[] statements = this.compilationUnit.statements;
-// TypeDeclaration[] types = this.compilationUnit.types;
- int[][] intervalToSkip = org.eclipse.wst.jsdt.internal.compiler.parser.diagnose.RangeUtil.computeDietRange(statements);
-// int[][] intervalToSkip = org.eclipse.wst.jsdt.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(false);
-
- reportSyntaxErrorsForSkippedMethod(statements);
-// reportSyntaxErrorsForSkippedMethod(types);
- this.scanner.resetTo(start, end);
- } else {
- DiagnoseParser diagnoseParser = new DiagnoseParser(this, oldFirstToken, start, end, this.options);
- diagnoseParser.diagnoseParse(this.options.performStatementsRecovery);
- }
-}
-private void reportSyntaxErrorsForSkippedMethod(ProgramElement[] statements){
- if(statements != null) {
- for (int i = 0; i < statements.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++) {
- if (statements[i] instanceof AbstractMethodDeclaration )
- {
- AbstractMethodDeclaration method = (AbstractMethodDeclaration)statements[i] ;
- if(method.errorInSignature) {
- DiagnoseParser diagnoseParser = new DiagnoseParser(this, TokenNameDIVIDE, method.declarationSourceStart, method.declarationSourceEnd, this.options);
- diagnoseParser.diagnoseParse(this.options.performStatementsRecovery);
- }
-// }
- }
- else if (statements[i] instanceof FieldDeclaration )
- {
-// FieldDeclaration field =(FieldDeclaration) statements[i] ;
-// 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(this.options.performStatementsRecovery);
-// }
-// }
-// }
- }
- }
- }
-}
-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;
- this.errorAction = new HashSet();
-}
-/*
- * 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() {
- if(!this.methodRecoveryActivated && !this.statementRecoveryActivated) {
-
- // 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){
- if (DO_DIET_PARSE)
- {
- goForHeaders();
- this.diet = true; // passed this point, will not consider method bodies
- }
- else
- goForProgramElements();
- return true;
- }
-
- // does not know how to restart
- return false;
- } else if(!this.statementRecoveryActivated || !DO_DIET_PARSE) {
-
- // reset internal stacks
- this.resetStacks();
- this.resetModifiers();
-
- /* attempt to move checkpoint location */
- if (!this.moveRecoveryCheckpoint()) {
- return false;
- }
-
- // only look for headers
- if (DO_DIET_PARSE)
- goForHeaders();
- else
- goForProgramElements();
- return true;
- } else {
- 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;
-
- // do not investigate deeper in statement recovery
- if (this.statementRecoveryActivated) return false;
-
- // 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 void setMethodsFullRecovery(boolean enabled) {
- this.options.performMethodsFullRecovery = enabled;
-}
-public void setStatementsRecovery(boolean enabled) {
- if(enabled) this.options.performMethodsFullRecovery = true;
- this.options.performStatementsRecovery = enabled;
-}
-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 + "intPtr : int = " + String.valueOf(this.intPtr) + "\n"; //$NON-NLS-1$ //$NON-NLS-2$
-
- 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--];
-}
-
-public void inferTypes(CompilationUnitDeclaration parsedUnit, CompilerOptions compileOptions) {
- if (parsedUnit.typesHaveBeenInferred)
- return;
- if (compileOptions==null)
- compileOptions=this.options;
-
- if (this.inferenceEngines==null)
- initializeInferenceEngine(parsedUnit);
-// InferEngine inferEngine=compileOptions.inferOptions.createEngine();
- for (int i=0;i<this.inferenceEngines.length;i++)
- {
- IInferEngine engine=this.inferenceEngines[i];
- PerformanceStats stats= PerformanceStats.getStats(PERFORMANCE__INFER_TYPES, engine);
- try {
- stats.startRun(new String(parsedUnit.getFileName()));
+ case 393 : if (DEBUG) { System.out.println("ForUpdateopt ::="); } //$NON-NLS-1$
+ consumeEmptyForUpdateopt();
+ break;
- engine.initialize();
- if (engine instanceof IInferEngineExtension)
- ((IInferEngineExtension) engine).setCompilationUnit(parsedUnit, this.scanner.getSource());
- else
- engine.setCompilationUnit(parsedUnit);
+ case 395 : if (DEBUG) { System.out.println("Catchesopt ::="); } //$NON-NLS-1$
+ consumeEmptyCatchesopt();
+ break;
- engine.doInfer();
- } catch (RuntimeException e) {
- org.eclipse.wst.jsdt.internal.core.util.Util.log(e, "error during type inferencing"); //$NON-NLS-1$
- }
- finally {
- stats.endRun();
- if (REPORT_PERFORMANCE__INFER_TYPES && stats.isFailure()) {
- IStatus status = new Status(IStatus.WARNING, JavaScriptCore.PLUGIN_ID, IStatus.OK, "Inference Engine took too long: " + engine, null); //$NON-NLS-1$
- Platform.getLog(Platform.getBundle(JavaScriptCore.PLUGIN_ID)).log(status);
- }
- }
- }
- parsedUnit.typesHaveBeenInferred=true;
-}
+ case 397 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt function..."); } //$NON-NLS-1$
+ consumeRecoveryMethodHeaderName();
+ break;
+ case 398 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } //$NON-NLS-1$
+ consumeMethodHeader();
+ break;
-}
+ }
+}
+
+private void consumeElisionList() {
+ int flag=this.intStack[this.intPtr];
+ if ((flag&UNCONSUMED_ELISION)!=0)
+ {
+ pushOnExpressionStack(new EmptyExpression(this.endPosition,this.endPosition));
+ }
+ concatExpressionLists();
+// this.intStack[this.intPtr]&= ~(UNCONSUMED_ELISION|UNCONSUMED_LIT_ELEMENT);
+}
+private void consumeElisionOne() {
+ pushOnExpressionStack(new EmptyExpression(this.endPosition,this.endPosition));
+ if ( (this.intStack[this.intPtr]&UNCONSUMED_LIT_ELEMENT)!=0 || (this.intStack[this.intPtr]&WAS_ARRAY_LIT_ELEMENT)!=0)
+ concatExpressionLists();
+ this.intStack[this.intPtr]|=(WAS_ARRAY_LIT_ELEMENT|UNCONSUMED_ELISION) ;
+
+}
+private void consumeArrayLiteralElement() {
+ this.intStack[this.intPtr]|= (WAS_ARRAY_LIT_ELEMENT|UNCONSUMED_LIT_ELEMENT);
+}
+private void consumeElisionEmpty() {
+}
+private void consumeForInInit() {
+ Expression expression = this.expressionStack[this.expressionPtr--];
+ this.expressionLengthPtr--;
+ Statement var = expression;
+ pushOnAstStack(var);
+
+}
+private void consumeStatementWith() {
+ this.expressionLengthPtr--;
+ Statement statement = (Statement) this.astStack[this.astPtr];
+ this.astStack[this.astPtr] =
+ new WithStatement(
+ this.expressionStack[this.expressionPtr--],
+ statement,
+ this.intStack[this.intPtr--],
+ this.endStatementPosition);
+}
+
+private void consumeArrayLiteral(boolean addElision) {
+ int flag=this.intStack[this.intPtr--];
+ if (addElision || (flag&UNCONSUMED_ELISION)!=0)
+ {
+ pushOnExpressionStack(new EmptyExpression(this.endPosition,this.endPosition));
+ concatExpressionLists();
+ }
+ int length = ((flag&WAS_ARRAY_LIT_ELEMENT)>0)? this.expressionLengthStack[this.expressionLengthPtr--] : 0;
+ arrayInitializer(length);
+
+}
+private void consumeObjectLiteral() {
+ ObjectLiteral objectLiteral = new ObjectLiteral();
+ int length;
+ if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
+ this.expressionPtr -= length;
+ System.arraycopy(
+ this.expressionStack,
+ this.expressionPtr + 1,
+ objectLiteral.fields = new ObjectLiteralField[length],
+ 0,
+ length);
+ }
+ objectLiteral.sourceEnd = this.endStatementPosition;
+ objectLiteral.sourceStart = this.intStack[this.intPtr--];
+
+ pushOnExpressionStack(objectLiteral);
+}
+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.endStatementPosition));
+ if (this.pendingRecoveredType != null) {
+ // Used only in statements recovery.
+ // This is not a real break statement but a placeholder for an existing local type.
+ // The break statement must be replace by the local type.
+ if (this.pendingRecoveredType.allocation == null &&
+ this.endPosition <= this.pendingRecoveredType.declarationSourceEnd) {
+ this.astStack[this.astPtr] = this.pendingRecoveredType;
+ this.pendingRecoveredType = null;
+ return;
+ }
+ this.pendingRecoveredType = null;
+ }
+}
+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.endStatementPosition));
+ 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.endStatementPosition));
+}
+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.endStatementPosition));
+ 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.endStatementPosition);
+}
+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.endStatementPosition)
+ );
+ } else {
+ pushOnAstStack(new ReturnStatement(null, this.intStack[this.intPtr--], this.endStatementPosition));
+ }
+}
+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 consumeStatementThrow() {
+ // ThrowStatement ::= 'throw' Expression ';'
+ this.expressionLengthPtr--;
+ pushOnAstStack(new ThrowStatement(this.expressionStack[this.expressionPtr--], this.intStack[this.intPtr--], this.endStatementPosition));
+}
+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 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();
+ 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 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 :
+ pushOnExpressionStackLengthStack(0);
+ break;
+ case TokenNamevolatile :
+ 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 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 :
+ case TokenNameFloatingPointLiteral :
+ case TokenNameDoubleLiteral :
+ pushOnExpressionStack(
+ new DoubleLiteral(
+ this.scanner.getCurrentTokenSource(),
+ this.scanner.startPosition,
+ this.scanner.currentPosition - 1));
+ break;
+ case TokenNameCharacterLiteral :
+ StringLiteral stringLiteral;
+ if (this.recordStringLiterals && this.checkExternalizeStrings && !this.statementRecoveryActivated) {
+ stringLiteral = this.createStringLiteral(
+ this.scanner.getCurrentTokenSourceString(),
+ this.scanner.startPosition,
+ this.scanner.currentPosition - 1,
+ Util.getLineNumber(this.scanner.startPosition, this.scanner.lineEnds, 0, this.scanner.linePtr));
+ this.compilationUnit.recordStringLiteral(stringLiteral);
+ } else {
+ stringLiteral = this.createStringLiteral(
+ this.scanner.getCurrentTokenSourceString(),
+ this.scanner.startPosition,
+ this.scanner.currentPosition - 1,
+ 0);
+ }
+ pushOnExpressionStack(stringLiteral);
+ break;
+ case TokenNameRegExLiteral :
+ pushOnExpressionStack(
+ new RegExLiteral(
+ this.scanner.getCurrentTokenSource(),
+ this.scanner.startPosition,
+ this.scanner.currentPosition - 1));
+ break;
+
+ case TokenNameStringLiteral :
+ if (this.recordStringLiterals && this.checkExternalizeStrings && !this.statementRecoveryActivated) {
+ stringLiteral = this.createStringLiteral(
+ this.scanner.getCurrentTokenSourceString(),
+ this.scanner.startPosition,
+ this.scanner.currentPosition - 1,
+ Util.getLineNumber(this.scanner.startPosition, this.scanner.lineEnds, 0, this.scanner.linePtr));
+ this.compilationUnit.recordStringLiteral(stringLiteral);
+ } else {
+ stringLiteral = this.createStringLiteral(
+ 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 TokenNameundefined :
+ pushOnExpressionStack(
+ new UndefinedLiteral(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 :
+ case TokenNamedebugger :
+ case TokenNameexport :
+ case TokenNamefunction :
+ case TokenNamevar :
+// case TokenNamein :
+// case TokenNameinfinity :
+ case TokenNamewith :
+ 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 TokenNameLBRACKET :
+ this.endPosition = this.scanner.startPosition;
+ break;
+ case TokenNameLBRACE :
+ this.endStatementPosition = this.scanner.currentPosition - 1;
+ case TokenNamePLUS :
+ case TokenNameMINUS :
+ case TokenNameNOT :
+ case TokenNameTWIDDLE :
+ case TokenNamedelete :
+ case TokenNamevoid :
+ case TokenNametypeof :
+ 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 TokenNameSEMICOLON :
+ if (this.insertedSemicolonPosition>0)
+ {
+ if (this.insertedSemicolonPosition>=this.scanner.source.length)
+ this.insertedSemicolonPosition--;
+ this.endStatementPosition = this.insertedSemicolonPosition;
+ this.endPosition = this.insertedSemicolonPosition;
+ this.insertedSemicolonPosition=-1;
+ this.problemReporter().missingSemiColon(null, this.endPosition-1,this.endPosition);
+ break;
+ }// else fallthru
+ case TokenNameRBRACE:
+ this.endStatementPosition = this.scanner.currentPosition - 1;
+ this.endPosition = this.scanner.startPosition - 1;
+ //the item is not part of the potential future 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 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 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 {
+ 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.getOne(),
+ op,
+ this.endStatementPosition);
+ } else {
+ this.expressionStack[this.expressionPtr] =
+ new PrefixExpression(
+ leftHandSide,
+ IntLiteral.getOne(),
+ op,
+ this.intStack[this.intPtr--]);
+ }
+ } else {
+ //the ++ or the -- is NOT taken into account if code gen proceeds
+ if (!post) {
+ this.intPtr--;
+ }
+ if(!this.statementRecoveryActivated) problemReporter().invalidUnaryExpression(leftHandSide);
+ }
+}
+protected void consumeVariableDeclarators() {
+ // VariableDeclarators ::= VariableDeclarators ',' VariableDeclarator
+ optimizedConcatNodeLists();
+}
+protected void consumeVariableInitializers() {
+ // VariableInitializers ::= VariableInitializers ',' VariableInitializer
+ concatExpressionLists();
+}
+/**
+ * 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.sourceStart = c.sourceStart;
+ m.sourceEnd = c.sourceEnd;
+ m.bodyStart = c.bodyStart;
+ m.bodyEnd = c.bodyEnd;
+ m.declarationSourceEnd = c.declarationSourceEnd;
+ m.declarationSourceStart = c.declarationSourceStart;
+ m.setSelector(c.getName());
+ m.statements = c.statements;
+ m.modifiers = c.modifiers;
+ m.arguments = c.arguments;
+ 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 JavadocParser createJavadocParser() {
+ return new JavadocParser(this);
+}
+protected LocalDeclaration createLocalDeclaration(char[] localDeclarationName, int sourceStart, int sourceEnd) {
+ return new LocalDeclaration(localDeclarationName, sourceStart, sourceEnd);
+}
+protected StringLiteral createStringLiteral(char[] token, int start, int end, int lineNumber) {
+ return new StringLiteral(token, start, end, lineNumber);
+}
+
+ 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 = DO_DIET_PARSE;
+ 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.statementRecoveryActivated ) {
+ RecoveredElement recoveredElement = this.buildInitialRecoveryState();
+ recoveredElement.topElement().updateParseTree();
+ if(this.hasError) this.resetStacks();
+ } else if (this.currentElement != null){
+ 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$
+ }
+ recoverAST(this.currentElement);
+ this.currentElement.topElement().updateParseTree();
+ } 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++){
+ if(!this.statementRecoveryActivated) 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]);
+ }
+ if (this.compilationUnit.statements==null)
+ this.compilationUnit.statements=new ProgramElement[0];
+ 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 (Util.getLineNumber(position, this.scanner.lineEnds, 0, this.scanner.linePtr)
+ == Util.getLineNumber(immediateCommentEnd, this.scanner.lineEnds, 0, this.scanner.linePtr)){
+ 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;
+}
+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 ::= '++' JavaScriptUnit
+ // 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;
+ char[] contents = compilationResult.compilationUnit.getContents();
+ this.scanner.setSource(contents, compilationResult);
+
+ if (this.javadocParser != null && this.javadocParser.checkDocComment) {
+ 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 = ScannerHelper.getNumericValue(comment[index[0]++])) > 15
+ || c1 < 0)
+ || ((c2 = ScannerHelper.getNumericValue(comment[index[0]++])) > 15 || c2 < 0)
+ || ((c3 = ScannerHelper.getNumericValue(comment[index[0]++])) > 15 || c3 < 0)
+ || ((c4 = ScannerHelper.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) {
+ ref = null;
+ } 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 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 goForProgramElements() {
+ //tells the scanner to go for block statements opt parsing
+
+ this.firstToken = TokenNamePLUS;
+ this.scanner.recordLineSeparator = true;
+}
+
+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.firstToken = TokenNamePLUS;
+ 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 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 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 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 -- ;
+}
+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 = 0;
+ 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;
+
+ this.errorAction= new HashSet();
+
+}
+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;
+}
+private void jumpOverType(){
+ if (this.recoveredTypes != null && this.nextTypeStart > -1 && this.nextTypeStart < this.scanner.currentPosition) {
+
+ if (DEBUG_AUTOMATON) {
+ System.out.println("Jump -"); //$NON-NLS-1$
+ }
+
+ TypeDeclaration typeDeclaration = this.recoveredTypes[this.recoveredTypePtr];
+ boolean isAnonymous = typeDeclaration.allocation != null;
+
+ int end = this.scanner.eofPosition;
+ this.scanner.resetTo(typeDeclaration.declarationSourceEnd + 1, end - 1);
+ if(!isAnonymous) {
+ ((RecoveryScanner)this.scanner).setPendingTokens(new int[]{TokenNameSEMICOLON, TokenNamebreak});
+ } else {
+ ((RecoveryScanner)this.scanner).setPendingTokens(new int[]{TokenNameIdentifier, TokenNameEQUAL, TokenNameIdentifier});
+ }
+
+ this.pendingRecoveredType = typeDeclaration;
+
+ try {
+ this.currentToken = this.scanner.getNextToken();
+ } catch(InvalidInputException e){
+ // it's impossible because we added pending tokens before
+ }
+
+ if(++this.recoveredTypePtr < this.recoveredTypes.length) {
+ TypeDeclaration nextTypeDeclaration = this.recoveredTypes[this.recoveredTypePtr];
+ this.nextTypeStart =
+ nextTypeDeclaration.allocation == null
+ ? nextTypeDeclaration.declarationSourceStart
+ : nextTypeDeclaration.allocation.sourceStart;
+ } else {
+ this.nextTypeStart = Integer.MAX_VALUE;
+ }
+ }
+}
+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
+ // and enclosing type must not be closed (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=147485)
+ && ((TypeDeclaration) node).declarationSourceEnd == 0)) {
+ 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.currentToken=this.scanner.currentNonWhitespaceToken=TokenNameUNKNOWN;
+ 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.currentToken=TokenNameUNKNOWN;
+ 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 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]++;
+}
+
+protected boolean isErrorState(int act) {
+ int stackTop=this.stateStackTop;
+ int [] tempStack=new int[this.stack.length+2];
+ System.arraycopy(this.stack, 0, tempStack, 0, this.stack.length);
+ boolean first=true;
+ int currentAction = act;
+ ProcessTerminals : for (;;) {
+ int stackLength = tempStack.length;
+ if (!first)
+ {
+ if (++stackTop >= stackLength) {
+ System.arraycopy(
+ tempStack, 0,
+ tempStack = new int[stackLength + StackIncrement], 0,
+ stackLength);
+ }
+ tempStack[stackTop] = currentAction;
+ }
+ first=false;
+ currentAction = tAction(currentAction, this.currentToken);
+ if (currentAction == ERROR_ACTION) {
+ return true;
+ }
+ if (currentAction <= NUM_RULES) {
+ stackTop--;
+
+ } else if (currentAction > ERROR_ACTION) { /* shift-reduce */
+ if (DEBUG) System.out.println("<<shift-reduce consume Token: "+scanner.toStringAction(this.currentToken)); //$NON-NLS-1$
+ return false;
+// consumeToken(this.currentToken);
+// if (this.currentElement != null) this.recoveryTokenCheck();
+// try {
+// prevPos = scanner.currentPosition;
+// prevToken = currentToken;
+// insertedSemicolon = false;
+// this.currentToken = this.scanner.getNextToken();
+// if (DEBUG) System.out.println(">>shift-reduce Next Token: "+scanner.dumpCurrent());
+// } catch(InvalidInputException e){
+// if (!this.hasReportedError){
+// this.problemReporter().scannerError(this, e.getMessage());
+// this.hasReportedError = true;
+// }
+// this.lastCheckPoint = this.scanner.currentPosition;
+// this.restartRecovery = true;
+// }
+// if(this.statementRecoveryActivated) {
+// jumpOverTypeAfterReduce = true;
+// }
+// act -= ERROR_ACTION;
+
+ } else {
+ if (currentAction < ACCEPT_ACTION) { /* shift */
+ if (DEBUG) System.out.println("<<shift consume Token: "+scanner.toStringAction(this.currentToken)); //$NON-NLS-1$
+ return false;
+// consumeToken(this.currentToken);
+// if (this.currentElement != null) this.recoveryTokenCheck();
+// try{
+// prevPos = scanner.currentPosition;
+// prevToken = currentToken;
+// insertedSemicolon = false;
+// this.currentToken = this.scanner.getNextToken();
+// if (DEBUG) System.out.println(">>shift next Token: "+scanner.dumpCurrent());
+// } catch(InvalidInputException e){
+// if (!this.hasReportedError){
+// this.problemReporter().scannerError(this, e.getMessage());
+// this.hasReportedError = true;
+// }
+// this.lastCheckPoint = this.scanner.currentPosition;
+// this.restartRecovery = true;
+// }
+// if(this.statementRecoveryActivated) {
+// this.jumpOverType();
+// }
+// continue ProcessTerminals;
+ }
+ break ProcessTerminals;
+ }
+
+ // ProcessNonTerminals :
+ do { /* reduce */
+ stackTop -= (rhs[currentAction] - 1);
+ currentAction = ntAction(tempStack[stackTop], lhs[currentAction]);
+ } while (currentAction <= NUM_RULES);
+ }
+return false;
+}
+
+
+/*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$
+
+ if (DEBUG_AUTOMATON) {
+ System.out.println("- Start --------------------------------"); //$NON-NLS-1$
+ }
+
+ boolean isDietParse = this.diet;
+ int oldFirstToken = getFirstToken();
+ this.hasError = false;
+
+ this.hasReportedError = false;
+ boolean insertedSemicolon = false;
+ int prevAct = START_STATE,
+ prevToken = getFirstToken(),
+ prevPos = scanner.startPosition;
+
+ 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;
+
+ if (DEBUG)
+ System.out.println("action="+act+ ((term_check[base_action[act]+this.currentToken] == this.currentToken)?"":" - take default") ); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ prevAct=act;
+
+ if (optionalSemicolonState[act])
+ {
+ if (term_check[base_action[act]+this.currentToken] != this.currentToken)
+ {
+ if (isErrorState(act))
+ {
+ if (!insertedSemicolon && shouldInsertSemicolon(prevPos, prevToken) )
+ {
+ currentToken = TokenNameSEMICOLON;
+ this.insertedSemicolonPosition=prevPos;
+ scanner.pushBack();
+ insertedSemicolon = true;
+
+ }
+ }
+ }
+ }
+
+ act = tAction(act, this.currentToken);
+ if (act == ERROR_ACTION || this.restartRecovery) {
+// if ( act == ERROR_ACTION &&
+// !insertedSemicolon &&
+// shouldInsertSemicolon(prevPos, prevToken)
+// ) {
+// act = prevAct;
+// --stateStackTop;
+// currentToken = TokenNameSEMICOLON;
+// scanner.pushBack();
+// insertedSemicolon = true;
+// continue ProcessTerminals;
+// }
+
+ if (DEBUG_AUTOMATON) {
+ if (this.restartRecovery) {
+ System.out.println("Restart - "); //$NON-NLS-1$
+ } else {
+ System.out.println("Error - "); //$NON-NLS-1$
+ }
+ }
+
+ 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();
+ if (DEBUG) System.out.println("!! Resume on syntax error"); //$NON-NLS-1$
+ continue ProcessTerminals;
+ }
+ act = ERROR_ACTION;
+ break ProcessTerminals;
+ }
+ if (act <= NUM_RULES) {
+ insertedSemicolon = false;
+ this.stateStackTop--;
+
+ if (DEBUG_AUTOMATON) {
+ System.out.print("Reduce - "); //$NON-NLS-1$
+ }
+
+ } else if (act > ERROR_ACTION) { /* shift-reduce */
+ if (DEBUG) System.out.println("<<shift-reduce consume Token: "+scanner.toStringAction(this.currentToken)); //$NON-NLS-1$
+ consumeToken(this.currentToken);
+ if (this.currentElement != null) this.recoveryTokenCheck();
+ try {
+ prevPos = scanner.currentPosition;
+ prevToken = currentToken;
+ insertedSemicolon = false;
+ this.currentToken = this.scanner.getNextToken();
+ if (DEBUG) System.out.println(">>shift-reduce Next Token: "+scanner.dumpCurrent()); //$NON-NLS-1$
+ } catch(InvalidInputException e){
+ if (!this.hasReportedError){
+ this.problemReporter().scannerError(this, e.getMessage());
+ this.hasReportedError = true;
+ }
+ this.lastCheckPoint = this.scanner.currentPosition;
+ this.restartRecovery = true;
+ }
+ if(this.statementRecoveryActivated) {
+ this.jumpOverType();
+ }
+ act -= ERROR_ACTION;
+
+ if (DEBUG_AUTOMATON) {
+ System.out.print("Shift/Reduce - (" + name[terminal_index[this.currentToken]]+") "); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ } else {
+ if (act < ACCEPT_ACTION) { /* shift */
+ if (DEBUG) System.out.println("<<shift consume Token: "+scanner.toStringAction(this.currentToken)); //$NON-NLS-1$
+ consumeToken(this.currentToken);
+ if (this.currentElement != null) this.recoveryTokenCheck();
+ try{
+ prevPos = scanner.currentPosition;
+ prevToken = currentToken;
+ insertedSemicolon = false;
+ this.currentToken = this.scanner.getNextToken();
+ if (DEBUG) System.out.println(">>shift next Token: "+scanner.dumpCurrent()); //$NON-NLS-1$
+ } catch(InvalidInputException e){
+ if (!this.hasReportedError){
+ this.problemReporter().scannerError(this, e.getMessage());
+ this.hasReportedError = true;
+ }
+ this.lastCheckPoint = this.scanner.currentPosition;
+ this.restartRecovery = true;
+ }
+ if(this.statementRecoveryActivated) {
+ this.jumpOverType();
+ }
+ if (DEBUG_AUTOMATON) {
+ System.out.println("Shift - (" + name[terminal_index[this.currentToken]]+")"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ continue ProcessTerminals;
+ }
+ break ProcessTerminals;
+ }
+
+ // ProcessNonTerminals :
+ do { /* reduce */
+
+ if (DEBUG_AUTOMATON) {
+ System.out.println(name[non_terminal_index[lhs[act]]]);
+ }
+
+ consumeRule(act);
+ this.stateStackTop -= (rhs[act] - 1);
+ act = ntAction(this.stack[this.stateStackTop], lhs[act]);
+ if (DEBUG_AUTOMATON && act <= NUM_RULES) {
+ System.out.print(" - "); //$NON-NLS-1$
+ }
+
+ } while (act <= NUM_RULES);
+ if (DEBUG_AUTOMATON) {
+ System.out.println("----------------------------------------"); //$NON-NLS-1$
+ }
+ }
+ if (DEBUG_AUTOMATON) {
+ System.out.println("- End ----------------------------------"); //$NON-NLS-1$
+ }
+
+ 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 && !(this.statementRecoveryActivated && DO_DIET_PARSE)) {
+ if(!this.options.performStatementsRecovery) {
+ reportSyntaxErrors(isDietParse, oldFirstToken);
+ } else {
+ RecoveryScannerData data = this.referenceContext.compilationResult().recoveryScannerData;
+
+ if(this.recoveryScanner == null) {
+ this.recoveryScanner = new RecoveryScanner(this.scanner, data);
+ } else {
+ this.recoveryScanner.setData(data);
+ }
+
+ this.recoveryScanner.setSource(scanner.source);
+ this.recoveryScanner.lineEnds = this.scanner.lineEnds;
+ this.recoveryScanner.linePtr = this.scanner.linePtr;
+
+ reportSyntaxErrors(isDietParse, oldFirstToken);
+
+ if(data == null) {
+ this.referenceContext.compilationResult().recoveryScannerData =
+ this.recoveryScanner.getData();
+ }
+
+ if (this.methodRecoveryActivated && this.options.performStatementsRecovery && !this.enteredRecoverStatements) {
+ this.methodRecoveryActivated = false;
+ this.enteredRecoverStatements=true;
+ this.recoverStatements();
+ this.methodRecoveryActivated = true;
+
+ this.lastAct = ERROR_ACTION;
+ }
+ }
+ }
+
+ 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
+
+ boolean oldMethodRecoveryActivated = this.methodRecoveryActivated;
+ if(this.options.performMethodsFullRecovery) {
+ this.methodRecoveryActivated = true;
+ }
+
+ 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]--;
+ if(this.options.performStatementsRecovery) {
+ this.methodRecoveryActivated = oldMethodRecoveryActivated;
+ }
+ }
+
+ checkNonNLSAfterBodyEnd(cd.declarationSourceEnd);
+
+ if (this.lastAct == ERROR_ACTION) {
+ initialize();
+ return;
+ }
+
+ //statements
+ cd.explicitDeclarations = this.realBlockStack[this.realBlockPtr--];
+ int length;
+ if (astLengthPtr > -1 && (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();
+
+ /* unit creation */
+ this.referenceContext =
+ this.compilationUnit =
+ new CompilationUnitDeclaration(
+ this.problemReporter,
+ compilationResult,
+ 0);
+
+
+ initializeInferenceEngine(this.compilationUnit);
+
+ /* scanners initialization */
+ char[] contents;
+ try {
+ contents = sourceUnit.getContents();
+ } catch(AbortCompilationUnit abortException) {
+ this.problemReporter().cannotReadSource(this.compilationUnit, abortException, this.options.verbose);
+ contents = CharOperation.NO_CHAR; // pretend empty from thereon
+ }
+ this.scanner.setSource(contents);
+ this.compilationUnit.sourceEnd = this.scanner.source.length - 1;
+ 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);
+ }
+ }
+ /* run automaton */
+if (false)
+ System.out.println("parsing "+new String(sourceUnit.getFileName())); //$NON-NLS-1$
+ 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;
+}
+
+public void initializeInferenceEngine(CompilationUnitDeclaration compilationUnitDeclaration) {
+ if (this.inferenceEngines==null)
+ this.inferenceEngines = InferrenceManager.getInstance().getInferenceEngines(compilationUnitDeclaration);
+ for (int i = 0; i < this.inferenceEngines.length; i++) {
+ this.inferenceEngines[i].initializeOptions(this.options.inferOptions);
+ }
+}
+
+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
+
+ boolean oldMethodRecoveryActivated = this.methodRecoveryActivated;
+ if(this.options.performMethodsFullRecovery) {
+ this.methodRecoveryActivated = true;
+ }
+
+ 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]--;
+ if(this.options.performStatementsRecovery) {
+ this.methodRecoveryActivated = oldMethodRecoveryActivated;
+ }
+ }
+
+ checkNonNLSAfterBodyEnd(initializer.declarationSourceEnd);
+
+ if (this.lastAct == ERROR_ACTION) {
+ return;
+ }
+
+ //refill statements
+ initializer.block.explicitDeclarations = this.realBlockStack[this.realBlockPtr--];
+ int length;
+ if (astLengthPtr > -1 && (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.modifiers & ExtraCompilerModifiers.AccSemicolonBody) != 0)
+ return;
+
+ boolean oldMethodRecoveryActivated = this.methodRecoveryActivated;
+ if(this.options.performMethodsFullRecovery) {
+ this.methodRecoveryActivated = true;
+ this.rParenPos = md.sourceEnd;
+ }
+ 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]--;
+ if(this.options.performStatementsRecovery) {
+ this.methodRecoveryActivated = oldMethodRecoveryActivated;
+ }
+ }
+
+ checkNonNLSAfterBodyEnd(md.declarationSourceEnd);
+
+ if (this.lastAct == ERROR_ACTION) {
+ return;
+ }
+
+ //refill statements
+ md.explicitDeclarations = this.realBlockStack[this.realBlockPtr--];
+ int length;
+ if (astLengthPtr > -1 && (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 || this.hasError) {
+ return null;
+ }
+ int astLength;
+ if (astLengthPtr > -1 && (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 parseStatements(ReferenceContext rc, int start, int end, TypeDeclaration[] types, CompilationUnitDeclaration unit) {
+ boolean oldStatementRecoveryEnabled = this.statementRecoveryActivated;
+ this.statementRecoveryActivated = true;
+
+ initialize();
+
+ if (rc instanceof CompilationUnitDeclaration)
+ goForCompilationUnit();
+ else
+ goForBlockStatementsopt();
+ this.nestedMethod[this.nestedType]++;
+ pushOnRealBlockStack(0);
+
+ //pushOnAstLengthStack(0);
+
+ this.referenceContext = rc;
+ this.compilationUnit = unit;
+
+ this.pendingRecoveredType = null;
+
+ if(types != null && types.length > 0) {
+ this.recoveredTypes = types;
+ this.recoveredTypePtr = 0;
+ this.nextTypeStart =
+ this.recoveredTypes[0].allocation == null
+ ? this.recoveredTypes[0].declarationSourceStart
+ : this.recoveredTypes[0].allocation.sourceStart;
+ } else {
+ this.recoveredTypes = null;
+ this.recoveredTypePtr = -1;
+ this.nextTypeStart = -1;
+ }
+
+ this.scanner.resetTo(start, end);
+ // reset the scanner to parser from { down to }
+
+ this.lastCheckPoint = this.scanner.initialPosition;
+
+
+ this.stateStackTop = -1;
+
+ try {
+ parse();
+ } catch (AbortCompilation ex) {
+ this.lastAct = ERROR_ACTION;
+ } finally {
+ this.nestedMethod[this.nestedType]--;
+ this.recoveredTypes = null;
+ this.statementRecoveryActivated = oldStatementRecoveryEnabled;
+ }
+
+ checkNonNLSAfterBodyEnd(end);
+}
+public void persistLineSeparatorPositions() {
+ if (this.scanner.recordLineSeparator) {
+ this.compilationUnit.compilationResult.lineSeparatorPositions = this.scanner.getLineEnds();
+ }
+}
+/*
+ * Prepares the state of the parser to go for BlockStatements.
+ */
+protected void prepareForBlockStatements() {
+ this.nestedMethod[this.nestedType = 0] = 1;
+ this.variablesCounter[this.nestedType] = 0;
+ this.realBlockStack[this.realBlockPtr = 1] = 0;
+}
+/**
+ * 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) {
+ if (this.compilationUnit!=null)
+ 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;
+}
+protected void recoverStatements() {
+ class MethodVisitor extends ASTVisitor {
+ public ASTVisitor typeVisitor;
+
+ TypeDeclaration enclosingType; // used only for initializer
+
+ TypeDeclaration[] types = new TypeDeclaration[0];
+ int typePtr = -1;
+ public boolean visit(ConstructorDeclaration constructorDeclaration, ClassScope scope) {
+ typePtr = -1;
+ return true;
+ }
+ public boolean visit(Initializer initializer, MethodScope scope) {
+ typePtr = -1;
+ return true;
+ }
+ public boolean visit(MethodDeclaration methodDeclaration,Scope scope) {
+ typePtr = -1;
+ return true;
+ }
+ public boolean visit(TypeDeclaration typeDeclaration, BlockScope scope) {
+ return this.visit(typeDeclaration);
+ }
+ public boolean visit(TypeDeclaration typeDeclaration, Scope scope) {
+ return this.visit(typeDeclaration);
+ }
+ private boolean visit(TypeDeclaration typeDeclaration) {
+ if(this.types.length <= ++this.typePtr) {
+ int length = this.typePtr;
+ System.arraycopy(this.types, 0, this.types = new TypeDeclaration[length * 2 + 1], 0, length);
+ }
+ this.types[this.typePtr] = typeDeclaration;
+ return false;
+ }
+ public void endVisit(ConstructorDeclaration constructorDeclaration, ClassScope scope) {
+ this.endVisitMethod(constructorDeclaration, scope);
+ }
+ public void endVisit(MethodDeclaration methodDeclaration, Scope scope) {
+ this.endVisitMethod(methodDeclaration, scope);
+ }
+ private void endVisitMethod(AbstractMethodDeclaration methodDeclaration, Scope scope) {
+ TypeDeclaration[] foundTypes = null;
+// int length = 0;
+// if(this.typePtr > -1) {
+// length = this.typePtr + 1;
+// foundTypes = new TypeDeclaration[length];
+// System.arraycopy(this.types, 0, foundTypes, 0, length);
+// }
+ ReferenceContext oldContext = Parser.this.referenceContext;
+ Parser.this.recoveryScanner.resetTo(methodDeclaration.bodyStart, methodDeclaration.bodyEnd);
+ Scanner oldScanner = Parser.this.scanner;
+ Parser.this.scanner = Parser.this.recoveryScanner;
+ Parser.this.parseStatements(
+ methodDeclaration,
+ methodDeclaration.bodyStart,
+ methodDeclaration.bodyEnd,
+ foundTypes,
+ compilationUnit);
+ Parser.this.scanner = oldScanner;
+ Parser.this.referenceContext = oldContext;
+
+// for (int i = 0; i < length; i++) {
+// foundTypes[i].traverse(typeVisitor, scope);
+// }
+ }
+ public void endVisit(Initializer initializer, MethodScope scope) {
+ TypeDeclaration[] foundTypes = null;
+ int length = 0;
+ if(this.typePtr > -1) {
+ length = this.typePtr + 1;
+ foundTypes = new TypeDeclaration[length];
+ System.arraycopy(this.types, 0, foundTypes, 0, length);
+ }
+ ReferenceContext oldContext = Parser.this.referenceContext;
+ Parser.this.recoveryScanner.resetTo(initializer.bodyStart, initializer.bodyEnd);
+ Scanner oldScanner = Parser.this.scanner;
+ Parser.this.scanner = Parser.this.recoveryScanner;
+ Parser.this.parseStatements(
+ this.enclosingType,
+ initializer.bodyStart,
+ initializer.bodyEnd,
+ foundTypes,
+ compilationUnit);
+ Parser.this.scanner = oldScanner;
+ Parser.this.referenceContext = oldContext;
+
+ for (int i = 0; i < length; i++) {
+ foundTypes[i].traverse(typeVisitor, scope);
+ }
+ }
+ }
+ class TypeVisitor extends ASTVisitor {
+ public MethodVisitor methodVisitor;
+
+ TypeDeclaration[] types = new TypeDeclaration[0];
+ int typePtr = -1;
+
+ public void endVisit(TypeDeclaration typeDeclaration, BlockScope scope) {
+ endVisitType();
+ }
+ public void endVisit(TypeDeclaration typeDeclaration, ClassScope scope) {
+ endVisitType();
+ }
+ private void endVisitType() {
+ this.typePtr--;
+ }
+ public boolean visit(TypeDeclaration typeDeclaration, BlockScope scope) {
+ return this.visit(typeDeclaration);
+ }
+ public boolean visit(TypeDeclaration typeDeclaration, ClassScope scope) {
+ return this.visit(typeDeclaration);
+ }
+ private boolean visit(TypeDeclaration typeDeclaration) {
+ if(this.types.length <= ++this.typePtr) {
+ int length = this.typePtr;
+ System.arraycopy(this.types, 0, this.types = new TypeDeclaration[length * 2 + 1], 0, length);
+ }
+ this.types[this.typePtr] = typeDeclaration;
+ return true;
+ }
+ public boolean visit(ConstructorDeclaration constructorDeclaration, ClassScope scope) {
+ if(constructorDeclaration.isDefaultConstructor()) return false;
+
+ constructorDeclaration.traverse(methodVisitor, scope);
+ return false;
+ }
+ public boolean visit(Initializer initializer, MethodScope scope) {
+ methodVisitor.enclosingType = this.types[typePtr];
+ initializer.traverse(methodVisitor, scope);
+ return false;
+ }
+ public boolean visit(MethodDeclaration methodDeclaration, Scope scope) {
+ methodDeclaration.traverse(methodVisitor, scope);
+ return false;
+ }
+ }
+
+ if (false)
+ {
+ MethodVisitor methodVisitor = new MethodVisitor();
+ TypeVisitor typeVisitor = new TypeVisitor();
+ methodVisitor.typeVisitor = typeVisitor;
+ typeVisitor.methodVisitor = methodVisitor;
+
+ if(this.referenceContext instanceof AbstractMethodDeclaration) {
+ ((AbstractMethodDeclaration)this.referenceContext).traverse(methodVisitor, (Scope)null);
+ }else if(this.referenceContext instanceof CompilationUnitDeclaration) {
+ CompilationUnitDeclaration compilationUnitDeclaration=(CompilationUnitDeclaration)this.referenceContext;
+ if (compilationUnitDeclaration.statements!=null)
+ for (int i = 0; i < compilationUnitDeclaration.statements.length; i++) {
+ if( compilationUnitDeclaration.statements[i] instanceof AbstractMethodDeclaration)
+ ((AbstractMethodDeclaration)compilationUnitDeclaration.statements[i] ).traverse(methodVisitor, (Scope)null);
+ }
+ } else if(this.referenceContext instanceof TypeDeclaration) {
+ TypeDeclaration typeContext = (TypeDeclaration)this.referenceContext;
+
+ int length = typeContext.fields.length;
+ for (int i = 0; i < length; i++) {
+ final FieldDeclaration fieldDeclaration = typeContext.fields[i];
+ switch(fieldDeclaration.getKind()) {
+ case AbstractVariableDeclaration.INITIALIZER:
+ methodVisitor.enclosingType = typeContext;
+ ((Initializer) fieldDeclaration).traverse(methodVisitor, (MethodScope)null);
+ break;
+ }
+ }
+ }
+ }
+ else
+ {
+ CompilationUnitDeclaration compilationUnitDeclaration=(CompilationUnitDeclaration)this.referenceContext;
+
+ ReferenceContext oldContext = Parser.this.referenceContext;
+ int start = compilationUnitDeclaration.sourceStart;
+ int end = compilationUnitDeclaration.sourceEnd;
+ Parser.this.recoveryScanner.resetTo(start, end);
+ Scanner oldScanner = Parser.this.scanner;
+ Parser.this.scanner = Parser.this.recoveryScanner;
+ /* unit creation */
+ this.referenceContext =
+ this.compilationUnit = compilationUnitDeclaration=
+ new CompilationUnitDeclaration(
+ this.problemReporter,
+ compilationUnitDeclaration.compilationResult,
+ end);
+
+ Parser.this.parseStatements(
+ compilationUnitDeclaration,
+ start,
+ end,
+ null,
+ compilationUnit);
+ Parser.this.scanner = oldScanner;
+ Parser.this.referenceContext = oldContext;
+ }
+
+
+}
+
+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;
+ this.lastCheckPoint=this.scanner.currentPosition;
+// 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;
+}
+
+protected boolean shouldInsertSemicolon(int prevpos, int prevtoken) {
+ Integer position = new Integer(prevpos);
+ if (this.errorAction.contains(position)) {
+ // should not insert a semi-colon at a location that has already be tried
+ return false;
+ }
+ this.errorAction.add(position);
+ return this.currentToken == TokenNameRBRACE
+ || scanner.getLineNumber(scanner.currentPosition) > scanner.getLineNumber(prevpos)
+ || this.currentToken==TokenNameEOF;
+}
+
+// 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 : this.scanner.eofPosition - 1;
+ if(isDietParse) {
+ ProgramElement[] statements = this.compilationUnit.statements;
+// TypeDeclaration[] types = this.compilationUnit.types;
+ int[][] intervalToSkip = org.eclipse.wst.jsdt.internal.compiler.parser.diagnose.RangeUtil.computeDietRange(statements);
+// int[][] intervalToSkip = org.eclipse.wst.jsdt.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(false);
+
+ reportSyntaxErrorsForSkippedMethod(statements);
+// reportSyntaxErrorsForSkippedMethod(types);
+ this.scanner.resetTo(start, end);
+ } else {
+ DiagnoseParser diagnoseParser = new DiagnoseParser(this, oldFirstToken, start, end, this.options);
+ diagnoseParser.diagnoseParse(this.options.performStatementsRecovery);
+ }
+}
+private void reportSyntaxErrorsForSkippedMethod(ProgramElement[] statements){
+ if(statements != null) {
+ for (int i = 0; i < statements.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++) {
+ if (statements[i] instanceof AbstractMethodDeclaration )
+ {
+ AbstractMethodDeclaration method = (AbstractMethodDeclaration)statements[i] ;
+ if(method.errorInSignature) {
+ DiagnoseParser diagnoseParser = new DiagnoseParser(this, TokenNameDIVIDE, method.declarationSourceStart, method.declarationSourceEnd, this.options);
+ diagnoseParser.diagnoseParse(this.options.performStatementsRecovery);
+ }
+// }
+ }
+ else if (statements[i] instanceof FieldDeclaration )
+ {
+// FieldDeclaration field =(FieldDeclaration) statements[i] ;
+// 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(this.options.performStatementsRecovery);
+// }
+// }
+// }
+ }
+ }
+ }
+}
+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;
+ this.errorAction = new HashSet();
+}
+/*
+ * 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() {
+ if(!this.methodRecoveryActivated && !this.statementRecoveryActivated) {
+
+ // 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){
+ if (DO_DIET_PARSE)
+ {
+ goForHeaders();
+ this.diet = true; // passed this point, will not consider method bodies
+ }
+ else
+ goForProgramElements();
+ return true;
+ }
+
+ // does not know how to restart
+ return false;
+ } else if(!this.statementRecoveryActivated || !DO_DIET_PARSE) {
+
+ // reset internal stacks
+ this.resetStacks();
+ this.resetModifiers();
+
+ /* attempt to move checkpoint location */
+ if (!this.moveRecoveryCheckpoint()) {
+ return false;
+ }
+
+ // only look for headers
+ if (DO_DIET_PARSE)
+ goForHeaders();
+ else
+ goForProgramElements();
+ return true;
+ } else {
+ 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;
+
+ // do not investigate deeper in statement recovery
+ if (this.statementRecoveryActivated) return false;
+
+ // 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 void setMethodsFullRecovery(boolean enabled) {
+ this.options.performMethodsFullRecovery = enabled;
+}
+public void setStatementsRecovery(boolean enabled) {
+ if(enabled) this.options.performMethodsFullRecovery = true;
+ this.options.performStatementsRecovery = enabled;
+}
+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 + "intPtr : int = " + String.valueOf(this.intPtr) + "\n"; //$NON-NLS-1$ //$NON-NLS-2$
+
+ 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--];
+}
+
+public void inferTypes(CompilationUnitDeclaration parsedUnit, CompilerOptions compileOptions) {
+ if (parsedUnit.typesHaveBeenInferred)
+ return;
+ if (compileOptions==null)
+ compileOptions=this.options;
+
+ if (this.inferenceEngines==null)
+ initializeInferenceEngine(parsedUnit);
+// InferEngine inferEngine=compileOptions.inferOptions.createEngine();
+ for (int i=0;i<this.inferenceEngines.length;i++)
+ {
+ IInferEngine engine=this.inferenceEngines[i];
+ PerformanceStats stats= PerformanceStats.getStats(PERFORMANCE__INFER_TYPES, engine);
+ try {
+ stats.startRun(new String(parsedUnit.getFileName()));
+
+ engine.initialize();
+ if (engine instanceof IInferEngineExtension)
+ ((IInferEngineExtension) engine).setCompilationUnit(parsedUnit, this.scanner.getSource());
+ else
+ engine.setCompilationUnit(parsedUnit);
+
+ engine.doInfer();
+ } catch (RuntimeException e) {
+ org.eclipse.wst.jsdt.internal.core.util.Util.log(e, "error during type inferencing"); //$NON-NLS-1$
+ }
+ finally {
+ stats.endRun();
+ if (REPORT_PERFORMANCE__INFER_TYPES && stats.isFailure()) {
+ IStatus status = new Status(IStatus.WARNING, JavaScriptCore.PLUGIN_ID, IStatus.OK, "Inference Engine took too long: " + engine, null); //$NON-NLS-1$
+ Platform.getLog(Platform.getBundle(JavaScriptCore.PLUGIN_ID)).log(status);
+ }
+ }
+ }
+ parsedUnit.typesHaveBeenInferred=true;
+}
+
+
+}
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/ParserBasicInformation.java b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/ParserBasicInformation.java
index 6a96a40..e5fbd8c 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/ParserBasicInformation.java
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/ParserBasicInformation.java
@@ -16,23 +16,23 @@
int
- ERROR_SYMBOL = 120,
- MAX_NAME_LENGTH = 36,
- NUM_STATES = 552,
+ ERROR_SYMBOL = 120,
+ MAX_NAME_LENGTH = 36,
+ NUM_STATES = 552,
- NT_OFFSET = 120,
- SCOPE_UBOUND = 56,
- SCOPE_SIZE = 57,
- LA_STATE_OFFSET = 7620,
- MAX_LA = 1,
- NUM_RULES = 398,
- NUM_TERMINALS = 120,
- NUM_NON_TERMINALS = 180,
- NUM_SYMBOLS = 300,
- START_STATE = 805,
- EOFT_SYMBOL = 70,
- EOLT_SYMBOL = 70,
- ACCEPT_ACTION = 7619,
- ERROR_ACTION = 7620;
+ NT_OFFSET = 120,
+ SCOPE_UBOUND = 56,
+ SCOPE_SIZE = 57,
+ LA_STATE_OFFSET = 7750,
+ MAX_LA = 1,
+ NUM_RULES = 398,
+ NUM_TERMINALS = 120,
+ NUM_NON_TERMINALS = 180,
+ NUM_SYMBOLS = 300,
+ START_STATE = 595,
+ EOFT_SYMBOL = 70,
+ EOLT_SYMBOL = 70,
+ ACCEPT_ACTION = 7749,
+ ERROR_ACTION = 7750;
}
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/TerminalTokens.java b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/TerminalTokens.java
index 7d11bd9..c6b1a9b 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/TerminalTokens.java
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/TerminalTokens.java
@@ -34,7 +34,7 @@
TokenNameCOMMENT_JAVADOC = 1003,
TokenNameUNKNOWN = 1004;
- int TokenNameIdentifier = 32,
+ int TokenNameIdentifier = 32,
TokenNameabstract = 88,
TokenNameboolean = 89,
TokenNamebreak = 59,
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser1.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser1.rsc
index 409011f..92e08e4 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser1.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser1.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser10.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser10.rsc
index 9e6c9fb..d4236da 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser10.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser10.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser11.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser11.rsc
index cae65a8..6209a86 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser11.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser11.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser12.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser12.rsc
index b3d0025..d1895f5 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser12.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser12.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser13.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser13.rsc
index e434b9e..d66b77b 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser13.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser13.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser14.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser14.rsc
index 71ef33e..6f38cf2 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser14.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser14.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser15.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser15.rsc
index 1e0b7db..6941739 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser15.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser15.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser16.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser16.rsc
index 64015f2..6746e47 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser16.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser16.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser2.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser2.rsc
index 15f415a..6d966f9 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser2.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser2.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser22.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser22.rsc
index 847bd34..962b0d8 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser22.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser22.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser3.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser3.rsc
index 459b04b..f7ce15a 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser3.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser3.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser4.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser4.rsc
index 828cf22..7ac7c53 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser4.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser4.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser5.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser5.rsc
index a7d76f2..3f07658 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser5.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser5.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser6.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser6.rsc
index 2df54e2..88c432c 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser6.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser6.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser8.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser8.rsc
index 40cbffd..5dd7879 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser8.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser8.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser9.rsc b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser9.rsc
index 5b03b58..8c5b980 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser9.rsc
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/parser9.rsc
Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/readableNames.properties b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/readableNames.properties
index b25d392..73b26ad 100644
--- a/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/readableNames.properties
+++ b/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/parser/readableNames.properties
@@ -1,16 +1,3 @@
-###############################################################################
-# Copyright (c) 2011 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
-###############################################################################
-# NLS_ENCODING=UTF-8
-# NLS_MESSAGEFORMAT_NONE
-
AbstractMethodDeclaration=MethodDeclaration
AdditiveExpression=Expression
AdditiveExpressionStmt=AdditiveExpression
