|
1
12 package org.eclipse.jdt.internal.compiler.parser;
13
14 import java.io.*;
15 import java.util.ArrayList  ;
16 import java.util.Collections ;
17 import java.util.Iterator ;
18 import java.util.List ;
19 import java.util.Locale ;
20 import java.util.MissingResourceException ;
21 import java.util.ResourceBundle ;
22
23 import org.eclipse.jdt.core.compiler.CharOperation;
24 import org.eclipse.jdt.core.compiler.InvalidInputException;
25 import org.eclipse.jdt.internal.compiler.ASTVisitor;
26 import org.eclipse.jdt.internal.compiler.CompilationResult;
27 import org.eclipse.jdt.internal.compiler.ast.*;
28 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
29 import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
30 import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
31 import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
32 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
33 import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
34 import org.eclipse.jdt.internal.compiler.lookup.Binding;
35 import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
36 import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
37 import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
38 import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
39 import org.eclipse.jdt.internal.compiler.parser.diagnose.DiagnoseParser;
40 import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
41 import org.eclipse.jdt.internal.compiler.problem.AbortCompilationUnit;
42 import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
43 import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
44 import org.eclipse.jdt.internal.compiler.util.Messages;
45 import org.eclipse.jdt.internal.compiler.util.Util;
46
47 public class Parser implements ParserBasicInformation, TerminalTokens, OperatorIds, TypeIds {
48 protected static final int THIS_CALL = ExplicitConstructorCall.This;
49 protected static final int SUPER_CALL = ExplicitConstructorCall.Super;
50
51 public static char asb[] = null;
52 public static char asr[] = null;
53 protected final static int AstStackIncrement = 100;
55 public static char base_action[] = null;
56 public static final int BracketKinds = 3;
57
58 public static short check_table[] = null;
59 public static final int CurlyBracket = 2;
60 private static final boolean DEBUG = false;
61 private static final boolean DEBUG_AUTOMATON = false;
62 private static final String EOF_TOKEN = "$eof" ; private static final String ERROR_TOKEN = "$error" ; protected final static int ExpressionStackIncrement = 100;
66
67 protected final static int GenericsStackIncrement = 10;
68
69 private final static String FILEPREFIX = "parser"; public static char in_symb[] = null;
71 private static final String INVALID_CHARACTER = "Invalid Character" ; public static char lhs[] = null;
73
74 public static String name[] = null;
75 public static char nasb[] = null;
76 public static char nasr[] = null;
77 public static char non_terminal_index[] = null;
78 private final static String READABLE_NAMES_FILE = "readableNames"; private final static String READABLE_NAMES_FILE_NAME =
80 "org.eclipse.jdt.internal.compiler.parser." + READABLE_NAMES_FILE; public static String readableName[] = null;
82
83 public static byte rhs[] = null;
84
85 public static int[] reverse_index = null;
86 public static char[] recovery_templates_index = null;
87 public static char[] recovery_templates = null;
88 public static char[] statements_recovery_filter = null;
89
90 public static long rules_compliance[] = null;
91
92 public static final int RoundBracket = 0;
93
94 public static byte scope_la[] = null;
95 public static char scope_lhs[] = null;
96
97 public static char scope_prefix[] = null;
98 public static char scope_rhs[] = null;
99 public static char scope_state[] = null;
100
101 public static char scope_state_set[] = null;
102 public static char scope_suffix[] = null;
103 public static final int SquareBracket = 1;
104
105 protected final static int StackIncrement = 255;
107
108 public static char term_action[] = null;
109 public static byte term_check[] = null;
110
111 public static char terminal_index[] = null;
112
113 private static final String UNEXPECTED_EOF = "Unexpected End Of File" ; public static boolean VERBOSE_RECOVERY = false;
115
116
117
118 protected int astLengthPtr;
119 protected int[] astLengthStack;
120 protected int astPtr;
121 protected ASTNode[] astStack = new ASTNode[AstStackIncrement];
122 public CompilationUnitDeclaration compilationUnit;
123 protected RecoveredElement currentElement;
124 public int currentToken;
125 protected boolean diet = false; protected int dietInt = 0; protected int endPosition; protected int endStatementPosition;
129 protected int expressionLengthPtr;
130 protected int[] expressionLengthStack;
131 protected int expressionPtr;
132 protected Expression[] expressionStack = new Expression[ExpressionStackIncrement];
133 public int firstToken ;
135 protected int genericsIdentifiersLengthPtr;
137 protected int[] genericsIdentifiersLengthStack = new int[GenericsStackIncrement];
138 protected int genericsLengthPtr;
139 protected int[] genericsLengthStack = new int[GenericsStackIncrement];
140 protected int genericsPtr;
141 protected ASTNode[] genericsStack = new ASTNode[GenericsStackIncrement];
142
143 protected boolean hasError;
144 protected boolean hasReportedError;
145
146 protected int identifierLengthPtr;
148 protected int[] identifierLengthStack;
149 protected long[] identifierPositionStack;
150 protected int identifierPtr;
151 protected char[][] identifierStack;
152
153 protected boolean ignoreNextOpeningBrace;
154 protected int intPtr;
156 protected int[] intStack;
157 public int lastAct ;
159 protected int lastCheckPoint;
161 protected int lastErrorEndPosition;
162 protected int lastErrorEndPositionBeforeRecovery = -1;
163 protected int lastIgnoredToken, nextIgnoredToken;
164 protected int listLength; protected int listTypeParameterLength; protected int lParenPos,rParenPos; protected int modifiers;
168 protected int modifiersSourceStart;
169 protected int[] nestedMethod; protected int nestedType, dimensions;
171 ASTNode [] noAstNodes = new ASTNode[AstStackIncrement];
172 Expression [] noExpressions = new Expression[ExpressionStackIncrement];
173 protected boolean optimizeStringLiterals =true;
175 protected CompilerOptions options;
176 protected ProblemReporter problemReporter;
177 protected int rBraceStart, rBraceEnd, rBraceSuccessorStart; protected int realBlockPtr;
179 protected int[] realBlockStack;
180 protected int recoveredStaticInitializerStart;
181 public ReferenceContext referenceContext;
182 public boolean reportOnlyOneSyntaxError = false;
183 public boolean reportSyntaxErrorIsRequired = true;
184 protected boolean restartRecovery;
185
186 public boolean methodRecoveryActivated = false;
189 protected boolean statementRecoveryActivated = false;
190 protected TypeDeclaration[] recoveredTypes;
191 protected int recoveredTypePtr;
192 protected int nextTypeStart;
193 protected TypeDeclaration pendingRecoveredType;
194
195 public RecoveryScanner recoveryScanner;
196
197 public Scanner scanner;
199 protected int[] stack = new int[StackIncrement];
200 protected int stateStackTop;
201 protected int synchronizedBlockSourceStart;
202 protected int[] variablesCounter;
203
204 protected boolean checkExternalizeStrings;
205 protected boolean recordStringLiterals;
206
207 public Javadoc javadoc;
209 public JavadocParser javadocParser;
210 protected int lastJavadocEnd;
212
213 static {
214 try{
215 initTables();
216 } catch(java.io.IOException ex){
217 throw new ExceptionInInitializerError (ex.getMessage());
218 }
219 }
220 public static int asi(int state) {
221
222 return asb[original_state(state)];
223 }
224 public final static short base_check(int i) {
225 return check_table[i - (NUM_RULES + 1)];
226 }
227 private final static void buildFile(String filename, List listToDump) {
228 BufferedWriter writer = null;
229 try {
230 writer = new BufferedWriter(new FileWriter(filename));
231 for (Iterator iterator = listToDump.iterator(); iterator.hasNext(); ) {
232 writer.write(String.valueOf(iterator.next()));
233 }
234 writer.flush();
235 } catch(IOException e) {
236 } finally {
238 if (writer != null) {
239 try {
240 writer.close();
241 } catch (IOException e1) {
242 }
244 }
245 }
246 System.out.println(filename + " creation complete"); }
248 private final static String [] buildFileForName(String filename, String contents) {
249 String [] result = new String [contents.length()];
250 result[0] = null;
251 int resultCount = 1;
252
253 StringBuffer buffer = new StringBuffer ();
254
255 int start = contents.indexOf("name[]"); start = contents.indexOf('\"', start);
257 int end = contents.indexOf("};", start);
259 contents = contents.substring(start, end);
260
261 boolean addLineSeparator = false;
262 int tokenStart = -1;
263 StringBuffer currentToken = new StringBuffer ();
264 for (int i = 0; i < contents.length(); i++) {
265 char c = contents.charAt(i);
266 if(c == '\"') {
267 if(tokenStart == -1) {
268 tokenStart = i + 1;
269 } else {
270 if(addLineSeparator) {
271 buffer.append('\n');
272 result[resultCount++] = currentToken.toString();
273 currentToken = new StringBuffer ();
274 }
275 String token = contents.substring(tokenStart, i);
276 if(token.equals(ERROR_TOKEN)){
277 token = INVALID_CHARACTER;
278 } else if(token.equals(EOF_TOKEN)) {
279 token = UNEXPECTED_EOF;
280 }
281 buffer.append(token);
282 currentToken.append(token);
283 addLineSeparator = true;
284 tokenStart = -1;
285 }
286 }
287 if(tokenStart == -1 && c == '+'){
288 addLineSeparator = false;
289 }
290 }
291 if(currentToken.length() > 0) {
292 result[resultCount++] = currentToken.toString();
293 }
294
295 buildFileForTable(filename, buffer.toString().toCharArray());
296
297 System.arraycopy(result, 0, result = new String [resultCount], 0, resultCount);
298 return result;
299 }
300 private static void buildFileForReadableName(
301 String file,
302 char[] newLhs,
303 char[] newNonTerminalIndex,
304 String [] newName,
305 String [] tokens) {
306
307 ArrayList entries = new ArrayList ();
308
309 boolean[] alreadyAdded = new boolean[newName.length];
310
311 for (int i = 0; i < tokens.length; i = i + 3) {
312 if("1".equals(tokens[i])) { int index = newNonTerminalIndex[newLhs[Integer.parseInt(tokens[i + 1])]];
314 StringBuffer buffer = new StringBuffer ();
315 if(!alreadyAdded[index]) {
316 alreadyAdded[index] = true;
317 buffer.append(newName[index]);
318 buffer.append('=');
319 buffer.append(tokens[i+2].trim());
320 buffer.append('\n');
321 entries.add(String.valueOf(buffer));
322 }
323 }
324 }
325 int i = 1;
326 while(!INVALID_CHARACTER.equals(newName[i])) i++;
327 i++;
328 for (; i < alreadyAdded.length; i++) {
329 if(!alreadyAdded[i]) {
330 System.out.println(newName[i] + " has no readable name"); }
332 }
333 Collections.sort(entries);
334 buildFile(file, entries);
335 }
336 private static void buildFilesForRecoveryTemplates(
337 String indexFilename,
338 String templatesFilename,
339 char[] newTerminalIndex,
340 char[] newNonTerminalIndex,
341 String [] newName,
342 char[] newLhs,
343 String [] tokens) {
344
345 int[] newReverse = computeReverseTable(newTerminalIndex, newNonTerminalIndex, newName);
346
347 char[] newRecoveyTemplatesIndex = new char[newNonTerminalIndex.length];
348 char[] newRecoveyTemplates = new char[newNonTerminalIndex.length];
349 int newRecoveyTemplatesPtr = 0;
350
351 for (int i = 0; i < tokens.length; i = i + 3) {
352 if("3".equals(tokens[i])) { int length = newRecoveyTemplates.length;
354 if(length == newRecoveyTemplatesPtr + 1) {
355 System.arraycopy(newRecoveyTemplates, 0, newRecoveyTemplates = new char[length * 2], 0, length);
356 }
357 newRecoveyTemplates[newRecoveyTemplatesPtr++] = 0;
358
359 int index = newLhs[Integer.parseInt(tokens[i + 1])];
360
361 newRecoveyTemplatesIndex[index] = (char)newRecoveyTemplatesPtr;
362
363 String token = tokens[i + 2].trim();
364 java.util.StringTokenizer st = new java.util.StringTokenizer (new String (token), " "); String [] terminalNames = new String [st.countTokens()];
366 int t = 0;
367 while (st.hasMoreTokens()) {
368 terminalNames[t++] = st.nextToken();
369 }
370
371 for (int j = 0; j < terminalNames.length; j++) {
372 int symbol = getSymbol(terminalNames[j], newName, newReverse);
373 if(symbol > -1) {
374 length = newRecoveyTemplates.length;
375 if(length == newRecoveyTemplatesPtr + 1) {
376 System.arraycopy(newRecoveyTemplates, 0, newRecoveyTemplates = new char[length * 2], 0, length);
377 }
378 newRecoveyTemplates[newRecoveyTemplatesPtr++] = (char)symbol;
379 }
380 }
381 }
382 }
383 newRecoveyTemplates[newRecoveyTemplatesPtr++] = 0;
384 System.arraycopy(newRecoveyTemplates, 0, newRecoveyTemplates = new char[newRecoveyTemplatesPtr], 0, newRecoveyTemplatesPtr);
385
386 buildFileForTable(indexFilename, newRecoveyTemplatesIndex);
387 buildFileForTable(templatesFilename, newRecoveyTemplates);
388 }
389 private static void buildFilesForStatementsRecoveryFilter(
390 String filename,
391 char[] newNonTerminalIndex,
392 char[] newLhs,
393 String [] tokens) {
394
395 char[] newStatementsRecoveryFilter = new char[newNonTerminalIndex.length];
396
397 for (int i = 0; i < tokens.length; i = i + 3) {
398 if("4".equals(tokens[i])) { int index = newLhs[Integer.parseInt(tokens[i + 1])];
400
401 newStatementsRecoveryFilter[index] = 1;
402 }
403 }
404 buildFileForTable(filename, newStatementsRecoveryFilter);
405 }
406 private static void buildFileForCompliance(
407 String file,
408 int length,
409 String [] tokens) {
410
411 byte[] result = new byte[length * 8];
412
413 for (int i = 0; i < tokens.length; i = i + 3) {
414 if("2".equals(tokens[i])) { int index = Integer.parseInt(tokens[i + 1]);
416 String token = tokens[i + 2].trim();
417 long compliance = 0;
418 if("1.4".equals(token)) { compliance = ClassFileConstants.JDK1_4;
420 } else if("1.5".equals(token)) { compliance = ClassFileConstants.JDK1_5;
422 } else if("recovery".equals(token)) { compliance = ClassFileConstants.JDK_DEFERRED;
424 }
425
426 int j = index * 8;
427 result[j] = (byte)(compliance >>> 56);
428 result[j + 1] = (byte)(compliance >>> 48);
429 result[j + 2] = (byte)(compliance >>> 40);
430 result[j + 3] = (byte)(compliance >>> 32);
431 result[j + 4] = (byte)(compliance >>> 24);
432 result[j + 5] = (byte)(compliance >>> 16);
433 result[j + 6] = (byte)(compliance >>> 8);
434 result[j + 7] = (byte)(compliance);
435 }
436 }
437
438 buildFileForTable(file, result);
439 }
440 private final static void buildFileForTable(String filename, byte[] bytes) {
441 java.io.FileOutputStream stream = null;
442 try {
443 stream = new java.io.FileOutputStream (filename);
444 stream.write(bytes);
445 } catch(IOException e) {
446 } finally {
448 if (stream != null) {
449 try {
450 stream.close();
451 } catch (IOException e) {
452 }
454 }
455 }
456 System.out.println(filename + " creation complete"); }
458 private final static void buildFileForTable(String filename, char[] chars) {
459 byte[] bytes = new byte[chars.length * 2];
460 for (int i = 0; i < chars.length; i++) {
461 bytes[2 * i] = (byte) (chars[i] >>> 8);
462 bytes[2 * i + 1] = (byte) (chars[i] & 0xFF);
463 }
464
465 java.io.FileOutputStream stream = null;
466 try {
467 stream = new java.io.FileOutputStream (filename);
468 stream.write(bytes);
469 } catch(IOException e) {
470 } finally {
472 if (stream != null) {
473 try {
474 stream.close();
475 } catch (IOException e) {
476 }
478 }
479 }
480 System.out.println(filename + " creation complete"); }
482 private final static byte[] buildFileOfByteFor(String filename, String tag, String [] tokens) {
483
484
486 int i = 0;
487 while (!tokens[i++].equals(tag)){}
489
491 byte[] bytes = new byte[tokens.length]; int ic = 0;
493 String token;
494 while (!(token = tokens[i++]).equals("}")) { int c = Integer.parseInt(token);
496 bytes[ic++] = (byte) c;
497 }
498
499 System.arraycopy(bytes, 0, bytes = new byte[ic], 0, ic);
501
502 buildFileForTable(filename, bytes);
503 return bytes;
504 }
505 private final static char[] buildFileOfIntFor(String filename, String tag, String [] tokens) {
506
507
509 int i = 0;
510 while (!tokens[i++].equals(tag)){}
512
514 char[] chars = new char[tokens.length]; int ic = 0;
516 String token;
517 while (!(token = tokens[i++]).equals("}")) { int c = Integer.parseInt(token);
519 chars[ic++] = (char) c;
520 }
521
522 System.arraycopy(chars, 0, chars = new char[ic], 0, ic);
524
525 buildFileForTable(filename, chars);
526 return chars;
527 }
528 private final static void buildFileOfShortFor(String filename, String tag, String [] tokens) {
529
530
532 int i = 0;
533 while (!tokens[i++].equals(tag)){}
535
537 char[] chars = new char[tokens.length]; int ic = 0;
539 String token;
540 while (!(token = tokens[i++]).equals("}")) { int c = Integer.parseInt(token);
542 chars[ic++] = (char) (c + 32768);
543 }
544
545 System.arraycopy(chars, 0, chars = new char[ic], 0, ic);
547
548 buildFileForTable(filename, chars);
549 }
550 public final static void buildFilesFromLPG(String dataFilename, String dataFilename2) {
551
552
554
557 char[] contents = CharOperation.NO_CHAR;
559 try {
560 contents = Util.getFileCharContent(new File(dataFilename), null);
561 } catch (IOException ex) {
562 System.out.println(Messages.parser_incorrectPath);
563 return;
564 }
565 java.util.StringTokenizer st =
566 new java.util.StringTokenizer (new String (contents), " \t\n\r[]={,;"); String [] tokens = new String [st.countTokens()];
568 int j = 0;
569 while (st.hasMoreTokens()) {
570 tokens[j++] = st.nextToken();
571 }
572 final String prefix = FILEPREFIX;
573 int i = 0;
574
575 char[] newLhs = buildFileOfIntFor(prefix + (++i) + ".rsc", "lhs", tokens); buildFileOfShortFor(prefix + (++i) + ".rsc", "check_table", tokens); buildFileOfIntFor(prefix + (++i) + ".rsc", "asb", tokens); buildFileOfIntFor(prefix + (++i) + ".rsc", "asr", tokens); buildFileOfIntFor(prefix + (++i) + ".rsc", "nasb", tokens); buildFileOfIntFor(prefix + (++i) + ".rsc", "nasr", tokens); char[] newTerminalIndex = buildFileOfIntFor(prefix + (++i) + ".rsc", "terminal_index", tokens); char[] newNonTerminalIndex = buildFileOfIntFor(prefix + (++i) + ".rsc", "non_terminal_index", tokens); buildFileOfIntFor(prefix + (++i) + ".rsc", "term_action", tokens);
585 buildFileOfIntFor(prefix + (++i) + ".rsc", "scope_prefix", tokens); buildFileOfIntFor(prefix + (++i) + ".rsc", "scope_suffix", tokens); buildFileOfIntFor(prefix + (++i) + ".rsc", "scope_lhs", tokens); buildFileOfIntFor(prefix + (++i) + ".rsc", "scope_state_set", tokens); buildFileOfIntFor(prefix + (++i) + ".rsc", "scope_rhs", tokens); buildFileOfIntFor(prefix + (++i) + ".rsc", "scope_state", tokens); buildFileOfIntFor(prefix + (++i) + ".rsc", "in_symb", tokens);
593 byte[] newRhs = buildFileOfByteFor(prefix + (++i) + ".rsc", "rhs", tokens); buildFileOfByteFor(prefix + (++i) + ".rsc", "term_check", tokens); buildFileOfByteFor(prefix + (++i) + ".rsc", "scope_la", tokens);
597 String [] newName = buildFileForName(prefix + (++i) + ".rsc", new String (contents));
599 contents = CharOperation.NO_CHAR;
600 try {
601 contents = Util.getFileCharContent(new File(dataFilename2), null);
602 } catch (IOException ex) {
603 System.out.println(Messages.parser_incorrectPath);
604 return;
605 }
606 st = new java.util.StringTokenizer (new String (contents), "\t\n\r#"); tokens = new String [st.countTokens()];
608 j = 0;
609 while (st.hasMoreTokens()) {
610 tokens[j++] = st.nextToken();
611 }
612
613 buildFileForCompliance(prefix + (++i) + ".rsc", newRhs.length, tokens); buildFileForReadableName(READABLE_NAMES_FILE+".properties", newLhs, newNonTerminalIndex, newName, tokens);
616 buildFilesForRecoveryTemplates(
617 prefix + (++i) + ".rsc", prefix + (++i) + ".rsc", newTerminalIndex,
620 newNonTerminalIndex,
621 newName,
622 newLhs,
623 tokens);
624
625 buildFilesForStatementsRecoveryFilter(
626 prefix + (++i) + ".rsc", newNonTerminalIndex,
628 newLhs,
629 tokens);
630
631
632 System.out.println(Messages.parser_moveFiles);
633 }
634 public static int in_symbol(int state) {
635 return in_symb[original_state(state)];
636 }
637 public final static void initTables() throws java.io.IOException {
638
639 final String prefix = FILEPREFIX;
640 int i = 0;
641 lhs = readTable(prefix + (++i) + ".rsc"); char[] chars = readTable(prefix + (++i) + ".rsc"); check_table = new short[chars.length];
644 for (int c = chars.length; c-- > 0;) {
645 check_table[c] = (short) (chars[c] - 32768);
646 }
647 asb = readTable(prefix + (++i) + ".rsc"); asr = readTable(prefix + (++i) + ".rsc"); nasb = readTable(prefix + (++i) + ".rsc"); nasr = readTable(prefix + (++i) + ".rsc"); terminal_index = readTable(prefix + (++i) + ".rsc"); non_terminal_index = readTable(prefix + (++i) + ".rsc"); term_action = readTable(prefix + (++i) + ".rsc");
655 scope_prefix = readTable(prefix + (++i) + ".rsc"); scope_suffix = readTable(prefix + (++i) + ".rsc"); scope_lhs = readTable(prefix + (++i) + ".rsc"); scope_state_set = readTable(prefix + (++i) + ".rsc"); scope_rhs = readTable(prefix + (++i) + ".rsc"); scope_state = readTable(prefix + (++i) + ".rsc"); in_symb = readTable(prefix + (++i) + ".rsc");
663 rhs = readByteTable(prefix + (++i) + ".rsc"); term_check = readByteTable(prefix + (++i) + ".rsc"); scope_la = readByteTable(prefix + (++i) + ".rsc");
667 name = readNameTable(prefix + (++i) + ".rsc");
669 rules_compliance = readLongTable(prefix + (++i) + ".rsc");
671 readableName = readReadableNameTable(READABLE_NAMES_FILE_NAME);
672
673 reverse_index = computeReverseTable(terminal_index, non_terminal_index, name);
674
675 recovery_templates_index = readTable(prefix + (++i) + ".rsc"); recovery_templates = readTable(prefix + (++i) + ".rsc");
678 statements_recovery_filter = readTable(prefix + (++i) + ".rsc");
680 base_action = lhs;
681 }
682 public static int nasi(int state) {
683 return nasb[original_state(state)];
684 }
685 public static int ntAction(int state, int sym) {
686 return base_action[state + sym];
687 }
688 protected static int original_state(int state) {
689 return -base_check(state);
690 }
691 protected static int[] computeReverseTable(char[] newTerminalIndex, char[] newNonTerminalIndex, String [] newName) {
692 int[] newReverseTable = new int[newName.length];
693 for (int j = 0; j < newName.length; j++) {
694 found : {
695 for (int k = 0; k < newTerminalIndex.length; k++) {
696 if(newTerminalIndex[k] == j) {
697 newReverseTable[j] = k;
698 break found;
699 }
700 }
701 for (int k = 0; k < newNonTerminalIndex.length; k++) {
702 if(newNonTerminalIndex[k] == j) {
703 newReverseTable[j] = -k;
704 break found;
705 }
706 }
707 }
708 }
709 return newReverseTable;
710 }
711
712 private static int getSymbol(String terminalName, String [] newName, int[] newReverse) {
713 for (int j = 0; j < newName.length; j++) {
714 if(terminalName.equals(newName[j])) {
715 return newReverse[j];
716 }
717 }
718 return -1;
719 }
720
721 protected static byte[] readByteTable(String filename) throws java.io.IOException {
722
723
725 InputStream stream = Parser.class.getResourceAsStream(filename);
726 if (stream == null) {
727 throw new java.io.IOException (Messages.bind(Messages.parser_missingFile, filename));
728 }
729 byte[] bytes = null;
730 try {
731 stream = new BufferedInputStream(stream);
732 bytes = Util.getInputStreamAsByteArray(stream, -1);
733 } finally {
734 try {
735 stream.close();
736 } catch (IOException e) {
737 }
739 }
740 return bytes;
741 }
742
743 protected static String [] readNameTable(String filename) throws java.io.IOException {
744 char[] contents = readTable(filename);
745 char[][] nameAsChar = CharOperation.splitOn('\n', contents);
746
747 String [] result = new String [nameAsChar.length + 1];
748 result[0] = null;
749 for (int i = 0; i < nameAsChar.length; i++) {
750 result[i + 1] = new String (nameAsChar[i]);
751 }
752
753 return result;
754 }
755 protected static String [] readReadableNameTable(String filename) {
756 String [] result = new String [name.length];
757
758 ResourceBundle bundle;
759 try {
760 bundle = ResourceBundle.getBundle(filename, Locale.getDefault());
761 } catch(MissingResourceException e) {
762 System.out.println("Missing resource : " + filename.replace('.', '/') + ".properties for locale " + Locale.getDefault()); throw e;
764 }
765 for (int i = 0; i < NT_OFFSET + 1; i++) {
766 result[i] = name[i];
767 }
768 for (int i = NT_OFFSET; i < name.length; i++) {
769 try {
770 String n = bundle.getString(name[i]);
771 if(n != null && n.length() > 0) {
772 result[i] = n;
773 } else {
774 result[i] = name[i];
775 }
776 } catch(MissingResourceException e) {
777 result[i] = name[i];
778 }
779 }
780 return result;
781 }
782 protected static char[] readTable(String filename) throws java.io.IOException {
783
784
786 InputStream stream = Parser.class.getResourceAsStream(filename);
787 if (stream == null) {
788 throw new java.io.IOException (Messages.bind(Messages.parser_missingFile, filename));
789 }
790 byte[] bytes = null;
791 try {
792 stream = new BufferedInputStream(stream);
793 bytes = Util.getInputStreamAsByteArray(stream, -1);
794 } finally {
795 try {
796 stream.close();
797 } catch (IOException e) {
798 }
800 }
801
802 int length = bytes.length;
804 if ((length & 1) != 0)
805 throw new java.io.IOException (Messages.bind(Messages.parser_corruptedFile, filename));
806
807 char[] chars = new char[length / 2];
809 int i = 0;
810 int charIndex = 0;
811
812 while (true) {
813 chars[charIndex++] = (char) (((bytes[i++] & 0xFF) << 8) + (bytes[i++] & 0xFF));
814 if (i == length)
815 break;
816 }
817 return chars;
818 }
819 protected static long[] readLongTable(String filename) throws java.io.IOException {
820
821
823 InputStream stream = Parser.class.getResourceAsStream(filename);
824 if (stream == null) {
825 throw new java.io.IOException (Messages.bind(Messages.parser_missingFile, filename));
826 }
827 byte[] bytes = null;
828 try {
829 stream = new BufferedInputStream(stream);
830 bytes = Util.getInputStreamAsByteArray(stream, -1);
831 } finally {
832 try {
833 stream.close();
834 } catch (IOException e) {
835 }
837 }
838
839 int length = bytes.length;
841 if (length % 8 != 0)
842 throw new java.io.IOException (Messages.bind(Messages.parser_corruptedFile, filename));
843
844 long[] longs = new long[length / 8];
846 int i = 0;
847 int longIndex = 0;
848
849 while (true) {
850 longs[longIndex++] =
851 (((long) (bytes[i++] & 0xFF)) << 56)
852 + (((long) (bytes[i++] & 0xFF)) << 48)
853 + (((long) (bytes[i++] & 0xFF)) << 40)
854 + (((long) (bytes[i++] & 0xFF)) << 32)
855 + (((long) (bytes[i++] & 0xFF)) << 24)
856 + (((long) (bytes[i++] & 0xFF)) << 16)
857 + (((long) (bytes[i++] & 0xFF)) << 8)
858 + (bytes[i++] & 0xFF);
859
860 if (i == length)
861 break;
862 }
863 return longs;
864 }
865 public static int tAction(int state, int sym) {
866 return term_action[term_check[base_action[state]+sym] == sym ? base_action[state] + sym : base_action[state]];
867 }
868
869 public Parser(ProblemReporter problemReporter, boolean optimizeStringLiterals) {
870
871 this.problemReporter = problemReporter;
872 this.options = problemReporter.options;
873 this.optimizeStringLiterals = optimizeStringLiterals;
874 this.initializeScanner();
875 this.astLengthStack = new int[50];
876 this.expressionLengthStack = new int[30];
877 this.intStack = new int[50];
878 this.identifierStack = new char[30][];
879 this.identifierLengthStack = new int[30];
880 this.nestedMethod = new int[30];
881 this.realBlockStack = new int[30];
882 this.identifierPositionStack = new long[30];
883 this.variablesCounter = new int[30];
884
885 this.javadocParser = createJavadocParser();
887 }
888 protected void annotationRecoveryCheckPoint(int start, int end) {
889 if(this.lastCheckPoint > start && this.lastCheckPoint < end) {
890 this.lastCheckPoint = end + 1;
891 }
892 }
893 public void arrayInitializer(int length) {
894
898 ArrayInitializer ai = new ArrayInitializer();
899 if (length != 0) {
900 this.expressionPtr -= length;
901 System.arraycopy(this.expressionStack, this.expressionPtr + 1, ai.expressions = new Expression[length], 0, length);
902 }
903 pushOnExpressionStack(ai);
904 ai.sourceEnd = this.endStatementPosition;
906 ai.sourceStart = this.intStack[this.intPtr--];
907 }
908 protected void blockReal() {
909 this.realBlockStack[this.realBlockPtr]++;
912 }
913
917 public RecoveredElement buildInitialRecoveryState(){
918
919
922 this.lastCheckPoint = 0;
923 this.lastErrorEndPositionBeforeRecovery = this.scanner.currentPosition;
924
925 RecoveredElement element = null;
926 if (this.referenceContext instanceof CompilationUnitDeclaration){
927 element = new RecoveredUnit(this.compilationUnit, 0, this);
928
929
931 if (true){ this.compilationUnit.currentPackage = null;
933 this.compilationUnit.imports = null;
934 this.compilationUnit.types = null;
935 this.currentToken = 0;
936 this.listLength = 0;
937 this.listTypeParameterLength = 0;
938 this.endPosition = 0;
939 this.endStatementPosition = 0;
940 return element;
941 }
942 if (this.compilationUnit.currentPackage != null){
943 this.lastCheckPoint = this.compilationUnit.currentPackage.declarationSourceEnd+1;
944 }
945 if (this.compilationUnit.imports != null){
946 this.lastCheckPoint = this.compilationUnit.imports[this.compilationUnit.imports.length -1].declarationSourceEnd+1;
947 }
948 } else {
949 if (this.referenceContext instanceof AbstractMethodDeclaration){
950 element = new RecoveredMethod((AbstractMethodDeclaration) this.referenceContext, null, 0, this);
951 this.lastCheckPoint = ((AbstractMethodDeclaration) this.referenceContext).bodyStart;
952 if(this.statementRecoveryActivated) {
953 element = element.add(new Block(0), 0);
954 }
955 } else {
956
957 if (this.referenceContext instanceof TypeDeclaration){
958 TypeDeclaration type = (TypeDeclaration) this.referenceContext;
959 for (int i = 0; i < type.fields.length; i++){
960 FieldDeclaration field = type.fields[i];
961 if (field != null
962 && field.getKind() == AbstractVariableDeclaration.INITIALIZER
963 && field.declarationSourceStart <= this.scanner.initialPosition
964 && this.scanner.initialPosition <= field.declarationSourceEnd
965 && this.scanner.eofPosition <= field.declarationSourceEnd+1){
966 element = new RecoveredInitializer(field, null, 1, this);
967 this.lastCheckPoint = field.declarationSourceStart;
968 break;
969 }
970 }
971 }
972 }
973 }
974
975 if (element == null) return element;
976
977 for(int i = 0; i <= this.astPtr; i++){
978 ASTNode node = this.astStack[i];
979 if (node instanceof AbstractMethodDeclaration){
980 AbstractMethodDeclaration method = (AbstractMethodDeclaration) node;
981 if (method.declarationSourceEnd == 0){
982 element = element.add(method, 0);
983 this.lastCheckPoint = method.bodyStart;
984 } else {
985 element = element.add(method, 0);
986 this.lastCheckPoint = method.declarationSourceEnd + 1;
987 }
988 continue;
989 }
990 if (node instanceof Initializer){
991 Initializer initializer = (Initializer) node;
992 if (initializer.declarationSourceEnd == 0){
993 element = element.add(initializer, 1);
994 this.lastCheckPoint = initializer.sourceStart;
995 } else {
996 element = element.add(initializer, 0);
997 this.lastCheckPoint = initializer.declarationSourceEnd + 1;
998 }
999 continue;
1000 }
1001 if (node instanceof FieldDeclaration){
1002 FieldDeclaration field = (FieldDeclaration) node;
1003 if (field.declarationSourceEnd == 0){
1004 element = element.add(field, 0);
1005 if (field.initialization == null){
1006 this.lastCheckPoint = field.sourceEnd + 1;
1007 } else {
1008 this.lastCheckPoint = field.initialization.sourceEnd + 1;
1009 }
1010 } else {
1011 element = element.add(field, 0);
1012 this.lastCheckPoint = field.declarationSourceEnd + 1;
1013 }
1014 continue;
1015 }
1016 if (node instanceof TypeDeclaration){
1017 TypeDeclaration type = (TypeDeclaration) node;
1018 if (type.declarationSourceEnd == 0){
1019 element = element.add(type, 0);
1020 this.lastCheckPoint = type.bodyStart;
1021 } else {
1022 element = element.add(type, 0);
1023 this.lastCheckPoint = type.declarationSourceEnd + 1;
1024 }
1025 continue;
1026 }
1027 if (node instanceof ImportReference){
1028 ImportReference importRef = (ImportReference) node;
1029 element = element.add(importRef, 0);
1030 this.lastCheckPoint = importRef.declarationSourceEnd + 1;
1031 }
1032 if(this.statementRecoveryActivated) {
1033 if(node instanceof Block) {
1034 Block block = (Block) node;
1035 element = element.add(block, 0);
1036 this.lastCheckPoint = block.sourceEnd + 1;
1037 } else if(node instanceof LocalDeclaration) {
1038 LocalDeclaration statement = (LocalDeclaration) node;
1039 element = element.add(statement, 0);
1040 this.lastCheckPoint = statement.sourceEnd + 1;
1041 } else if(node instanceof Expression) {
1042 if(node instanceof Assignment ||
1043 node instanceof PrefixExpression ||
1044 node instanceof PostfixExpression ||
1045 node instanceof MessageSend ||
1046 node instanceof AllocationExpression) {
1047 Expression statement = (Expression) node;
1049 element = element.add(statement, 0);
1050 if(statement.statementEnd != -1) {
1051 this.lastCheckPoint = statement.statementEnd + 1;
1052 } else {
1053 this.lastCheckPoint = statement.sourceEnd + 1;
1054 }
1055 }
1056 } else if(node instanceof Statement) {
1057 Statement statement = (Statement) node;
1058 element = element.add(statement, 0);
1059 this.lastCheckPoint = statement.sourceEnd + 1;
1060 }
1061 }
1062 }
1063
1064 if (this.statementRecoveryActivated) {
1065 if (this.pendingRecoveredType != null &&
1066 this.scanner.startPosition - 1 <= this.pendingRecoveredType.declarationSourceEnd) {
1067 element = element.add(this.pendingRecoveredType, 0);
1069 this.lastCheckPoint = this.pendingRecoveredType.declarationSourceEnd + 1;
1070 this.pendingRecoveredType = null;
1071 }
1072 }
1073 return element;
1074}
1075
1076protected void checkAndSetModifiers(int flag){
1077
1083
1084 if ((this.modifiers & flag) != 0){ this.modifiers |= ExtraCompilerModifiers.AccAlternateModifierProblem;
1086 }
1087 this.modifiers |= flag;
1088
1089 if (this.modifiersSourceStart < 0) this.modifiersSourceStart = this.scanner.startPosition;
1090}
1091public void checkComment() {
1092
1093 if (!(this.diet && this.dietInt==0) && this.scanner.commentPtr >= 0) {
1095 flushCommentsDefinedPriorTo(this.endStatementPosition);
1096 }
1097
1098 int lastComment = this.scanner.commentPtr;
1099
1100 if (this.modifiersSourceStart >= 0) {
1101 while (lastComment >= 0 && this.scanner.commentStarts[lastComment] > this.modifiersSourceStart) lastComment--;
1103 }
1104 if (lastComment >= 0) {
1105 this.modifiersSourceStart = this.scanner.commentStarts[0];
1107
1108 while (lastComment >= 0 && this.scanner.commentStops[lastComment] < 0) lastComment--; if (lastComment >= 0 && this.javadocParser != null) {
1111 int commentEnd = this.scanner.commentStops[lastComment] - 1; this.javadocParser.reportProblems = this.currentElement == null || commentEnd > this.lastJavadocEnd;
1114 if (this.javadocParser.checkDeprecation(lastComment)) {
1115 checkAndSetModifiers(ClassFileConstants.AccDeprecated);
1116 }
1117 this.javadoc = this.javadocParser.docComment; if (currentElement == null) this.lastJavadocEnd = commentEnd;
1119 }
1120 }
1121}
1122protected void checkNonNLSAfterBodyEnd(int declarationEnd){
1123 if(this.scanner.currentPosition - 1 <= declarationEnd) {
1124 this.scanner.eofPosition = declarationEnd < Integer.MAX_VALUE ? declarationEnd + 1 : declarationEnd;
1125 try {
1126 while(this.scanner.getNextToken() != TokenNameEOF){}
1127 } catch (InvalidInputException e) {
1128 }
1130 }
1131}
1132protected void classInstanceCreation(boolean isQualified) {
1133
1135
1138 AllocationExpression alloc;
1139 int length;
1140 if (((length = this.astLengthStack[this.astLengthPtr--]) == 1)
1141 && (this.astStack[this.astPtr] == null)) {
1142 this.astPtr--;
1144 if (isQualified) {
1145 alloc = new QualifiedAllocationExpression();
1146 } else {
1147 alloc = new AllocationExpression();
1148 }
1149 alloc.sourceEnd = this.endPosition;
1151 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
1152 this.expressionPtr -= length;
1153 System.arraycopy(
1154 this.expressionStack,
1155 this.expressionPtr + 1,
1156 alloc.arguments = new Expression[length],
1157 0,
1158 length);
1159 }
1160 alloc.type = getTypeReference(0);
1161
1162 alloc.sourceStart = this.intStack[this.intPtr--];
1165 pushOnExpressionStack(alloc);
1166 } else {
1167 dispatchDeclarationInto(length);
1168 TypeDeclaration anonymousTypeDeclaration = (TypeDeclaration)this.astStack[this.astPtr];
1169 anonymousTypeDeclaration.declarationSourceEnd = this.endStatementPosition;
1170 anonymousTypeDeclaration.bodyEnd = this.endStatementPosition;
1171 if (anonymousTypeDeclaration.allocation != null) {
1172 anonymousTypeDeclaration.allocation.sourceEnd = this.endStatementPosition;
1173 }
1174 if (length == 0 && !containsComment(anonymousTypeDeclaration.bodyStart, anonymousTypeDeclaration.bodyEnd)) {
1175 anonymousTypeDeclaration.bits |= ASTNode.UndocumentedEmptyBlock;
1176 }
1177 this.astPtr--;
1178 this.astLengthPtr--;
1179
1180 markInitializersWithLocalType(anonymousTypeDeclaration);
1182 }
1183}
1184protected void concatExpressionLists() {
1185 this.expressionLengthStack[--this.expressionLengthPtr]++;
1186}
1187protected void concatGenericsLists() {
1188 this.genericsLengthStack[this.genericsLengthPtr - 1] += this.genericsLengthStack[this.genericsLengthPtr--];
1189}
1190protected void concatNodeLists() {
1191
1203
1204 this.astLengthStack[this.astLengthPtr - 1] += this.astLengthStack[this.astLengthPtr--];
1205}
1206protected void consumeAdditionalBound() {
1207 pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));
1208}
1209protected void consumeAdditionalBound1() {
1210 }
1213protected void consumeAdditionalBoundList() {
1214 concatGenericsLists();
1215}
1216protected void consumeAdditionalBoundList1() {
1217 concatGenericsLists();
1218}
1219protected void consumeAllocationHeader() {
1220
1222
1225 if (this.currentElement == null){
1226 return; }
1228 if (this.currentToken == TokenNameLBRACE){
1229 TypeDeclaration anonymousType = new TypeDeclaration(this.compilationUnit.compilationResult);
1231 anonymousType.name = CharOperation.NO_CHAR;
1232 anonymousType.bits |= (ASTNode.IsAnonymousType|ASTNode.IsLocalType);
1233 anonymousType.sourceStart = this.intStack[this.intPtr--];
1234 anonymousType.sourceEnd = this.rParenPos; QualifiedAllocationExpression alloc = new QualifiedAllocationExpression(anonymousType);
1236 alloc.type = getTypeReference(0);
1237 alloc.sourceStart = anonymousType.sourceStart;
1238 alloc.sourceEnd = anonymousType.sourceEnd ;
1239 this.lastCheckPoint = anonymousType.bodyStart = this.scanner.currentPosition;
1240 this.currentElement = this.currentElement.add(anonymousType, 0);
1241 this.lastIgnoredToken = -1;
1242 this.currentToken = 0; return;
1244 }
1245 this.lastCheckPoint = this.scanner.startPosition; this.restartRecovery = true; }
1248protected void consumeAnnotationAsModifier() {
1249 Expression expression = this.expressionStack[this.expressionPtr];
1250 int sourceStart = expression.sourceStart;
1251 if (this.modifiersSourceStart < 0) {
1252 this.modifiersSourceStart = sourceStart;
1253 }
1254}
1255protected void consumeAnnotationName() {
1256 if(this.currentElement != null) {
1257 int start = this.intStack[this.intPtr];
1258 int end = (int) (this.identifierPositionStack[this.identifierPtr] & 0x00000000FFFFFFFFL);
1259 annotationRecoveryCheckPoint(start, end);
1260 }
1261 this.recordStringLiterals = false;
1262}
1263protected void consumeAnnotationTypeDeclaration() {
1264 int length;
1265 if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
1266 dispatchDeclarationInto(length);
1269 }
1270
1271 TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
1272
1273 markInitializersWithLocalType(typeDecl);
1275
1276 typeDecl.checkConstructors(this);
1278
1279 if (this.scanner.containsAssertKeyword) {
1281 typeDecl.bits |= ASTNode.ContainsAssertion;
1282 }
1283 typeDecl.addClinit();
1284 typeDecl.bodyEnd = this.endStatementPosition;
1285 if (length == 0 && !containsComment(typeDecl.bodyStart, typeDecl.bodyEnd)) {
1286 typeDecl.bits |= ASTNode.UndocumentedEmptyBlock;
1287 }
1288 typeDecl.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
1289}
1290protected void consumeAnnotationTypeDeclarationHeader() {
1291 if (this.currentElement != null) {
1292 this.restartRecovery = true; }
1294 this.scanner.commentPtr = -1;
1296}
1297protected void consumeAnnotationTypeDeclarationHeaderName() {
1298 TypeDeclaration annotationTypeDeclaration = new TypeDeclaration(this.compilationUnit.compilationResult);
1301 if (this.nestedMethod[this.nestedType] == 0) {
1302 if (this.nestedType != 0) {
1303 annotationTypeDeclaration.bits |= ASTNode.IsMemberType;
1304 }
1305 } else {
1306 annotationTypeDeclaration.bits |= ASTNode.IsLocalType;
1308 markEnclosingMemberWithLocalType();
1309 blockReal();
1310 }
1311
1312 long pos = this.identifierPositionStack[this.identifierPtr];
1314 annotationTypeDeclaration.sourceEnd = (int) pos;
1315 annotationTypeDeclaration.sourceStart = (int) (pos >>> 32);
1316 annotationTypeDeclaration.name = this.identifierStack[this.identifierPtr--];
1317 this.identifierLengthPtr--;
1318
1319 this.intPtr--; this.intPtr--;
1326 annotationTypeDeclaration.modifiersSourceStart = this.intStack[this.intPtr--];
1327 annotationTypeDeclaration.modifiers = this.intStack[this.intPtr--] | ClassFileConstants.AccAnnotation | ClassFileConstants.AccInterface;
1328 if (annotationTypeDeclaration.modifiersSourceStart >= 0) {
1329 annotationTypeDeclaration.declarationSourceStart = annotationTypeDeclaration.modifiersSourceStart;
1330 this.intPtr--; } else {
1332 int atPosition = this.intStack[this.intPtr--];
1333 annotationTypeDeclaration.declarationSourceStart = atPosition;
1335 }
1336
1337 if ((annotationTypeDeclaration.bits & ASTNode.IsMemberType) == 0 && (annotationTypeDeclaration.bits & ASTNode.IsLocalType) == 0) {
1339 if (this.compilationUnit != null && !CharOperation.equals(annotationTypeDeclaration.name, this.compilationUnit.getMainTypeName())) {
1340 annotationTypeDeclaration.bits |= ASTNode.IsSecondaryType;
1341 }
1342 }
1343
1344 int length;
1346 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
1347 System.arraycopy(
1348 this.expressionStack,
1349 (this.expressionPtr -= length) + 1,
1350 annotationTypeDeclaration.annotations = new Annotation[length],
1351 0,
1352 length);
1353 }
1354 annotationTypeDeclaration.bodyStart = annotationTypeDeclaration.sourceEnd + 1;
1355
1356 annotationTypeDeclaration.javadoc = this.javadoc;
1358 this.javadoc = null;
1359 pushOnAstStack(annotationTypeDeclaration);
1360 if(!this.statementRecoveryActivated &&
1361 options.sourceLevel < ClassFileConstants.JDK1_5 &&
1362 this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
1363 this.problemReporter().invalidUsageOfAnnotationDeclarations(annotationTypeDeclaration);
1364 }
1365
1366 if (this.currentElement != null){
1368 this.lastCheckPoint = annotationTypeDeclaration.bodyStart;
1369 this.currentElement = this.currentElement.add(annotationTypeDeclaration, 0);
1370 this.lastIgnoredToken = -1;
1371 }
1372}
1373protected void consumeAnnotationTypeMemberDeclaration() {
1374 AnnotationMethodDeclaration annotationTypeMemberDeclaration = (AnnotationMethodDeclaration) this.astStack[this.astPtr];
1376 annotationTypeMemberDeclaration.modifiers |= ExtraCompilerModifiers.AccSemicolonBody;
1377 int declarationEndPosition = flushCommentsDefinedPriorTo(this.endStatementPosition);
1380 annotationTypeMemberDeclaration.bodyStart = this.endStatementPosition;
1381 annotationTypeMemberDeclaration.bodyEnd = declarationEndPosition;
1382 annotationTypeMemberDeclaration.declarationSourceEnd = declarationEndPosition;
1383}
1384protected void consumeAnnotationTypeMemberDeclarations() {
1385 concatNodeLists();
1387}
1388protected void consumeArgumentList() {
1389 concatExpressionLists();
1391}
1392protected void consumeArguments() {
1393 pushOnIntStack(rParenPos);
1396}
1397protected void consumeArrayAccess(boolean unspecifiedReference) {
1398
1401
1402 Expression exp;
1404 if (unspecifiedReference) {
1405 exp =
1406 this.expressionStack[this.expressionPtr] =
1407 new ArrayReference(
1408 getUnspecifiedReferenceOptimized(),
1409 this.expressionStack[this.expressionPtr]);
1410 } else {
1411 this.expressionPtr--;
1412 this.expressionLengthPtr--;
1413 exp =
1414 this.expressionStack[this.expressionPtr] =
1415 new ArrayReference(
1416 this.expressionStack[this.expressionPtr],
1417 this.expressionStack[this.expressionPtr + 1]);
1418 }
1419 exp.sourceEnd = this.endStatementPosition;
1420}
1421protected void consumeArrayCreationExpressionWithInitializer() {
1422
1425 int length;
1426 ArrayAllocationExpression arrayAllocation = new ArrayAllocationExpression();
1427 this.expressionLengthPtr -- ;
1428 arrayAllocation.initializer = (ArrayInitializer) this.expressionStack[this.expressionPtr--];
1429
1430 arrayAllocation.type = getTypeReference(0);
1431 arrayAllocation.type.bits |= ASTNode.IgnoreRawTypeCheck; length = (this.expressionLengthStack[this.expressionLengthPtr--]);
1433 this.expressionPtr -= length ;
1434 System.arraycopy(
1435 this.expressionStack,
1436 this.expressionPtr+1,
1437 arrayAllocation.dimensions = new Expression[length],
1438 0,
1439 length);
1440 arrayAllocation.sourceStart = this.intStack[this.intPtr--];
1441 if (arrayAllocation.initializer == null) {
1442 arrayAllocation.sourceEnd = this.endStatementPosition;
1443 } else {
1444 arrayAllocation.sourceEnd = arrayAllocation.initializer.sourceEnd ;
1445 }
1446 pushOnExpressionStack(arrayAllocation);
1447}
1448protected void consumeArrayCreationExpressionWithoutInitializer() {
1449
1452 int length;
1453 ArrayAllocationExpression arrayAllocation = new ArrayAllocationExpression();
1454 arrayAllocation.type = getTypeReference(0);
1455 arrayAllocation.type.bits |= ASTNode.IgnoreRawTypeCheck; length = (this.expressionLengthStack[this.expressionLengthPtr--]);
1457 this.expressionPtr -= length ;
1458 System.arraycopy(
1459 this.expressionStack,
1460 this.expressionPtr+1,
1461 arrayAllocation.dimensions = new Expression[length],
1462 0,
1463 length);
1464 arrayAllocation.sourceStart = this.intStack[this.intPtr--];
1465 if (arrayAllocation.initializer == null) {
1466 arrayAllocation.sourceEnd = this.endStatementPosition;
1467 } else {
1468 arrayAllocation.sourceEnd = arrayAllocation.initializer.sourceEnd ;
1469 }
1470 pushOnExpressionStack(arrayAllocation);
1471}
1472protected void consumeArrayCreationHeader() {
1473 }
1475protected void consumeArrayInitializer() {
1476
1479 arrayInitializer(this.expressionLengthStack[this.expressionLengthPtr--]);
1480}
1481protected void consumeArrayTypeWithTypeArgumentsName() {
1482 this.genericsIdentifiersLengthStack[this.genericsIdentifiersLengthPtr] += this.identifierLengthStack[this.identifierLengthPtr];
1483 pushOnGenericsLengthStack(0); }
1485protected void consumeAssertStatement() {
1486 this.expressionLengthPtr-=2;
1488 pushOnAstStack(new AssertStatement(this.expressionStack[this.expressionPtr--], this.expressionStack[this.expressionPtr--], this.intStack[this.intPtr--]));
1489}
1490protected void consumeAssignment() {
1491
1494 int op = this.intStack[this.intPtr--] ;
1496 this.expressionPtr -- ; this.expressionLengthPtr -- ;
1497 this.expressionStack[this.expressionPtr] =
1498 (op != EQUAL ) ?
1499 new CompoundAssignment(
1500 this.expressionStack[this.expressionPtr] ,
1501 this.expressionStack[this.expressionPtr+1],
1502 op,
1503 this.scanner.startPosition - 1) :
1504 new Assignment(
1505 this.expressionStack[this.expressionPtr] ,
1506 this.expressionStack[this.expressionPtr+1],
1507 this.scanner.startPosition - 1);
1508
1509 if (this.pendingRecoveredType != null) {
1510 if (this.pendingRecoveredType.allocation != null &&
1514 this.scanner.startPosition - 1 <= this.pendingRecoveredType.declarationSourceEnd) {
1515 this.expressionStack[this.expressionPtr] = this.pendingRecoveredType.allocation;
1516 this.pendingRecoveredType = null;
1517 return;
1518 }
1519 this.pendingRecoveredType = null;
1520 }
1521}
1522protected void consumeAssignmentOperator(int pos) {
1523
1536 pushOnIntStack(pos);
1537}
1538protected void consumeBinaryExpression(int op) {
1539
1557
1559 this.expressionPtr--;
1560 this.expressionLengthPtr--;
1561 Expression expr1 = this.expressionStack[this.expressionPtr];
1562 Expression expr2 = this.expressionStack[this.expressionPtr + 1];
1563 switch(op) {
1564 case OR_OR :
1565 this.expressionStack[this.expressionPtr] =
1566 new OR_OR_Expression(
1567 expr1,
1568 expr2,
1569 op);
1570 break;
1571 case AND_AND :
1572 this.expressionStack[this.expressionPtr] =
1573 new AND_AND_Expression(
1574 expr1,
1575 expr2,
1576 op);
1577 break;
1578 case PLUS :
1579 if (this.optimizeStringLiterals) {
1581 if (expr1 instanceof StringLiteral) {
1582 if (expr2 instanceof CharLiteral) { this.expressionStack[this.expressionPtr] =
1584 ((StringLiteral) expr1).extendWith((CharLiteral) expr2);
1585 } else if (expr2 instanceof StringLiteral) { this.expressionStack[this.expressionPtr] =
1587 ((StringLiteral) expr1).extendWith((StringLiteral) expr2);
1588 } else {
1589 this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
1590 }
1591 } else if (expr1 instanceof CombinedBinaryExpression) {
1592 CombinedBinaryExpression cursor;
1593 if ((cursor = (CombinedBinaryExpression)expr1).arity <
1599 cursor.arityMax) {
1600 cursor.left = new BinaryExpression(cursor.left,
1601 cursor.right, PLUS);
1602 cursor.arity++;
1603 } else {
1604 cursor.left = new CombinedBinaryExpression(cursor.left,
1605 cursor.right, PLUS, cursor.arity);
1606 cursor.arity = 0;
1607 cursor.tuneArityMax();
1608 }
1609 cursor.right = expr2;
1610 cursor.sourceEnd = expr2.sourceEnd;
1611 this.expressionStack[this.expressionPtr] = cursor;
1612 } else if (expr1 instanceof BinaryExpression &&
1616 ((expr1.bits & ASTNode.OperatorMASK) >>
1621 ASTNode.OperatorSHIFT) == OperatorIds.PLUS) {
1622 this.expressionStack[this.expressionPtr] =
1623 new CombinedBinaryExpression(expr1, expr2, PLUS, 1);
1624 } else {
1625 this.expressionStack[this.expressionPtr] =
1626 new BinaryExpression(expr1, expr2, PLUS);
1627 }
1628 } else if (expr1 instanceof StringLiteral) {
1629 if (expr2 instanceof StringLiteral) {
1630 this.expressionStack[this.expressionPtr] =
1632 ((StringLiteral) expr1).extendsWith((StringLiteral) expr2);
1633 } else {
1634 this.expressionStack[this.expressionPtr] =
1636 new BinaryExpression(expr1, expr2, PLUS);
1637 }
1638 } else if (expr1 instanceof CombinedBinaryExpression) {
1639 CombinedBinaryExpression cursor;
1640 int numberOfParens = (expr1.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT;
1641 if ((cursor = (CombinedBinaryExpression)expr1).arity <
1643 cursor.arityMax) {
1644 cursor.left = new BinaryExpression(cursor.left,
1645 cursor.right, PLUS);
1646 if (numberOfParens != 0) {
1647 cursor.bits &= ~ASTNode.ParenthesizedMASK;
1649 cursor.left.bits &= ~ASTNode.ParenthesizedMASK;
1650 cursor.left.bits |= numberOfParens << ASTNode.ParenthesizedSHIFT;
1651 }
1652 cursor.arity++;
1653 } else {
1654 cursor.left = new CombinedBinaryExpression(cursor.left,
1655 cursor.right, PLUS, cursor.arity);
1656 if (numberOfParens != 0) {
1657 cursor.bits &= ~ASTNode.ParenthesizedMASK;
1659 cursor.left.bits &= ~ASTNode.ParenthesizedMASK;
1660 cursor.left.bits |= numberOfParens << ASTNode.ParenthesizedSHIFT;
1661 }
1662 cursor.arity = 0;
1663 cursor.tuneArityMax();
1664 }
1665 cursor.right = expr2;
1666 cursor.sourceEnd = expr2.sourceEnd;
1667 this.expressionStack[this.expressionPtr] = cursor;
1671 } else if (expr1 instanceof BinaryExpression
1672 && ((expr1.bits & ASTNode.OperatorMASK) >>
1673 ASTNode.OperatorSHIFT) == OperatorIds.PLUS) {
1674 this.expressionStack[this.expressionPtr] =
1676 new CombinedBinaryExpression(expr1, expr2, PLUS, 1);
1677 } else {
1678 this.expressionStack[this.expressionPtr] =
1679 new BinaryExpression(expr1, expr2, PLUS);
1680 }
1681 break;
1682 case LESS :
1683 this.intPtr--;
1684 this.expressionStack[this.expressionPtr] =
1685 new BinaryExpression(
1686 expr1,
1687 expr2,
1688 op);
1689 break;
1690 default :
1691 this.expressionStack[this.expressionPtr] =
1692 new BinaryExpression(
1693 expr1,
1694 expr2,
1695 op);
1696 }
1697}
1698
1701protected void consumeBinaryExpressionWithName(int op) {
1702 pushOnExpressionStack(getUnspecifiedReferenceOptimized());
1703 this.expressionPtr--;
1704 this.expressionLengthPtr--;
1705
1748 Expression expr1 = this.expressionStack[this.expressionPtr + 1];
1749 Expression expr2 = this.expressionStack[this.expressionPtr];
1750 switch(op) {
1753 case OR_OR :
1754 this.expressionStack[this.expressionPtr] =
1755 new OR_OR_Expression(
1756 expr1,
1757 expr2,
1758 op);
1759 break;
1760 case AND_AND :
1761 this.expressionStack[this.expressionPtr] =
1762 new AND_AND_Expression(
1763 expr1,
1764 expr2,
1765 op);
1766 break;
1767 case PLUS :
1768 if (this.optimizeStringLiterals) {
1770 if (expr1 instanceof StringLiteral) {
1771 if (expr2 instanceof CharLiteral) { this.expressionStack[this.expressionPtr] =
1773 ((StringLiteral) expr1).extendWith((CharLiteral) expr2);
1774 } else if (expr2 instanceof StringLiteral) { this.expressionStack[this.expressionPtr] =
1776 ((StringLiteral) expr1).extendWith((StringLiteral) expr2);
1777 } else {
1778 this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
1779 }
1780 } else {
1781 this.expressionStack[this.expressionPtr] = new BinaryExpression(expr1, expr2, PLUS);
1782 }
1783 } else if (expr1 instanceof StringLiteral) {
1784 if (expr2 instanceof StringLiteral) {
1785 this.expressionStack[this.expressionPtr] =
1787 ((StringLiteral) expr1).extendsWith((StringLiteral) expr2);
1788 } else {
1789 this.expressionStack[this.expressionPtr] =
1790 new BinaryExpression(
1791 expr1,
1792 expr2,
1793 op);
1794 }
1795 } else {
1796 this.expressionStack[this.expressionPtr] =
1797 new BinaryExpression(
1798 expr1,
1799 expr2,
1800 op);
1801 }
1802 break;
1803 case LESS :
1804 this.intPtr--;
1805 this.expressionStack[this.expressionPtr] =
1806 new BinaryExpression(
1807 expr1,
1808 expr2,
1809 op);
1810 break;
1811 default :
1812 this.expressionStack[this.expressionPtr] =
1813 new BinaryExpression(
1814 expr1,
1815 expr2,
1816 op);
1817 }
1818}
1819protected void consumeBlock() {
1820
1823 int statementsLength = this.astLengthStack[this.astLengthPtr--];
1824 Block block;
1825 if (statementsLength == 0) { block = new Block(0);
1827 block.sourceStart = this.intStack[this.intPtr--];
1828 block.sourceEnd = this.endStatementPosition;
1829 if (!containsComment(block.sourceStart, block.sourceEnd)) {
1831 block.bits |= ASTNode.UndocumentedEmptyBlock;
1832 }
1833 this.realBlockPtr--; } else {
1835 block = new Block(this.realBlockStack[this.realBlockPtr--]);
1836 this.astPtr -= statementsLength;
1837 System.arraycopy(
1838 this.astStack,
1839 this.astPtr + 1,
1840 block.statements = new Statement[statementsLength],
1841 0,
1842 statementsLength);
1843 block.sourceStart = this.intStack[this.intPtr--];
1844 block.sourceEnd = this.endStatementPosition;
1845 }
1846 pushOnAstStack(block);
1847}
1848protected void consumeBlockStatements() {
1849 concatNodeLists();
1851}
1852protected void consumeCaseLabel() {
1853 this.expressionLengthPtr--;
1855 Expression expression = this.expressionStack[this.expressionPtr--];
1856 pushOnAstStack(new CaseStatement(expression, expression.sourceEnd, this.intStack[this.intPtr--]));
1857}
1858protected void consumeCastExpressionLL1() {
1859
1862
1864 Expression cast,exp;
1865 this.expressionPtr--;
1866 this.expressionStack[this.expressionPtr] =
1867 cast = new CastExpression(
1868 exp=this.expressionStack[this.expressionPtr+1] ,
1869 getTypeReference(this.expressionStack[this.expressionPtr]));
1870 this.expressionLengthPtr -- ;
1871 updateSourcePosition(cast);
1872 cast.sourceEnd=exp.sourceEnd;
1873}
1874protected void consumeCastExpressionWithGenericsArray() {
1875
1877 Expression exp, cast, castType;
1878 int end = this.intStack[this.intPtr--];
1879
1880 int dim = this.intStack[this.intPtr--];
1881 pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
1882
1883 this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = getTypeReference(dim));
1884 intPtr--;
1885 castType.sourceEnd = end - 1;
1886 castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;
1887 cast.sourceEnd = exp.sourceEnd;
1888}
1889protected void consumeCastExpressionWithNameArray() {
1890
1892 Expression exp, cast, castType;
1893 int end = this.intStack[this.intPtr--];
1894
1895 pushOnGenericsLengthStack(0);
1897 pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
1898
1899 this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = getTypeReference(this.intStack[this.intPtr--]));
1900 castType.sourceEnd = end - 1;
1901 castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;
1902 cast.sourceEnd = exp.sourceEnd;
1903}
1904protected void consumeCastExpressionWithPrimitiveType() {
1905
1907
1909
1911 Expression exp, cast, castType;
1912 int end = this.intStack[this.intPtr--];
1913 this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = getTypeReference(this.intStack[this.intPtr--]));
1914 castType.sourceEnd = end - 1;
1915 castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;
1916 cast.sourceEnd = exp.sourceEnd;
1917}
1918protected ParameterizedQualifiedTypeReference computeQualifiedGenericsFromRightSide(TypeReference rightSide, int dim) {
1919 int nameSize = this.identifierLengthStack[this.identifierLengthPtr];
1920 int tokensSize = nameSize;
1921 if (rightSide instanceof ParameterizedSingleTypeReference) {
1922 tokensSize ++;
1923 } else if (rightSide instanceof SingleTypeReference) {
1924 tokensSize ++;
1925 } else if (rightSide instanceof ParameterizedQualifiedTypeReference) {
1926 tokensSize += ((QualifiedTypeReference) rightSide).tokens.length;
1927 } else if (rightSide instanceof QualifiedTypeReference) {
1928 tokensSize += ((QualifiedTypeReference) rightSide).tokens.length;
1929 }
1930 TypeReference[][] typeArguments = new TypeReference[tokensSize][];
1931 char[][] tokens = new char[tokensSize][];
1932 long[] positions = new long[tokensSize];
1933 if (rightSide instanceof ParameterizedSingleTypeReference) {
1934 ParameterizedSingleTypeReference singleParameterizedTypeReference = (ParameterizedSingleTypeReference) rightSide;
1935 tokens[nameSize] = singleParameterizedTypeReference.token;
1936 positions[nameSize] = (((long) singleParameterizedTypeReference.sourceStart) << 32) + singleParameterizedTypeReference.sourceEnd;
1937 typeArguments[nameSize] = singleParameterizedTypeReference.typeArguments;
1938 } else if (rightSide instanceof SingleTypeReference) {
1939 SingleTypeReference singleTypeReference = (SingleTypeReference) rightSide;
1940 tokens[nameSize] = singleTypeReference.token;
1941 positions[nameSize] = (((long) singleTypeReference.sourceStart) << 32) + singleTypeReference.sourceEnd;
1942 } else if (rightSide instanceof ParameterizedQualifiedTypeReference) {
1943 ParameterizedQualifiedTypeReference parameterizedTypeReference = (ParameterizedQualifiedTypeReference) rightSide;
1944 TypeReference[][] rightSideTypeArguments = parameterizedTypeReference.typeArguments;
1945 System.arraycopy(rightSideTypeArguments, 0, typeArguments, nameSize, rightSideTypeArguments.length);
1946 char[][] rightSideTokens = parameterizedTypeReference.tokens;
1947 System.arraycopy(rightSideTokens, 0, tokens, nameSize, rightSideTokens.length);
1948 long[] rightSidePositions = parameterizedTypeReference.sourcePositions;
1949 System.arraycopy(rightSidePositions, 0, positions, nameSize, rightSidePositions.length);
1950 } else if (rightSide instanceof QualifiedTypeReference) {
1951 QualifiedTypeReference qualifiedTypeReference = (QualifiedTypeReference) rightSide;
1952 char[][] rightSideTokens = qualifiedTypeReference.tokens;
1953 System.arraycopy(rightSideTokens, 0, tokens, nameSize, rightSideTokens.length);
1954 long[] rightSidePositions = qualifiedTypeReference.sourcePositions;
1955 System.arraycopy(rightSidePositions, 0, positions, nameSize, rightSidePositions.length);
1956 }
1957
1958 int currentTypeArgumentsLength = this.genericsLengthStack[this.genericsLengthPtr--];
1959 TypeReference[] currentTypeArguments = new TypeReference[currentTypeArgumentsLength];
1960 this.genericsPtr -= currentTypeArgumentsLength;
1961 System.arraycopy(this.genericsStack, this.genericsPtr + 1, currentTypeArguments, 0, currentTypeArgumentsLength);
1962
1963 if (nameSize == 1) {
1964 tokens[0] = this.identifierStack[this.identifierPtr];
1965 positions[0] = this.identifierPositionStack[this.identifierPtr--];
1966 typeArguments[0] = currentTypeArguments;
1967 } else {
1968 this.identifierPtr -= nameSize;
1969 System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, 0, nameSize);
1970 System.arraycopy(this.identifierPositionStack, this.identifierPtr + 1, positions, 0, nameSize);
1971 typeArguments[nameSize - 1] = currentTypeArguments;
1972 }
1973 this.identifierLengthPtr--;
1974 return new ParameterizedQualifiedTypeReference(tokens, typeArguments, dim, positions);
1975}
1976protected void consumeCastExpressionWithQualifiedGenericsArray() {
1977 Expression exp, cast, castType;
1979 int end = this.intStack[this.intPtr--];
1980
1981 int dim = this.intStack[this.intPtr--];
1982 TypeReference rightSide = getTypeReference(0);
1983
1984 ParameterizedQualifiedTypeReference qualifiedParameterizedTypeReference = computeQualifiedGenericsFromRightSide(rightSide, dim);
1985 intPtr--;
1986 this.expressionStack[this.expressionPtr] = cast = new CastExpression(exp = this.expressionStack[this.expressionPtr], castType = qualifiedParameterizedTypeReference);
1987 castType.sourceEnd = end - 1;
1988 castType.sourceStart = (cast.sourceStart = this.intStack[this.intPtr--]) + 1;
1989 cast.sourceEnd = exp.sourceEnd;
1990}
1991protected void consumeCatches() {
1992 optimizedConcatNodeLists();
1994}
1995protected void consumeCatchHeader() {
1996
1998 if (this.currentElement == null){
1999 return; }
2001 if (!(this.currentElement instanceof RecoveredBlock)){
2003 if(!(this.currentElement instanceof RecoveredMethod)) {
2004 return;
2005 }
2006 RecoveredMethod rMethod = (RecoveredMethod) this.currentElement;
2007 if(!(rMethod.methodBody == null && rMethod.bracketBalance > 0)) {
2008 return;
2009 }
2010 }
2011
2012 Argument arg = (Argument)this.astStack[this.astPtr--];
2013 LocalDeclaration localDeclaration = new LocalDeclaration(arg.name, arg.sourceStart, arg.sourceEnd);
2015 localDeclaration.type = arg.type;
2016 localDeclaration.declarationSourceStart = arg.declarationSourceStart;
2017 localDeclaration.declarationSourceEnd = arg.declarationSourceEnd;
2018
2019 this.currentElement = this.currentElement.add(localDeclaration, 0);
2020 this.lastCheckPoint = this.scanner.startPosition; this.restartRecovery = true; this.lastIgnoredToken = -1;
2023}
2024protected void consumeClassBodyDeclaration() {
2025 this.nestedMethod[this.nestedType]--;
2029 Block block = (Block) this.astStack[this.astPtr];
2030 if (this.diet) block.bits &= ~ASTNode.UndocumentedEmptyBlock; Initializer initializer = new Initializer(block, 0);
2032 this.intPtr--; initializer.bodyStart = this.intStack[this.intPtr--];
2034 this.realBlockPtr--; int javadocCommentStart = this.intStack[this.intPtr--];
2036 if (javadocCommentStart != -1) {
2037 initializer.declarationSourceStart = javadocCommentStart;
2038 initializer.javadoc = this.javadoc;
2039 this.javadoc = null;
2040 }
2041 this.astStack[this.astPtr] = initializer;
2042 initializer.bodyEnd = this.endPosition;
2043 initializer.sourceEnd = this.endStatementPosition;
2044 initializer.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
2045}
2046protected void consumeClassBodyDeclarations() {
2047 concatNodeLists();
2049}
2050protected void consumeClassBodyDeclarationsopt() {
2051 this.nestedType-- ;
2053}
2054protected void consumeAnnotationTypeMemberDeclarationsopt() {
2055 this.nestedType-- ;
2056}
2057protected void consumeClassBodyopt() {
2058 pushOnAstStack(null);
2060 this.endPosition = this.rParenPos;
2061}
2062protected void consumeClassDeclaration() {
2063
2065 int length;
2066 if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
2067 dispatchDeclarationInto(length);
2070 }
2071
2072 TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
2073
2074 markInitializersWithLocalType(typeDecl);
2076
2077 boolean hasConstructor = typeDecl.checkConstructors(this);
2079
2080 if (!hasConstructor) {
2082 switch(TypeDeclaration.kind(typeDecl.modifiers)) {
2083 case TypeDeclaration.CLASS_DECL :
2084 case TypeDeclaration.ENUM_DECL :
2085 boolean insideFieldInitializer = false;
2086 if (this.diet) {
2087 for (int i = this.nestedType; i > 0; i--){
2088 if (this.variablesCounter[i] > 0) {
2089 insideFieldInitializer = true;
2090 break;
2091 }
2092 }
2093 }
2094 typeDecl.createDefaultConstructor(!this.diet || insideFieldInitializer, true);
2095 }
2096 }
2097 if (this.scanner.containsAssertKeyword) {
2099 typeDecl.bits |= ASTNode.ContainsAssertion;
2100 }
2101 typeDecl.addClinit();
2102 typeDecl.bodyEnd = this.endStatementPosition;
2103 if (length == 0 && !containsComment(typeDecl.bodyStart, typeDecl.bodyEnd)) {
2104 typeDecl.bits |= ASTNode.UndocumentedEmptyBlock;
2105 }
2106
2107 typeDecl.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
2108}
2109protected void consumeClassHeader() {
2110
2112 TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
2113 if (this.currentToken == TokenNameLBRACE) {
2114 typeDecl.bodyStart = this.scanner.currentPosition;
2115 }
2116 if (this.currentElement != null) {
2117 this.restartRecovery = true; }
2119 this.scanner.commentPtr = -1;
2121}
2122protected void consumeClassHeaderExtends() {
2123 TypeReference superClass = getTypeReference(0);
2126 TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
2128 typeDecl.superclass = superClass;
2129 superClass.bits |= ASTNode.IsSuperType;
2130 typeDecl.bodyStart = typeDecl.superclass.sourceEnd + 1;
2131 if (this.currentElement != null){
2133 this.lastCheckPoint = typeDecl.bodyStart;
2134 }
2135}
2136protected void consumeClassHeaderImplements() {
2137 int length = this.astLengthStack[this.astLengthPtr--];
2139 this.astPtr -= length;
2141 TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
2143 System.arraycopy(
2144 this.astStack,
2145 this.astPtr + 1,
2146 typeDecl.superInterfaces = new TypeReference[length],
2147 0,
2148 length);
2149 for (int i = 0, max = typeDecl.superInterfaces.length; i < max; i++) {
2150 typeDecl.superInterfaces[i].bits |= ASTNode.IsSuperType;
2151 }
2152 typeDecl.bodyStart = typeDecl.superInterfaces[length-1].sourceEnd + 1;
2153 this.listLength = 0; if (this.currentElement != null) { this.lastCheckPoint = typeDecl.bodyStart;
2157 }
2158}
2159protected void consumeClassHeaderName1() {
2160 TypeDeclaration typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
2162 if (this.nestedMethod[this.nestedType] == 0) {
2163 if (this.nestedType != 0) {
2164 typeDecl.bits |= ASTNode.IsMemberType;
2165 }
2166 } else {
2167 typeDecl.bits |= ASTNode.IsLocalType;
2169 markEnclosingMemberWithLocalType();
2170 blockReal();
2171 }
2172
2173 long pos = this.identifierPositionStack[this.identifierPtr];
2175 typeDecl.sourceEnd = (int) pos;
2176 typeDecl.sourceStart = (int) (pos >>> 32);
2177 typeDecl.name = this.identifierStack[this.identifierPtr--];
2178 this.identifierLengthPtr--;
2179
2180 typeDecl.declarationSourceStart = this.intStack[this.intPtr--];
2185 this.intPtr--;
2187 typeDecl.modifiersSourceStart = this.intStack[this.intPtr--];
2188 typeDecl.modifiers = this.intStack[this.intPtr--];
2189 if (typeDecl.modifiersSourceStart >= 0) {
2190 typeDecl.declarationSourceStart = typeDecl.modifiersSourceStart;
2191 }
2192
2193 if ((typeDecl.bits & ASTNode.IsMemberType) == 0 && (typeDecl.bits & ASTNode.IsLocalType) == 0) {
2195 if (this.compilationUnit != null && !CharOperation.equals(typeDecl.name, this.compilationUnit.getMainTypeName())) {
2196 typeDecl.bits |= ASTNode.IsSecondaryType;
2197 }
2198 }
2199
2200 int length;
2202 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
2203 System.arraycopy(
2204 this.expressionStack,
2205 (this.expressionPtr -= length) + 1,
2206 typeDecl.annotations = new Annotation[length],
2207 0,
2208 length);
2209 }
2210 typeDecl.bodyStart = typeDecl.sourceEnd + 1;
2211 pushOnAstStack(typeDecl);
2212
2213 this.listLength = 0; if (this.currentElement != null){
2216 this.lastCheckPoint = typeDecl.bodyStart;
2217 this.currentElement = this.currentElement.add(typeDecl, 0);
2218 this.lastIgnoredToken = -1;
2219 }
2220 typeDecl.javadoc = this.javadoc;
2222 this.javadoc = null;
2223}
2224protected void consumeTypeHeaderNameWithTypeParameters() {
2225 TypeDeclaration typeDecl = (TypeDeclaration)this.astStack[this.astPtr];
2228
2229 int length = this.genericsLengthStack[this.genericsLengthPtr--];
2231 this.genericsPtr -= length;
2232 System.arraycopy(this.genericsStack, this.genericsPtr + 1, typeDecl.typeParameters = new TypeParameter[length], 0, length);
2233
2234 typeDecl.bodyStart = typeDecl.typeParameters[length-1].declarationSourceEnd + 1;
2235
2236 this.listTypeParameterLength = 0;
2237
2238 if (this.currentElement != null) { RecoveredType recoveredType = (RecoveredType) this.currentElement;
2240 recoveredType.pendingTypeParameters = null;
2241
2242 this.lastCheckPoint = typeDecl.bodyStart;
2243 }
2244}
2245protected void consumeClassInstanceCreationExpression() {
2246 classInstanceCreation(false);
2248}
2249protected void consumeClassInstanceCreationExpressionName() {
2250 pushOnExpressionStack(getUnspecifiedReferenceOptimized());
2252}
2253protected void consumeClassInstanceCreationExpressionQualified() {
2254 classInstanceCreation(true);
2257
2258 this.expressionLengthPtr--;
2259 QualifiedAllocationExpression qae =
2260 (QualifiedAllocationExpression) this.expressionStack[this.expressionPtr--];
2261 qae.enclosingInstance = this.expressionStack[this.expressionPtr];
2262 this.expressionStack[this.expressionPtr] = qae;
2263 qae.sourceStart = qae.enclosingInstance.sourceStart;
2264}
2265protected void consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() {
2266
2269 QualifiedAllocationExpression alloc;
2270 int length;
2271 if (((length = this.astLengthStack[this.astLengthPtr--]) == 1) && (this.astStack[this.astPtr] == null)) {
2272 this.astPtr--;
2274 alloc = new QualifiedAllocationExpression();
2275 alloc.sourceEnd = this.endPosition;
2277 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
2278 this.expressionPtr -= length;
2279 System.arraycopy(
2280 this.expressionStack,
2281 this.expressionPtr + 1,
2282 alloc.arguments = new Expression[length],
2283 0,
2284 length);
2285 }
2286 alloc.type = getTypeReference(0);
2287
2288 length = this.genericsLengthStack[this.genericsLengthPtr--];
2289 this.genericsPtr -= length;
2290 System.arraycopy(this.genericsStack, this.genericsPtr + 1, alloc.typeArguments = new TypeReference[length], 0, length);
2291 intPtr--;
2292
2293 alloc.sourceStart = this.intStack[this.intPtr--];
2296 pushOnExpressionStack(alloc);
2297 } else {
2298 dispatchDeclarationInto(length);
2299 TypeDeclaration anonymousTypeDeclaration = (TypeDeclaration)this.astStack[this.astPtr];
2300 anonymousTypeDeclaration.declarationSourceEnd = this.endStatementPosition;
2301 anonymousTypeDeclaration.bodyEnd = this.endStatementPosition;
2302 if (length == 0 && !containsComment(anonymousTypeDeclaration.bodyStart, anonymousTypeDeclaration.bodyEnd)) {
2303 anonymousTypeDeclaration.bits |= ASTNode.UndocumentedEmptyBlock;
2304 }
2305 this.astPtr--;
2306 this.astLengthPtr--;
2307
2308 QualifiedAllocationExpression allocationExpression = anonymousTypeDeclaration.allocation;
2309 if (allocationExpression != null) {
2310 allocationExpression.sourceEnd = this.endStatementPosition;
2311 length = this.genericsLengthStack[this.genericsLengthPtr--];
2313 this.genericsPtr -= length;
2314 System.arraycopy(this.genericsStack, this.genericsPtr + 1, allocationExpression.typeArguments = new TypeReference[length], 0, length);
2315 allocationExpression.sourceStart = intStack[intPtr--];
2316 }
2317
2318 markInitializersWithLocalType(anonymousTypeDeclaration);
2320 }
2321
2322 this.expressionLengthPtr--;
2323 QualifiedAllocationExpression qae =
2324 (QualifiedAllocationExpression) this.expressionStack[this.expressionPtr--];
2325 qae.enclosingInstance = this.expressionStack[this.expressionPtr];
2326 this.expressionStack[this.expressionPtr] = qae;
2327 qae.sourceStart = qae.enclosingInstance.sourceStart;
2328}
2329protected void consumeClassInstanceCreationExpressionWithTypeArguments() {
2330 AllocationExpression alloc;
2332 int length;
2333 if (((length = this.astLengthStack[this.astLengthPtr--]) == 1)
2334 && (this.astStack[this.astPtr] == null)) {
2335 this.astPtr--;
2337 alloc = new AllocationExpression();
2338 alloc.sourceEnd = this.endPosition;
2340 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
2341 this.expressionPtr -= length;
2342 System.arraycopy(
2343 this.expressionStack,
2344 this.expressionPtr + 1,
2345 alloc.arguments = new Expression[length],
2346 0,
2347 length);
2348 }
2349 alloc.type = getTypeReference(0);
2350
2351 length = this.genericsLengthStack[this.genericsLengthPtr--];
2352 this.genericsPtr -= length;
2353 System.arraycopy(this.genericsStack, this.genericsPtr + 1, alloc.typeArguments = new TypeReference[length], 0, length);
2354 intPtr--;
2355
2356 alloc.sourceStart = this.intStack[this.intPtr--];
2359 pushOnExpressionStack(alloc);
2360 } else {
2361 dispatchDeclarationInto(length);
2362 TypeDeclaration anonymousTypeDeclaration = (TypeDeclaration)this.astStack[this.astPtr];
2363 anonymousTypeDeclaration.declarationSourceEnd = this.endStatementPosition;
2364 anonymousTypeDeclaration.bodyEnd = this.endStatementPosition;
2365 if (length == 0 && !containsComment(anonymousTypeDeclaration.bodyStart, anonymousTypeDeclaration.bodyEnd)) {
2366 anonymousTypeDeclaration.bits |= ASTNode.UndocumentedEmptyBlock;
2367 }
2368 this.astPtr--;
2369 this.astLengthPtr--;
2370
2371 QualifiedAllocationExpression allocationExpression = anonymousTypeDeclaration.allocation;
2372 if (allocationExpression != null) {
2373 allocationExpression.sourceEnd = this.endStatementPosition;
2374 length = this.genericsLengthStack[this.genericsLengthPtr--];
2376 this.genericsPtr -= length;
2377 System.arraycopy(this.genericsStack, this.genericsPtr + 1, allocationExpression.typeArguments = new TypeReference[length], 0, length);
2378 allocationExpression.sourceStart = intStack[intPtr--];
2379 }
2380
2381 markInitializersWithLocalType(anonymousTypeDeclaration);
2383 }
2384}
2385protected void consumeClassOrInterface() {
2386 this.genericsIdentifiersLengthStack[this.genericsIdentifiersLengthPtr] += this.identifierLengthStack[this.identifierLengthPtr];
2387 pushOnGenericsLengthStack(0); }
2389protected void consumeClassOrInterfaceName() {
2390 pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
2391 pushOnGenericsLengthStack(0); }
2393protected void consumeClassTypeElt() {
2394 pushOnAstStack(getTypeReference(0));
2396
2398 this.listLength++;
2399}
2400protected void consumeClassTypeList() {
2401 optimizedConcatNodeLists();
2403}
2404protected void consumeCompilationUnit() {
2405 }
2408protected void consumeConditionalExpression(int op) {
2409 this.intPtr -= 2; this.expressionPtr -= 2;
2413 this.expressionLengthPtr -= 2;
2414 this.expressionStack[this.expressionPtr] =
2415 new ConditionalExpression(
2416 this.expressionStack[this.expressionPtr],
2417 this.expressionStack[this.expressionPtr + 1],
2418 this.expressionStack[this.expressionPtr + 2]);
2419}
2420
2423protected void consumeConditionalExpressionWithName(int op) {
2424 this.intPtr -= 2; pushOnExpressionStack(getUnspecifiedReferenceOptimized());
2427 this.expressionPtr -= 2;
2428 this.expressionLengthPtr -= 2;
2429 this.expressionStack[this.expressionPtr] =
2430 new ConditionalExpression(
2431 this.expressionStack[this.expressionPtr + 2],
2432 this.expressionStack[this.expressionPtr],
2433 this.expressionStack[this.expressionPtr + 1]);
2434}
2435protected void consumeConstructorBlockStatements() {
2436 concatNodeLists(); }
2439protected void consumeConstructorBody() {
2440 this.nestedMethod[this.nestedType] --;
2443}
2444protected void consumeConstructorDeclaration() {
2445
2447
2454
2455
2457 int length;
2458
2459 this.intPtr--;
2461 this.intPtr--;
2462
2463 this.realBlockPtr--;
2465 ExplicitConstructorCall constructorCall = null;
2466 Statement[] statements = null;
2467 if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
2468 this.astPtr -= length;
2469 if (this.astStack[this.astPtr + 1] instanceof ExplicitConstructorCall) {
2470 System.arraycopy(
2472 this.astStack,
2473 this.astPtr + 2,
2474 statements = new Statement[length - 1],
2475 0,
2476 length - 1);
2477 constructorCall = (ExplicitConstructorCall) this.astStack[this.astPtr + 1];
2478 } else { System.arraycopy(
2480 this.astStack,
2481 this.astPtr + 1,
2482 statements = new Statement[length],
2483 0,
2484 length);
2485 constructorCall = SuperReference.implicitSuperConstructorCall();
2486 }
2487 } else {
2488 boolean insideFieldInitializer = false;
2489 if (this.diet) {
2490 for (int i = this.nestedType; i > 0; i--){
2491 if (this.variablesCounter[i] > 0) {
2492 insideFieldInitializer = true;
2493 break;
2494 }
2495 }
2496 }
2497
2498 if (!this.diet || insideFieldInitializer){
2499 constructorCall = SuperReference.implicitSuperConstructorCall();
2501 }
2502 }
2503
2504 ConstructorDeclaration cd = (ConstructorDeclaration) this.astStack[this.astPtr];
2506 cd.constructorCall = constructorCall;
2507 cd.statements = statements;
2508
2509 if (constructorCall != null && cd.constructorCall.sourceEnd == 0) {
2511 cd.constructorCall.sourceEnd = cd.sourceEnd;
2512 cd.constructorCall.sourceStart = cd.sourceStart;
2513 }
2514
2515 if (!(this.diet && this.dietInt == 0)
2516 && statements == null
2517 && (constructorCall == null || constructorCall.isImplicitSuper())
2518 && !containsComment(cd.bodyStart, this.endPosition)) {
2519 cd.bits |= ASTNode.UndocumentedEmptyBlock;
2520 }
2521
2522 cd.bodyEnd = this.endPosition;
2526 cd.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
2527}
2528protected void consumeConstructorHeader() {
2529
2531 AbstractMethodDeclaration method = (AbstractMethodDeclaration)this.astStack[this.astPtr];
2532
2533 if (this.currentToken == TokenNameLBRACE){
2534 method.bodyStart = this.scanner.currentPosition;
2535 }
2536 if (this.currentElement != null){
2538 if (this.currentToken == TokenNameSEMICOLON){ method.modifiers |= ExtraCompilerModifiers.AccSemicolonBody;
2540 method.declarationSourceEnd = this.scanner.currentPosition-1;
2541 method.bodyEnd = this.scanner.currentPosition-1;
2542 if (this.currentElement.parseTree() == method && this.currentElement.parent != null) {
2543 this.currentElement = this.currentElement.parent;
2544 }
2545 }
2546 this.restartRecovery = true; }
2548}
2549protected void consumeConstructorHeaderName() {
2550
2551
2552 if (this.currentElement != null){
2553 if (this.lastIgnoredToken == TokenNamenew){ this.lastCheckPoint = this.scanner.startPosition; this.restartRecovery = true;
2556 return;
2557 }
2558 }
2559
2560 ConstructorDeclaration cd = new ConstructorDeclaration(this.compilationUnit.compilationResult);
2562
2563 cd.selector = this.identifierStack[this.identifierPtr];
2565 long selectorSource = this.identifierPositionStack[this.identifierPtr--];
2566 this.identifierLengthPtr--;
2567
2568 cd.declarationSourceStart = this.intStack[this.intPtr--];
2570 cd.modifiers = this.intStack[this.intPtr--];
2571 int length;
2573 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
2574 System.arraycopy(
2575 this.expressionStack,
2576 (this.expressionPtr -= length) + 1,
2577 cd.annotations = new Annotation[length],
2578 0,
2579 length);
2580 }
2581 cd.javadoc = this.javadoc;
2583 this.javadoc = null;
2584
2585 cd.sourceStart = (int) (selectorSource >>> 32);
2587 pushOnAstStack(cd);
2588 cd.sourceEnd = this.lParenPos;
2589 cd.bodyStart = this.lParenPos+1;
2590 this.listLength = 0;
2592 if (this.currentElement != null){
2594 this.lastCheckPoint = cd.bodyStart;
2595 if ((this.currentElement instanceof RecoveredType && this.lastIgnoredToken != TokenNameDOT)
2596 || cd.modifiers != 0){
2597 this.currentElement = this.currentElement.add(cd, 0);
2598 this.lastIgnoredToken = -1;
2599 }
2600 }
2601}
2602protected void consumeConstructorHeaderNameWithTypeParameters() {
2603
2604
2605 if (this.currentElement != null){
2606 if (this.lastIgnoredToken == TokenNamenew){ this.lastCheckPoint = this.scanner.startPosition; this.restartRecovery = true;
2609 return;
2610 }
2611 }
2612
2613 ConstructorDeclaration cd = new ConstructorDeclaration(this.compilationUnit.compilationResult);
2615
2616 cd.selector = this.identifierStack[this.identifierPtr];
2618 long selectorSource = this.identifierPositionStack[this.identifierPtr--];
2619 this.identifierLengthPtr--;
2620
2621 int length = this.genericsLengthStack[this.genericsLengthPtr--];
2623 this.genericsPtr -= length;
2624 System.arraycopy(this.genericsStack, this.genericsPtr + 1, cd.typeParameters = new TypeParameter[length], 0, length);
2625
2626 cd.declarationSourceStart = this.intStack[this.intPtr--];
2628 cd.modifiers = this.intStack[this.intPtr--];
2629 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
2631 System.arraycopy(
2632 this.expressionStack,
2633 (this.expressionPtr -= length) + 1,
2634 cd.annotations = new Annotation[length],
2635 0,
2636 length);
2637 }
2638 cd.javadoc = this.javadoc;
2640 this.javadoc = null;
2641
2642 cd.sourceStart = (int) (selectorSource >>> 32);
2644 pushOnAstStack(cd);
2645 cd.sourceEnd = this.lParenPos;
2646 cd.bodyStart = this.lParenPos+1;
2647 this.listLength = 0;
2649 if (this.currentElement != null){
2651 this.lastCheckPoint = cd.bodyStart;
2652 if ((this.currentElement instanceof RecoveredType && this.lastIgnoredToken != TokenNameDOT)
2653 || cd.modifiers != 0){
2654 this.currentElement = this.currentElement.add(cd, 0);
2655 this.lastIgnoredToken = -1;
2656 }
2657 }
2658}
2659protected void consumeDefaultLabel() {
2660 pushOnAstStack(new CaseStatement(null, this.intStack[this.intPtr--], this.intStack[this.intPtr--]));
2662}
2663protected void consumeDefaultModifiers() {
2664 checkComment(); pushOnIntStack(this.modifiers); pushOnIntStack(
2667 this.modifiersSourceStart >= 0 ? this.modifiersSourceStart : this.scanner.startPosition);
2668 resetModifiers();
2669 pushOnExpressionStackLengthStack(0); }
2671protected void consumeDiet() {
2672 checkComment();
2674 pushOnIntStack(this.modifiersSourceStart); resetModifiers();
2676 jumpOverMethodBody();
2677}
2678protected void consumeDims() {
2679 pushOnIntStack(this.dimensions);
2681 this.dimensions = 0;
2682}
2683protected void consumeDimWithOrWithOutExpr() {
2684 pushOnExpressionStack(null);
2686
2687 if(this.currentElement != null && this.currentToken == TokenNameLBRACE) {
2688 this.ignoreNextOpeningBrace = true;
2689 this.currentElement.bracketBalance++;
2690 }
2691}
2692protected void consumeDimWithOrWithOutExprs() {
2693 concatExpressionLists();
2695}
2696protected void consumeEmptyAnnotationTypeMemberDeclarationsopt() {
2697 pushOnAstLengthStack(0);
2699}
2700protected void consumeEmptyArgumentListopt() {
2701 pushOnExpressionStackLengthStack(0);
2703}
2704protected void consumeEmptyArguments() {
2705 final FieldDeclaration fieldDeclaration = (FieldDeclaration) this.astStack[this.astPtr];
2707 pushOnIntStack(fieldDeclaration.sourceEnd);
2708 pushOnExpressionStackLengthStack(0);
2709}
2710protected void consumeEmptyArrayInitializer() {
2711 arrayInitializer(0);
2713}
2714protected void consumeEmptyArrayInitializeropt() {
2715 pushOnExpressionStackLengthStack(0);
2717}
2718protected void consumeEmptyBlockStatementsopt() {
2719 pushOnAstLengthStack(0);
2721}
2722protected void consumeEmptyCatchesopt() {
2723 pushOnAstLengthStack(0);
2725}
2726protected void consumeEmptyClassBodyDeclarationsopt() {
2727 pushOnAstLengthStack(0);
2729}
2730protected void consumeEmptyMethodHeaderDefaultValue() {
2731 AbstractMethodDeclaration method = (AbstractMethodDeclaration)this.astStack[this.astPtr];
2733 if(method.isAnnotationMethod()) { pushOnExpressionStackLengthStack(0);
2735 }
2736 this.recordStringLiterals = true;
2737}
2738protected void consumeEmptyDimsopt() {
2739 pushOnIntStack(0);
2741}
2742protected void consumeEmptyEnumDeclarations() {
2743 pushOnAstLengthStack(0);
2745}
2746protected void consumeEmptyExpression() {
2747 pushOnExpressionStackLengthStack(0);
2749}
2750protected void consumeEmptyForInitopt() {
2751 pushOnAstLengthStack(0);
2753}
2754protected void consumeEmptyForUpdateopt() {
2755 pushOnExpressionStackLengthStack(0);
2757}
2758protected void consumeEmptyInterfaceMemberDeclarationsopt() {
2759 pushOnAstLengthStack(0);
2761}
2762protected void consumeEmptyInternalCompilationUnit() {
2763 if (this.compilationUnit.isPackageInfo()) {
2766 this.compilationUnit.types = new TypeDeclaration[1];
2767 TypeDeclaration declaration = new TypeDeclaration(compilationUnit.compilationResult);
2769 declaration.name = TypeConstants.PACKAGE_INFO_NAME;
2770 declaration.modifiers = ClassFileConstants.AccDefault | ClassFileConstants.AccInterface;
2771 this.compilationUnit.types[0] = declaration;
2772 declaration.javadoc = this.compilationUnit.javadoc;
2773 }
2774}
2775protected void consumeEmptyMemberValuePairsopt() {
2776 pushOnAstLengthStack(0);
2778}
2779protected void consumeEmptyMemberValueArrayInitializer() {
2780 arrayInitializer(0);
2783}
2784protected void consumeEmptyStatement() {
2785 char[] source = this.scanner.source;
2787 if (source[this.endStatementPosition] == ';') {
2788 pushOnAstStack(new EmptyStatement(this.endStatementPosition, this.endStatementPosition));
2789 } else {
2790 if(source.length > 5) {
2791 int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
2792 int pos = this.endStatementPosition - 4;
2793 while (source[pos] == 'u') {
2794 pos--;
2795 }
2796 if (source[pos] == '\\' &&
2797 !((c1 = ScannerHelper.getNumericValue(source[this.endStatementPosition - 3])) > 15
2798 || c1 < 0
2799 || (c2 = ScannerHelper.getNumericValue(source[this.endStatementPosition - 2])) > 15
2800 || c2 < 0
2801 || (c3 = ScannerHelper.getNumericValue(source[this.endStatementPosition - 1])) > 15
2802 || c3 < 0
2803 || (c4 = ScannerHelper.getNumericValue(source[this.endStatementPosition])) > 15
2804 || c4 < 0) &&
2805 ((char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4)) == ';'){
2806 pushOnAstStack(new EmptyStatement(pos, this.endStatementPosition));
2808 return;
2809 }
2810 }
2811 pushOnAstStack(new EmptyStatement(this.endStatementPosition, this.endStatementPosition));
2812 }
2813}
2814protected void consumeEmptySwitchBlock() {
2815 pushOnAstLengthStack(0);
2817}
2818protected void consumeEmptyTypeDeclaration() {
2819 pushOnAstLengthStack(0);
2823 if(!this.statementRecoveryActivated) problemReporter().superfluousSemicolon(this.endPosition+1, this.endStatementPosition);
2824 flushCommentsDefinedPriorTo(this.endStatementPosition);
2825}
2826protected void consumeEnhancedForStatementHeaderInit(boolean hasModifiers) {
2827 TypeReference type;
2828
2829 char[] identifierName = this.identifierStack[this.identifierPtr];
2830 long namePosition = this.identifierPositionStack[this.identifierPtr];
2831
2832 LocalDeclaration localDeclaration = createLocalDeclaration(identifierName, (int) (namePosition >>> 32), (int) namePosition);
2833 localDeclaration.declarationSourceEnd = localDeclaration.declarationEnd;
2834
2835 int extraDims = this.intStack[this.intPtr--];
2836 this.identifierPtr--;
2837 this.identifierLengthPtr--;
2838 int declarationSourceStart = 0;
2840 int modifiersValue = 0;
2841 if (hasModifiers) {
2842 declarationSourceStart = this.intStack[this.intPtr--];
2843 modifiersValue = this.intStack[this.intPtr--];
2844 } else {
2845 this.intPtr-=2;
2846 }
2847
2848 type = getTypeReference(this.intStack[this.intPtr--] + extraDims);
2850 int length;
2852 if ((length = this.expressionLengthStack[this.expressionLengthPtr--])!= 0) {
2853 System.arraycopy(
2854 this.expressionStack,
2855 (this.expressionPtr -= length) + 1,
2856 localDeclaration.annotations = new Annotation[length],
2857 0,
2858 length);
2859 }
2860 if (hasModifiers) {
2861 localDeclaration.declarationSourceStart = declarationSourceStart;
2862 localDeclaration.modifiers = modifiersValue;
2863 } else {
2864 localDeclaration.declarationSourceStart = type.sourceStart;
2865 }
2866 localDeclaration.type = type;
2867
2868 ForeachStatement iteratorForStatement =
2869 new ForeachStatement(
2870 localDeclaration,
2871 this.intStack[this.intPtr--]);
2872 pushOnAstStack(iteratorForStatement);
2873
2874 iteratorForStatement.sourceEnd = localDeclaration.declarationSourceEnd;
2875}
2876protected void consumeEnhancedForStatementHeader(){
2877 final ForeachStatement statement = (ForeachStatement) this.astStack[this.astPtr];
2879 this.expressionLengthPtr--;
2881 final Expression collection = this.expressionStack[this.expressionPtr--];
2882 statement.collection = collection;
2883 statement.sourceEnd = this.rParenPos;
2884
2885 if(!this.statementRecoveryActivated &&
2886 options.sourceLevel < ClassFileConstants.JDK1_5 &&
2887 this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
2888 this.problemReporter().invalidUsageOfForeachStatements(statement.elementVariable, collection);
2889 }
2890}
2891protected void consumeEnhancedForStatement() {
2892
2895 this.astLengthPtr--;
2897 Statement statement = (Statement) this.astStack[this.astPtr--];
2898
2899 ForeachStatement foreachStatement = (ForeachStatement) this.astStack[this.astPtr];
2901 foreachStatement.action = statement;
2902 if (statement instanceof EmptyStatement) statement.bits |= ASTNode.IsUsefulEmptyStatement;
2904
2905 foreachStatement.sourceEnd = this.endStatementPosition;
2906}
2907protected void consumeEnterAnonymousClassBody() {
2908 TypeReference typeReference = getTypeReference(0);
2910
2911 TypeDeclaration anonymousType = new TypeDeclaration(this.compilationUnit.compilationResult);
2912 anonymousType.name = CharOperation.NO_CHAR;
2913 anonymousType.bits |= (ASTNode.IsAnonymousType|ASTNode.IsLocalType);
2914 QualifiedAllocationExpression alloc = new QualifiedAllocationExpression(anonymousType);
2915 markEnclosingMemberWithLocalType();
2916 pushOnAstStack(anonymousType);
2917
2918 alloc.sourceEnd = this.rParenPos; int argumentLength;
2920 if ((argumentLength = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
2921 this.expressionPtr -= argumentLength;
2922 System.arraycopy(
2923 this.expressionStack,
2924 this.expressionPtr + 1,
2925 alloc.arguments = new Expression[argumentLength],
2926 0,
2927 argumentLength);
2928 }
2929 alloc.type = typeReference;
2930
2931 anonymousType.sourceEnd = alloc.sourceEnd;
2932 anonymousType.sourceStart = anonymousType.declarationSourceStart = alloc.type.sourceStart;
2934 alloc.sourceStart = this.intStack[this.intPtr--];
2935 pushOnExpressionStack(alloc);
2936
2937 anonymousType.bodyStart = this.scanner.currentPosition;
2938 this.listLength = 0;
2940 this.scanner.commentPtr = -1;
2942
2943 if (this.currentElement != null){
2945 this.lastCheckPoint = anonymousType.bodyStart;
2946 this.currentElement = this.currentElement.add(anonymousType, 0);
2947 this.currentToken = 0; this.lastIgnoredToken = -1;
2949 }
2950}
2951protected void consumeEnterCompilationUnit() {
2952 }
2955protected void consumeEnterMemberValue() {
2956 }
2959protected void consumeEnterMemberValueArrayInitializer() {
2960 if(this.currentElement != null) {
2962 this.ignoreNextOpeningBrace = true;
2963 this.currentElement.bracketBalance++;
2964 }
2965}
2966protected void consumeEnterVariable() {
2967
2970 char[] identifierName = this.identifierStack[this.identifierPtr];
2971 long namePosition = this.identifierPositionStack[this.identifierPtr];
2972 int extendedDimension = this.intStack[this.intPtr--];
2973 AbstractVariableDeclaration declaration;
2974 boolean isLocalDeclaration = this.nestedMethod[this.nestedType] != 0;
2976 if (isLocalDeclaration) {
2977 declaration =
2979 this.createLocalDeclaration(identifierName, (int) (namePosition >>> 32), (int) namePosition);
2980 } else {
2981 declaration =
2983 this.createFieldDeclaration(identifierName, (int) (namePosition >>> 32), (int) namePosition);
2984 }
2985
2986 this.identifierPtr--;
2987 this.identifierLengthPtr--;
2988 TypeReference type;
2989 int variableIndex = this.variablesCounter[this.nestedType];
2990 int typeDim = 0;
2991 if (variableIndex == 0) {
2992 if (isLocalDeclaration) {
2994 declaration.declarationSourceStart = this.intStack[this.intPtr--];
2995 declaration.modifiers = this.intStack[this.intPtr--];
2996 int length;
2998 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
2999 System.arraycopy(
3000 this.expressionStack,
3001 (this.expressionPtr -= length) + 1,
3002 declaration.annotations = new Annotation[length],
3003 0,
3004 length);
3005 }
3006 type = getTypeReference(typeDim = this.intStack[this.intPtr--]); if (declaration.declarationSourceStart == -1) {
3008 declaration.declarationSourceStart = type.sourceStart;
3010 }
3011 pushOnAstStack(type);
3012 } else {
3013 type = getTypeReference(typeDim = this.intStack[this.intPtr--]); pushOnAstStack(type);
3015 declaration.declarationSourceStart = this.intStack[this.intPtr--];
3016 declaration.modifiers = this.intStack[this.intPtr--];
3017 int length;
3019 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
3020 System.arraycopy(
3021 this.expressionStack,
3022 (this.expressionPtr -= length) + 1,
3023 declaration.annotations = new Annotation[length],
3024 0,
3025 length);
3026 }
3027 FieldDeclaration fieldDeclaration = (FieldDeclaration) declaration;
3029 fieldDeclaration.javadoc = this.javadoc;
3030 this.javadoc = null;
3031 }
3032 } else {
3033 type = (TypeReference) this.astStack[this.astPtr - variableIndex];
3034 typeDim = type.dimensions();
3035 AbstractVariableDeclaration previousVariable =
3036 (AbstractVariableDeclaration) this.astStack[this.astPtr];
3037 declaration.declarationSourceStart = previousVariable.declarationSourceStart;
3038 declaration.modifiers = previousVariable.modifiers;
3039 final Annotation[] annotations = previousVariable.annotations;
3040 if (annotations != null) {
3041 final int annotationsLength = annotations.length;
3042 System.arraycopy(annotations, 0, declaration.annotations = new Annotation[annotationsLength], 0, annotationsLength);
3043 }
3044 }
3045
3046 if (extendedDimension == 0) {
3047 declaration.type = type;
3048 } else {
3049 int dimension = typeDim + extendedDimension;
3050 declaration.type = this.copyDims(type, dimension);
3051 }
3052 this.variablesCounter[this.nestedType]++;
3053 pushOnAstStack(declaration);
3054 if (this.currentElement != null) {
3056 if (!(this.currentElement instanceof RecoveredType)
3057 && (this.currentToken == TokenNameDOT
3058 || (Util.getLineNumber(declaration.type.sourceStart, this.scanner.lineEnds, 0, this.scanner.linePtr)
3060 != Util.getLineNumber((int) (namePosition >>> 32), this.scanner.lineEnds, 0, this.scanner.linePtr)))){
3061 this.lastCheckPoint = (int) (namePosition >>> 32);
3062 this.restartRecovery = true;
3063 return;
3064 }
3065 if (isLocalDeclaration){
3066 LocalDeclaration localDecl = (LocalDeclaration) this.astStack[this.astPtr];
3067 this.lastCheckPoint = localDecl.sourceEnd + 1;
3068 this.currentElement = this.currentElement.add(localDecl, 0);
3069 } else {
3070 FieldDeclaration fieldDecl = (FieldDeclaration) this.astStack[this.astPtr];
3071 this.lastCheckPoint = fieldDecl.sourceEnd + 1;
3072 this.currentElement = this.currentElement.add(fieldDecl, 0);
3073 }
3074 this.lastIgnoredToken = -1;
3075 }
3076}
3077protected void consumeEnumBodyNoConstants() {
3078 }
3081protected void consumeEnumBodyWithConstants() {
3082 concatNodeLists();
3084}
3085protected void consumeEnumConstantHeaderName() {
3086 if (this.currentElement != null) {
3087 if (!(this.currentElement instanceof RecoveredType
3088 || (this.currentElement instanceof RecoveredField && ((RecoveredField)currentElement).fieldDeclaration.type == null))
3089 || (this.lastIgnoredToken == TokenNameDOT)) {
3090 this.lastCheckPoint = this.scanner.startPosition;
3091 this.restartRecovery = true;
3092 return;
3093 }
3094 }
3095 long namePosition = this.identifierPositionStack[this.identifierPtr];
3096 char[] constantName = this.identifierStack[this.identifierPtr];
3097 final int sourceEnd = (int) namePosition;
3098 FieldDeclaration enumConstant = createFieldDeclaration(constantName, (int) (namePosition >>> 32), sourceEnd);
3099 this.identifierPtr--;
3100 this.identifierLengthPtr--;
3101 enumConstant.modifiersSourceStart = this.intStack[this.intPtr--];
3102 enumConstant.modifiers = this.intStack[this.intPtr--];
3103 enumConstant.declarationSourceStart = enumConstant.modifiersSourceStart;
3104
3105 if ((enumConstant.bits & ASTNode.IsMemberType) == 0 && (enumConstant.bits & ASTNode.IsLocalType) == 0) {
3107 if (this.compilationUnit != null && !CharOperation.equals(enumConstant.name, this.compilationUnit.getMainTypeName())) {
3108 enumConstant.bits |= ASTNode.IsSecondaryType;
3109 }
3110 }
3111
3112 int length;
3114 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
3115 System.arraycopy(
3116 this.expressionStack,
3117 (this.expressionPtr -= length) + 1,
3118 enumConstant.annotations = new Annotation[length],
3119 0,
3120 length);
3121 }
3122 pushOnAstStack(enumConstant);
3123 if (this.currentElement != null){
3124 this.lastCheckPoint = enumConstant.sourceEnd + 1;
3125 this.currentElement = this.currentElement.add(enumConstant, 0);
3126 }
3127 enumConstant.javadoc = this.javadoc;
3129 this.javadoc = null;
3130}
3131protected void consumeEnumConstantHeader() {
3132 FieldDeclaration enumConstant = (FieldDeclaration) this.astStack[this.astPtr];
3133 boolean foundOpeningBrace = this.currentToken == TokenNameLBRACE;
3134 if (foundOpeningBrace){
3135 TypeDeclaration anonymousType = new TypeDeclaration(this.compilationUnit.compilationResult);
3137 anonymousType.name = CharOperation.NO_CHAR;
3138 anonymousType.bits |= (ASTNode.IsAnonymousType|ASTNode.IsLocalType);
3139 final int start = this.scanner.startPosition;
3140 anonymousType.declarationSourceStart = start;
3141 anonymousType.sourceStart = start;
3142 anonymousType.sourceEnd = start; anonymousType.modifiers = 0;
3144 anonymousType.bodyStart = this.scanner.currentPosition;
3145 markEnclosingMemberWithLocalType();
3146 pushOnAstStack(anonymousType);
3147 QualifiedAllocationExpression allocationExpression = new QualifiedAllocationExpression(anonymousType);
3148 allocationExpression.enumConstant = enumConstant;
3149
3150 int length;
3152 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
3153 this.expressionPtr -= length;
3154 System.arraycopy(
3155 this.expressionStack,
3156 this.expressionPtr + 1,
3157 allocationExpression.arguments = new Expression[length],
3158 0,
3159 length);
3160 }
3161 enumConstant.initialization = allocationExpression;
3162 } else {
3163 AllocationExpression allocationExpression = new AllocationExpression();
3164 allocationExpression.enumConstant = enumConstant;
3165 int length;
3167 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
3168 this.expressionPtr -= length;
3169 System.arraycopy(
3170 this.expressionStack,
3171 this.expressionPtr + 1,
3172 allocationExpression.arguments = new Expression[length],
3173 0,
3174 length);
3175 }
3176 enumConstant.initialization = allocationExpression;
3177 }
3178
3179 if (this.currentElement != null) {
3181 if(foundOpeningBrace) {
3182 TypeDeclaration anonymousType = (TypeDeclaration) this.astStack[this.astPtr];
3183 this.currentElement = this.currentElement.add(anonymousType, 0);
3184 this.lastCheckPoint = anonymousType.bodyStart;
3185 this.lastIgnoredToken = -1;
3186 this.currentToken = 0; } else {
3188 if(this.currentToken == TokenNameSEMICOLON) {
3189 RecoveredType currentType = this.currentRecoveryType();
3190 if(currentType != null) {
3191 currentType.insideEnumConstantPart = false;
3192 }
3193 }
3194 this.lastCheckPoint = this.scanner.startPosition; this.lastIgnoredToken = -1;
3196 this.restartRecovery = true;
3197 }
3198 }
3199}
3200protected void consumeEnumConstantNoClassBody() {
3201 int endOfEnumConstant = intStack[intPtr--];
3203 final FieldDeclaration fieldDeclaration = (FieldDeclaration) this.astStack[this.astPtr];
3204 fieldDeclaration.declarationEnd = endOfEnumConstant;
3205 fieldDeclaration.declarationSourceEnd = endOfEnumConstant;
3206}
3207protected void consumeEnumConstants() {
3208 concatNodeLists();
3209}
3210protected void consumeEnumConstantWithClassBody() {
3211 dispatchDeclarationInto(this.astLengthStack[this.astLengthPtr--]);
3212 TypeDeclaration anonymousType = (TypeDeclaration) this.astStack[this.astPtr--]; this.astLengthPtr--;
3214 anonymousType.bodyEnd = this.endPosition;
3215 anonymousType.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
3216 final FieldDeclaration fieldDeclaration = ((FieldDeclaration) this.astStack[this.astPtr]);
3217 fieldDeclaration.declarationEnd = this.endStatementPosition;
3218 fieldDeclaration.declarationSourceEnd = anonymousType.declarationSourceEnd;
3219 intPtr --; }
3221protected void consumeEnumDeclaration() {
3222 int length;
3224 if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
3225 dispatchDeclarationIntoEnumDeclaration(length);
3228 }
3229
3230 TypeDeclaration enumDeclaration = (TypeDeclaration) this.astStack[this.astPtr];
3231
3232 markInitializersWithLocalType(enumDeclaration);
3234
3235 boolean hasConstructor = enumDeclaration.checkConstructors(this);
3237
3238 if (!hasConstructor) {
3240 boolean insideFieldInitializer = false;
3241 if (this.diet) {
3242 for (int i = this.nestedType; i > 0; i--){
3243 if (this.variablesCounter[i] > 0) {
3244 insideFieldInitializer = true;
3245 break;
3246 }
3247 }
3248 }
3249 enumDeclaration.createDefaultConstructor(!this.diet || insideFieldInitializer, true);
3250 }
3251
3252 if (this.scanner.containsAssertKeyword) {
3254 enumDeclaration.bits |= ASTNode.ContainsAssertion;
3255 }
3256 enumDeclaration.addClinit();
3257 enumDeclaration.bodyEnd = this.endStatementPosition;
3258 if (length == 0 && !containsComment(enumDeclaration.bodyStart, enumDeclaration.bodyEnd)) {
3259 enumDeclaration.bits |= ASTNode.UndocumentedEmptyBlock;
3260 }
3261
3262 enumDeclaration.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
3263}
3264protected void consumeEnumDeclarations() {
3265 }
3267protected void consumeEnumHeader() {
3268 TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
3269 if (this.currentToken == TokenNameLBRACE) {
3270 typeDecl.bodyStart = this.scanner.currentPosition;
3271 }
3272
3273 if (this.currentElement != null) {
3274 this.restartRecovery = true; }
3276
3277 this.scanner.commentPtr = -1;
3279}
3280protected void consumeEnumHeaderName() {
3281 TypeDeclaration enumDeclaration = new TypeDeclaration(this.compilationUnit.compilationResult);
3283 if (this.nestedMethod[this.nestedType] == 0) {
3284 if (this.nestedType != 0) {
3285 enumDeclaration.bits |= ASTNode.IsMemberType;
3286 }
3287 } else {
3288 blockReal();
3291 }
3292 long pos = this.identifierPositionStack[this.identifierPtr];
3294 enumDeclaration.sourceEnd = (int) pos;
3295 enumDeclaration.sourceStart = (int) (pos >>> 32);
3296 enumDeclaration.name = this.identifierStack[this.identifierPtr--];
3297 this.identifierLengthPtr--;
3298
3299 enumDeclaration.declarationSourceStart = this.intStack[this.intPtr--];
3304 this.intPtr--;
3306 enumDeclaration.modifiersSourceStart = this.intStack[this.intPtr--];
3307 enumDeclaration.modifiers = this.intStack[this.intPtr--] | ClassFileConstants.AccEnum;
3308 if (enumDeclaration.modifiersSourceStart >= 0) {
3309 enumDeclaration.declarationSourceStart = enumDeclaration.modifiersSourceStart;
3310 }
3311 int length;
3313 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
3314 System.arraycopy(
3315 this.expressionStack,
3316 (this.expressionPtr -= length) + 1,
3317 enumDeclaration.annotations = new Annotation[length],
3318 0,
3319 length);
3320 }
3321 enumDeclaration.bodyStart = enumDeclaration.sourceEnd + 1;
3325 pushOnAstStack(enumDeclaration);
3326
3327 this.listLength = 0;
3329 if(!this.statementRecoveryActivated &&
3330 options.sourceLevel < ClassFileConstants.JDK1_5 &&
3331 this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
3332 this.problemReporter().invalidUsageOfEnumDeclarations(enumDeclaration);
3334 }
3335
3336 if (this.currentElement != null){
3338 this.lastCheckPoint = enumDeclaration.bodyStart;
3339 this.currentElement = this.currentElement.add(enumDeclaration, 0);
3340 this.lastIgnoredToken = -1;
3341 }
3342 enumDeclaration.javadoc = this.javadoc;
3344 this.javadoc = null;
3345}
3346protected void consumeEqualityExpression(int op) {
3347
3350
3352 this.expressionPtr--;
3353 this.expressionLengthPtr--;
3354 this.expressionStack[this.expressionPtr] =
3355 new EqualExpression(
3356 this.expressionStack[this.expressionPtr],
3357 this.expressionStack[this.expressionPtr + 1],
3358 op);
3359}
3360
3363protected void consumeEqualityExpressionWithName(int op) {
3364 pushOnExpressionStack(getUnspecifiedReferenceOptimized());
3367 this.expressionPtr--;
3368 this.expressionLengthPtr--;
3369 this.expressionStack[this.expressionPtr] =
3370 new EqualExpression(
3371 this.expressionStack[this.expressionPtr + 1],
3372 this.expressionStack[this.expressionPtr],
3373 op);
3374}
3375protected void consumeExitMemberValue() {
3376 }
3379protected void consumeExitTryBlock() {
3380 if(this.currentElement != null) {
3382 this.restartRecovery = true;
3383 }
3384}
3385protected void consumeExitVariableWithInitialization() {
3386 this.expressionLengthPtr--;
3389 AbstractVariableDeclaration variableDecl = (AbstractVariableDeclaration) this.astStack[this.astPtr];
3390 variableDecl.initialization = this.expressionStack[this.expressionPtr--];
3391 variableDecl.declarationSourceEnd = variableDecl.initialization.sourceEnd;
3394 variableDecl.declarationEnd = variableDecl.initialization.sourceEnd;
3395
3396 this.recoveryExitFromVariable();
3397}
3398protected void consumeExitVariableWithoutInitialization() {
3399
3402 AbstractVariableDeclaration variableDecl = (AbstractVariableDeclaration) this.astStack[this.astPtr];
3403 variableDecl.declarationSourceEnd = variableDecl.declarationEnd;
3404 if(this.currentElement != null && this.currentElement instanceof RecoveredField) {
3405 if(this.endStatementPosition > variableDecl.sourceEnd) {
3406 this.currentElement.updateSourceEndIfNecessary(this.endStatementPosition);
3407 }
3408 }
3409 this.recoveryExitFromVariable();
3410}
3411protected void consumeExplicitConstructorInvocation(int flag, int recFlag) {
3412
3413
3424 int startPosition = this.intStack[this.intPtr--];
3425 ExplicitConstructorCall ecc = new ExplicitConstructorCall(recFlag);
3426 int length;
3427 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
3428 this.expressionPtr -= length;
3429 System.arraycopy(this.expressionStack, this.expressionPtr + 1, ecc.arguments = new Expression[length], 0, length);
3430 }
3431 switch (flag) {
3432 case 0 :
3433 ecc.sourceStart = startPosition;
3434 break;
3435 case 1 :
3436 this.expressionLengthPtr--;
3437 ecc.sourceStart = (ecc.qualification = this.expressionStack[this.expressionPtr--]).sourceStart;
3438 break;
3439 case 2 :
3440 ecc.sourceStart = (ecc.qualification = getUnspecifiedReferenceOptimized()).sourceStart;
3441 break;
3442 }
3443 pushOnAstStack(ecc);
3444 ecc.sourceEnd = this.endStatementPosition;
3445}
3446protected void consumeExplicitConstructorInvocationWithTypeArguments(int flag, int recFlag) {
3447
3448
3459 int startPosition = this.intStack[this.intPtr--];
3460 ExplicitConstructorCall ecc = new ExplicitConstructorCall(recFlag);
3461 int length;
3462 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
3463 this.expressionPtr -= length;
3464 System.arraycopy(this.expressionStack, this.expressionPtr + 1, ecc.arguments = new Expression[length], 0, length);
3465 }
3466 length = this.genericsLengthStack[this.genericsLengthPtr--];
3467 this.genericsPtr -= length;
3468 System.arraycopy(this.genericsStack, this.genericsPtr + 1, ecc.typeArguments = new TypeReference[length], 0, length);
3469 ecc.typeArgumentsSourceStart = this.intStack[intPtr--];
3470
3471 switch (flag) {
3472 case 0 :
3473 ecc.sourceStart = startPosition;
3474 break;
3475 case 1 :
3476 this.expressionLengthPtr--;
3477 ecc.sourceStart = (ecc.qualification = this.expressionStack[this.expressionPtr--]).sourceStart;
3478 break;
3479 case 2 :
3480 ecc.sourceStart = (ecc.qualification = getUnspecifiedReferenceOptimized()).sourceStart;
3481 break;
3482 }
3483
3484 pushOnAstStack(ecc);
3485 ecc.sourceEnd = this.endStatementPosition;
3486}
3487protected void consumeExpressionStatement() {
3488 this.expressionLengthPtr--;
3490 Expression expression = this.expressionStack[this.expressionPtr--];
3491 expression.statementEnd = this.endStatementPosition;
3492 pushOnAstStack(expression);
3493}
3494protected void consumeFieldAccess(boolean isSuperAccess) {
3495
3498 FieldReference fr =
3499 new FieldReference(
3500 this.identifierStack[this.identifierPtr],
3501 this.identifierPositionStack[this.identifierPtr--]);
3502 this.identifierLengthPtr--;
3503 if (isSuperAccess) {
3504 fr.sourceStart = this.intStack[this.intPtr--];
3506 fr.receiver = new SuperReference(fr.sourceStart, this.endPosition);
3507 pushOnExpressionStack(fr);
3508 } else {
3509 fr.receiver = this.expressionStack[this.expressionPtr];
3511 fr.sourceStart = fr.receiver.sourceStart;
3513 this.expressionStack[this.expressionPtr] = fr;
3514 }
3515}
3516protected void consumeFieldDeclaration() {
3517
3520
3532 int variableDeclaratorsCounter = this.astLengthStack[this.astLengthPtr];
3533
3534 for (int i = variableDeclaratorsCounter - 1; i >= 0; i--) {
3535 FieldDeclaration fieldDeclaration = (FieldDeclaration) this.astStack[this.astPtr - i];
3536 fieldDeclaration.declarationSourceEnd = this.endStatementPosition;
3537 fieldDeclaration.declarationEnd = this.endStatementPosition; }
3539
3540 updateSourceDeclarationParts(variableDeclaratorsCounter);
3541 int endPos = flushCommentsDefinedPriorTo(this.endStatementPosition);
3542 if (endPos != this.endStatementPosition) {
3543 for (int i = 0; i < variableDeclaratorsCounter; i++) {
3544 FieldDeclaration fieldDeclaration = (FieldDeclaration) this.astStack[this.astPtr - i];
3545 fieldDeclaration.declarationSourceEnd = endPos;
3546 }
3547 }
3548 int startIndex = this.astPtr - this.variablesCounter[this.nestedType] + 1;
3550 System.arraycopy(
3551 this.astStack,
3552 startIndex,
3553 this.astStack,
3554 startIndex - 1,
3555 variableDeclaratorsCounter);
3556 this.astPtr--; this.astLengthStack[--this.astLengthPtr] = variableDeclaratorsCounter;
3558
3559 if (this.currentElement != null) {
3561 this.lastCheckPoint = endPos + 1;
3562 if (this.currentElement.parent != null && this.currentElement instanceof RecoveredField){
3563 if (!(this.currentElement instanceof RecoveredInitializer)) {
3564 this.currentElement = this.currentElement.parent;
3565 }
3566 }
3567 this.restartRecovery = true;
3568 }
3569 this.variablesCounter[this.nestedType] = 0;
3570}
3571protected void consumeForceNoDiet() {
3572 this.dietInt++;
3574}
3575protected void consumeForInit() {
3576 pushOnAstLengthStack(-1);
3578}
3579protected void consumeFormalParameter(boolean isVarArgs) {
3580
3591
3592 this.identifierLengthPtr--;
3593 char[] identifierName = this.identifierStack[this.identifierPtr];
3594 long namePositions = this.identifierPositionStack[this.identifierPtr--];
3595 int extendedDimensions = this.intStack[this.intPtr--];
3596 int endOfEllipsis = 0;
3597 if (isVarArgs) {
3598 endOfEllipsis = this.intStack[this.intPtr--];
3599 }
3600 int firstDimensions = this.intStack[this.intPtr--];
3601 final int typeDimensions = firstDimensions + extendedDimensions;
3602 TypeReference type = getTypeReference(typeDimensions);
3603 if (isVarArgs) {
3604 type = copyDims(type, typeDimensions + 1);
3605 if (extendedDimensions == 0) {
3606 type.sourceEnd = endOfEllipsis;
3607 }
3608 type.bits |= ASTNode.IsVarArgs; }
3610 int modifierPositions = this.intStack[this.intPtr--];
3611 this.intPtr--;
3612 Argument arg =
3613 new Argument(
3614 identifierName,
3615 namePositions,
3616 type,
3617 this.intStack[this.intPtr + 1] & ~ClassFileConstants.AccDeprecated); arg.declarationSourceStart = modifierPositions;
3619 int length;
3621 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
3622 System.arraycopy(
3623 this.expressionStack,
3624 (this.expressionPtr -= length) + 1,
3625 arg.annotations = new Annotation[length],
3626 0,
3627 length);
3628 }
3629 pushOnAstStack(arg);
3630
3631
3633 this.listLength++;
3634
3635 if(isVarArgs) {
3636 if (!this.statementRecoveryActivated &&
3637 options.sourceLevel < ClassFileConstants.JDK1_5 &&
3638 this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
3639 this.problemReporter().invalidUsageOfVarargs(arg);
3640 } else if (!this.statementRecoveryActivated &&
3641 extendedDimensions > 0) {
3642 this.problemReporter().illegalExtendedDimensions(arg);
3643 }
3644 }
3645}
3646protected void consumeFormalParameterList() {
3647 optimizedConcatNodeLists();
3649}
3650protected void consumeFormalParameterListopt() {
3651 pushOnAstLengthStack(0);
3653}
3654protected void consumeGenericType() {
3655 }
3658protected void consumeGenericTypeArrayType() {
3659 }
3662protected void consumeGenericTypeNameArrayType() {
3663 }
3666protected void consumeImportDeclaration() {
3667 ImportReference impt = (ImportReference) this.astStack[this.astPtr];
3669 impt.declarationEnd = this.endStatementPosition;
3671 impt.declarationSourceEnd =
3672 this.flushCommentsDefinedPriorTo(impt.declarationSourceEnd);
3673
3674 if (this.currentElement != null) {
3676 this.lastCheckPoint = impt.declarationSourceEnd + 1;
3677 this.currentElement = this.currentElement.add(impt, 0);
3678 this.lastIgnoredToken = -1;
3679 this.restartRecovery = true;
3680 }
3682}
3683protected void consumeImportDeclarations() {
3684 optimizedConcatNodeLists();
3686}
3687protected void consumeInsideCastExpression() {
3688 }
3690protected void consumeInsideCastExpressionLL1() {
3691 pushOnExpressionStack(getUnspecifiedReferenceOptimized());
3693}
3694protected void consumeInsideCastExpressionWithQualifiedGenerics() {
3695 }
3697protected void consumeInstanceOfExpression() {
3698
3701 Expression exp;
3703 this.expressionStack[this.expressionPtr] = exp =
3704 new InstanceOfExpression(
3705 this.expressionStack[this.expressionPtr],
3706 getTypeReference(this.intStack[this.intPtr--]));
3707 if (exp.sourceEnd == 0) {
3708 exp.sourceEnd = this.scanner.startPosition - 1;
3710 }
3711 }
3713protected void consumeInstanceOfExpressionWithName() {
3714
3717 TypeReference reference = getTypeReference(this.intStack[this.intPtr--]);
3719 pushOnExpressionStack(getUnspecifiedReferenceOptimized());
3720 Expression exp;
3721 this.expressionStack[this.expressionPtr] = exp =
3722 new InstanceOfExpression(
3723 this.expressionStack[this.expressionPtr],
3724 reference);
3725 if (exp.sourceEnd == 0) {
3726 exp.sourceEnd = this.scanner.startPosition - 1;
3728 }
3729 }
3731protected void consumeInterfaceDeclaration() {
3732 int length;
3735 if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
3736 dispatchDeclarationInto(length);
3739 }
3740
3741 TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
3742
3743 markInitializersWithLocalType(typeDecl);
3745
3746 typeDecl.checkConstructors(this);
3748
3749 if (this.scanner.containsAssertKeyword) {
3751 typeDecl.bits |= ASTNode.ContainsAssertion;
3752 }
3753 typeDecl.addClinit();
3754 typeDecl.bodyEnd = this.endStatementPosition;
3755 if (length == 0 && !containsComment(typeDecl.bodyStart, typeDecl.bodyEnd)) {
3756 typeDecl.bits |= ASTNode.UndocumentedEmptyBlock;
3757 }
3758 typeDecl.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
3759}
3760protected void consumeInterfaceHeader() {
3761
3763 TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
3764 if (this.currentToken == TokenNameLBRACE){
3765 typeDecl.bodyStart = this.scanner.currentPosition;
3766 }
3767 if (this.currentElement != null){
3768 this.restartRecovery = true; }
3770 this.scanner.commentPtr = -1;
3772}
3773protected void consumeInterfaceHeaderExtends() {
3774 int length = this.astLengthStack[this.astLengthPtr--];
3776 this.astPtr -= length;
3778 TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
3779 System.arraycopy(
3780 this.astStack,
3781 this.astPtr + 1,
3782 typeDecl.superInterfaces = new TypeReference[length],
3783 0,
3784 length);
3785 for (int i = 0, max = typeDecl.superInterfaces.length; i < max; i++) {
3786 typeDecl.superInterfaces[i].bits |= ASTNode.IsSuperType;
3787 }
3788 typeDecl.bodyStart = typeDecl.superInterfaces[length-1].sourceEnd + 1;
3789 this.listLength = 0; if (this.currentElement != null) {
3792 this.lastCheckPoint = typeDecl.bodyStart;
3793 }
3794}
3795protected void consumeInterfaceHeaderName1() {
3796 TypeDeclaration typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
3798
3799 if (this.nestedMethod[this.nestedType] == 0) {
3800 if (this.nestedType != 0) {
3801 typeDecl.bits |= ASTNode.IsMemberType;
3802 }
3803 } else {
3804 typeDecl.bits |= ASTNode.IsLocalType;
3806 markEnclosingMemberWithLocalType();
3807 blockReal();
3808 }
3809
3810 long pos = this.identifierPositionStack[this.identifierPtr];
3812 typeDecl.sourceEnd = (int) pos;
3813 typeDecl.sourceStart = (int) (pos >>> 32);
3814 typeDecl.name = this.identifierStack[this.identifierPtr--];
3815 this.identifierLengthPtr--;
3816
3817 typeDecl.declarationSourceStart = this.intStack[this.intPtr--];
3822 this.intPtr--; typeDecl.modifiersSourceStart = this.intStack[this.intPtr--];
3824 typeDecl.modifiers = this.intStack[this.intPtr--] | ClassFileConstants.AccInterface;
3825 if (typeDecl.modifiersSourceStart >= 0) {
3826 typeDecl.declarationSourceStart = typeDecl.modifiersSourceStart;
3827 }
3828
3829 if ((typeDecl.bits & ASTNode.IsMemberType) == 0 && (typeDecl.bits & ASTNode.IsLocalType) == 0) {
3831 if (this.compilationUnit != null && !CharOperation.equals(typeDecl.name, this.compilationUnit.getMainTypeName())) {
3832 typeDecl.bits |= ASTNode.IsSecondaryType;
3833 }
3834 }
3835
3836 int length;
3838 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
3839 System.arraycopy(
3840 this.expressionStack,
3841 (this.expressionPtr -= length) + 1,
3842 typeDecl.annotations = new Annotation[length],
3843 0,
3844 length);
3845 }
3846 typeDecl.bodyStart = typeDecl.sourceEnd + 1;
3847 pushOnAstStack(typeDecl);
3848 this.listLength = 0; if (this.currentElement != null){ this.lastCheckPoint = typeDecl.bodyStart;
3852 this.currentElement = this.currentElement.add(typeDecl, 0);
3853 this.lastIgnoredToken = -1;
3854 }
3855 typeDecl.javadoc = this.javadoc;
3857 this.javadoc = null;
3858}
3859protected void consumeInterfaceMemberDeclarations() {
3860 concatNodeLists();
3862}
3863protected void consumeInterfaceMemberDeclarationsopt() {
3864 this.nestedType--;
3866}
3867protected void consumeInterfaceType() {
3868 pushOnAstStack(getTypeReference(0));
3870
3872 this.listLength++;
3873}
3874protected void consumeInterfaceTypeList() {
3875 optimizedConcatNodeLists();
3877}
3878protected void consumeInternalCompilationUnit() {
3879 if (this.compilationUnit.isPackageInfo()) {
3883 this.compilationUnit.types = new TypeDeclaration[1];
3884 TypeDeclaration declaration = new TypeDeclaration(compilationUnit.compilationResult);
3886 declaration.name = TypeConstants.PACKAGE_INFO_NAME;
3887 declaration.modifiers = ClassFileConstants.AccDefault | ClassFileConstants.AccInterface;
3888 this.compilationUnit.types[0] = declaration;
3889 declaration.javadoc = this.compilationUnit.javadoc;
3890 }
3891}
3892protected void consumeInternalCompilationUnitWithTypes() {
3893 int length;
3899 if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
3900 if (this.compilationUnit.isPackageInfo()) {
3901 this.compilationUnit.types = new TypeDeclaration[length + 1];
3902 this.astPtr -= length;
3903 System.arraycopy(this.astStack, this.astPtr + 1, this.compilationUnit.types, 1, length);
3904 TypeDeclaration declaration = new TypeDeclaration(compilationUnit.compilationResult);
3906 declaration.name = TypeConstants.PACKAGE_INFO_NAME;
3907 declaration.modifiers = ClassFileConstants.AccDefault | ClassFileConstants.AccInterface;
3908 this.compilationUnit.types[0] = declaration;
3909 declaration.javadoc = this.compilationUnit.javadoc;
3910 } else {
3911 this.compilationUnit.types = new TypeDeclaration[length];
3912 this.astPtr -= length;
3913 System.arraycopy(this.astStack, this.astPtr + 1, this.compilationUnit.types, 0, length);
3914 }
3915 }
3916}
3917protected void consumeInvalidAnnotationTypeDeclaration() {
3918 TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
3920 if(!this.statementRecoveryActivated) problemReporter().illegalLocalTypeDeclaration(typeDecl);
3921 this.astPtr--;
3923 pushOnAstLengthStack(-1);
3924 concatNodeLists();
3925}
3926protected void consumeInvalidConstructorDeclaration() {
3927 ConstructorDeclaration cd = (ConstructorDeclaration) this.astStack[this.astPtr];
3930
3931 cd.bodyEnd = this.endPosition; cd.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
3933
3935 cd.modifiers |= ExtraCompilerModifiers.AccSemicolonBody; }
3937protected void consumeInvalidConstructorDeclaration(boolean hasBody) {
3938
3941
3948 if (hasBody) {
3949 this.intPtr--;
3951 }
3952
3953 if (hasBody) {
3955 this.realBlockPtr--;
3956 }
3957
3958 int length;
3959 if (hasBody && ((length = this.astLengthStack[this.astLengthPtr--]) != 0)) {
3960 this.astPtr -= length;
3961 }
3962 ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) this.astStack[this.astPtr];
3963 constructorDeclaration.bodyEnd = this.endStatementPosition;
3964 constructorDeclaration.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
3965 if (!hasBody) {
3966 constructorDeclaration.modifiers |= ExtraCompilerModifiers.AccSemicolonBody;
3967 }
3968}
3969protected void consumeInvalidInterfaceDeclaration() {
3970 TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
3973 if(!this.statementRecoveryActivated) problemReporter().illegalLocalTypeDeclaration(typeDecl);
3974 this.astPtr--;
3976 pushOnAstLengthStack(-1);
3977 concatNodeLists();
3978}
3979protected void consumeInvalidEnumDeclaration() {
3980 TypeDeclaration typeDecl = (TypeDeclaration) this.astStack[this.astPtr];
3982 if(!this.statementRecoveryActivated) problemReporter().illegalLocalTypeDeclaration(typeDecl);
3983 this.astPtr--;
3985 pushOnAstLengthStack(-1);
3986 concatNodeLists();
3987}
3988protected void consumeInvalidMethodDeclaration() {
3989
3991
4000
4001 this.intPtr--;
4003
4005 this.realBlockPtr--;
4007 int length;
4008 if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
4009 this.astPtr -= length;
4010 }
4011
4012 MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];
4014 md.bodyEnd = this.endPosition;
4015 md.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
4016
4017 if(!this.statementRecoveryActivated) problemReporter().abstractMethodNeedingNoBody(md);
4019}
4020protected void consumeLabel() {
4021 }
4023protected void consumeLeftParen() {
4024 pushOnIntStack(this.lParenPos);
4026}
4027protected void consumeLocalVariableDeclaration() {
4028
4030
4042 int variableDeclaratorsCounter = this.astLengthStack[this.astLengthPtr];
4043
4044 int startIndex = this.astPtr - this.variablesCounter[this.nestedType] + 1;
4046 System.arraycopy(
4047 this.astStack,
4048 startIndex,
4049 this.astStack,
4050 startIndex - 1,
4051 variableDeclaratorsCounter);
4052 this.astPtr--; this.astLengthStack[--this.astLengthPtr] = variableDeclaratorsCounter;
4054 this.variablesCounter[this.nestedType] = 0;
4055}
4056protected void consumeLocalVariableDeclarationStatement() {
4057 this.realBlockStack[this.realBlockPtr]++;
4061
4062 int variableDeclaratorsCounter = this.astLengthStack[this.astLengthPtr];
4064 for (int i = variableDeclaratorsCounter - 1; i >= 0; i--) {
4065 LocalDeclaration localDeclaration = (LocalDeclaration) this.astStack[this.astPtr - i];
4066 localDeclaration.declarationSourceEnd = this.endStatementPosition;
4067 localDeclaration.declarationEnd = this.endStatementPosition; }
4069
4070}
4071protected void consumeMarkerAnnotation() {
4072 MarkerAnnotation markerAnnotation = null;
4074 TypeReference typeReference = this.getAnnotationType();
4075 markerAnnotation = new MarkerAnnotation(typeReference, this.intStack[this.intPtr--]);
4076 markerAnnotation.declarationSourceEnd = markerAnnotation.sourceEnd;
4077 pushOnExpressionStack(markerAnnotation);
4078 if(!this.statementRecoveryActivated &&
4079 options.sourceLevel < ClassFileConstants.JDK1_5 &&
4080 this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
4081 this.problemReporter().invalidUsageOfAnnotation(markerAnnotation);
4082 }
4083 this.recordStringLiterals = true;
4084}
4085protected void consumeMemberValueArrayInitializer() {
4086 arrayInitializer(this.expressionLengthStack[this.expressionLengthPtr--]);
4089}
4090protected void consumeMemberValueAsName() {
4091 pushOnExpressionStack(getUnspecifiedReferenceOptimized());
4092}
4093protected void consumeMemberValuePair() {
4094 char[] simpleName = this.identifierStack[this.identifierPtr];
4096 long position = this.identifierPositionStack[this.identifierPtr--];
4097 this.identifierLengthPtr--;
4098 int end = (int) position;
4099 int start = (int) (position >>> 32);
4100 Expression value = this.expressionStack[this.expressionPtr--];
4101 this.expressionLengthPtr--;
4102 MemberValuePair memberValuePair = new MemberValuePair(simpleName, start, end, value);
4103 pushOnAstStack(memberValuePair);
4104}
4105protected void consumeMemberValuePairs() {
4106 concatNodeLists();
4108}
4109protected void consumeMemberValues() {
4110 concatExpressionLists();
4112}
4113protected void consumeMethodBody() {
4114 this.nestedMethod[this.nestedType] --;
4116}
4117protected void consumeMethodDeclaration(boolean isNotAbstract) {
4118
4121
4130
4131 int length;
4132 if (isNotAbstract) {
4133 this.intPtr--;
4135 this.intPtr--;
4136 }
4137
4138 int explicitDeclarations = 0;
4139 Statement[] statements = null;
4140 if (isNotAbstract) {
4141 explicitDeclarations = this.realBlockStack[this.realBlockPtr--];
4143 if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
4144 System.arraycopy(
4145 this.astStack,
4146 (this.astPtr -= length) + 1,
4147 statements = new Statement[length],
4148 0,
4149 length);
4150 }
4151 }
4152
4153 MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];
4155 md.statements = statements;
4156 md.explicitDeclarations = explicitDeclarations;
4157
4158 if (!isNotAbstract) { md.modifiers |= ExtraCompilerModifiers.AccSemicolonBody;
4162 } else if (!(this.diet && this.dietInt == 0) && statements == null && !containsComment(md.bodyStart, this.endPosition)) {
4163 md.bits |= ASTNode.UndocumentedEmptyBlock;
4164 }
4165 md.bodyEnd = this.endPosition;
4168 md.declarationSourceEnd = flushCommentsDefinedPriorTo(this.endStatementPosition);
4169}
4170protected void consumeMethodHeader() {
4171
4176 AbstractMethodDeclaration method = (AbstractMethodDeclaration)this.astStack[this.astPtr];
4178
4179 if (this.currentToken == TokenNameLBRACE){
4180 method.bodyStart = this.scanner.currentPosition;
4181 }
4182 if (this.currentElement != null){
4184 if (this.currentToken == TokenNameSEMICOLON ){
4191 method.modifiers |= ExtraCompilerModifiers.AccSemicolonBody;
4192 method.declarationSourceEnd = this.scanner.currentPosition-1;
4193 method.bodyEnd = this.scanner.currentPosition-1;
4194 if (this.currentElement.parseTree() == method && this.currentElement.parent != null) {
4195 this.currentElement = this.currentElement.parent;
4196 }
4197 } else if(this.currentToken == TokenNameLBRACE) {
4198 if (this.currentElement instanceof RecoveredMethod &&
4199 ((RecoveredMethod)this.currentElement).methodDeclaration != method) {
4200 this.ignoreNextOpeningBrace = true;
4201 this.currentElement.bracketBalance++;
4202 }
4203 }
4204 this.restartRecovery = true; }
4206}
4207protected void consumeMethodHeaderDefaultValue() {
4208 MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];
4210
4211
4212 int length = this.expressionLengthStack[this.expressionLengthPtr--];
4213 if (length == 1) {
4214 intPtr--; intPtr--; if(md.isAnnotationMethod()) {
4217 ((AnnotationMethodDeclaration)md).defaultValue = this.expressionStack[this.expressionPtr];
4218 md.modifiers |= ClassFileConstants.AccAnnotationDefault;
4219 }
4220 this.expressionPtr--;
4221 this.recordStringLiterals = true;
4222 }
4223
4224 if(this.currentElement != null) {
4225 if(md.isAnnotationMethod()) {
4226 this.currentElement.updateSourceEndIfNecessary(((AnnotationMethodDeclaration)md).defaultValue.sourceEnd);
4227 }
4228 }
4229}
4230protected void consumeMethodHeaderExtendedDims() {
4231 MethodDeclaration md = (MethodDeclaration) this.astStack[this.astPtr];
4234 int extendedDims = this.intStack[this.intPtr--];
4235 if(md.isAnnotationMethod()) {
4236 ((AnnotationMethodDeclaration)md).extendedDimensions = extendedDims;
4237 }
4238 if (extendedDims != 0) {
4239 TypeReference returnType = md.returnType;
4240 md.sourceEnd = this.endPosition;
4241 int dims = returnType.dimensions() + extendedDims;
4242 md.returnType = this.copyDims(returnType, dims);
4243 if (this.currentToken == TokenNameLBRACE){
4244 md.bodyStart = this.endPosition + 1;
4245 }
4246 if (this.currentElement != null){
4248 this.lastCheckPoint = md.bodyStart;
4249 }
4250 }
4251}
4252protected void consumeMethodHeaderName(boolean isAnnotationMethod) {
4253 MethodDeclaration md = null;
4257 if(isAnnotationMethod) {
4258 md = new AnnotationMethodDeclaration(this.compilationUnit.compilationResult);
4259 this.recordStringLiterals = false;
4260 } else {
4261 md = new MethodDeclaration(this.compilationUnit.compilationResult);
4262 }
4263
4264 md.selector = this.identifierStack[this.identifierPtr];
4266 long selectorSource = this.identifierPositionStack[this.identifierPtr--];
4267 this.identifierLengthPtr--;
4268 md.returnType = getTypeReference(this.intStack[this.intPtr--]);
4270 md.declarationSourceStart = this.intStack[this.intPtr--];
4272 md.modifiers = this.intStack[this.intPtr--];
4273 int length;
4275 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
4276 System.arraycopy(
4277 this.expressionStack,
4278 (this.expressionPtr -= length) + 1,
4279 md.annotations = new Annotation[length],
4280 0,
4281 length);
4282 }
4283 md.javadoc = this.javadoc;
4285 this.javadoc = null;
4286
4287 md.sourceStart = (int) (selectorSource >>> 32);
4289 pushOnAstStack(md);
4290 md.sourceEnd = this.lParenPos;
4291 md.bodyStart = this.lParenPos+1;
4292 this.listLength = 0;
4294 if (this.currentElement != null){
4296 if (this.currentElement instanceof RecoveredType
4297 || (Util.getLineNumber(md.returnType.sourceStart, this.scanner.lineEnds, 0, this.scanner.linePtr)
4299 == Util.getLineNumber(md.sourceStart, this.scanner.lineEnds, 0, this.scanner.linePtr))){
4300 this.lastCheckPoint = md.bodyStart;
4301 this.currentElement = this.currentElement.add(md, 0);
4302 this.lastIgnoredToken = -1;
4303 } else {
4304 this.lastCheckPoint = md.sourceStart;
4305 this.restartRecovery = true;
4306 }
4307 }
4308}
4309protected void consumeMethodHeaderNameWithTypeParameters(boolean isAnnotationMethod) {
4310 MethodDeclaration md = null;
4314 if(isAnnotationMethod) {
4315 md = new AnnotationMethodDeclaration(this.compilationUnit.compilationResult);
4316 this.recordStringLiterals = false;
4317 } else {
4318 md = new MethodDeclaration(this.compilationUnit.compilationResult);
4319 }
4320
4321 md.selector = this.identifierStack[this.identifierPtr];
4323 long selectorSource = this.identifierPositionStack[this.identifierPtr--];
4324 this.identifierLengthPtr--;
4325 md.returnType = getTypeReference(this.intStack[this.intPtr--]);
4327
4328 int length = this.genericsLengthStack[this.genericsLengthPtr--];
4330 this.genericsPtr -= length;
4331 System.arraycopy(this.genericsStack, this.genericsPtr + 1, md.typeParameters = new TypeParameter[length], 0, length);
4332
4333 md.declarationSourceStart = this.intStack[this.intPtr--];
4335 md.modifiers = this.intStack[this.intPtr--];
4336 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
4338 System.arraycopy(
4339 this.expressionStack,
4340 (this.expressionPtr -= length) + 1,
4341 md.annotations = new Annotation[length],
4342 0,
4343 length);
4344 }
4345 md.javadoc = this.javadoc;
4347 this.javadoc = null;
4348
4349 md.sourceStart = (int) (selectorSource >>> 32);
4351 pushOnAstStack(md);
4352 md.sourceEnd = this.lParenPos;
4353 md.bodyStart = this.lParenPos+1;
4354 this.listLength = 0;
4356 if (this.currentElement != null){
4358 boolean isType;
4359 if ((isType = this.currentElement instanceof RecoveredType)
4360 || (Util.getLineNumber(md.returnType.sourceStart, this.scanner.lineEnds, 0, this.scanner.linePtr)
4362 == Util.getLineNumber(md.sourceStart, this.scanner.lineEnds, 0, this.scanner.linePtr))){
4363 if(isType) {
4364 ((RecoveredType) this.currentElement).pendingTypeParameters = null;
4365 }
4366 this.lastCheckPoint = md.bodyStart;
4367 this.currentElement = this.currentElement.add(md, 0);
4368 this.lastIgnoredToken = -1;
4369 } else {
4370 this.lastCheckPoint = md.sourceStart;
4371 this.restartRecovery = true;
4372 }
4373 }
4374}
4375protected void consumeMethodHeaderRightParen() {
4376 int length = this.astLengthStack[this.astLengthPtr--];
4378 this.astPtr -= length;
4379 AbstractMethodDeclaration md = (AbstractMethodDeclaration) this.astStack[this.astPtr];
4380 md.sourceEnd = this.rParenPos;
4381 if (length != 0) {
4383 System.arraycopy(
4384 this.astStack,
4385 this.astPtr + 1,
4386 md.arguments = new Argument[length],
4387 0,
4388 length);
4389 }
4390 md.bodyStart = this.rParenPos+1;
4391 this.listLength = 0; if (this.currentElement != null){
4394 this.lastCheckPoint = md.bodyStart;
4395 if (this.currentElement.parseTree() == md) return;
4396
4397 if (md.isConstructor()){
4399 if ((length != 0)
4400 || (this.currentToken == TokenNameLBRACE)
4401 || (this.currentToken == TokenNamethrows)){
4402 this.currentElement = this.currentElement.add(md, 0);
4403 this.lastIgnoredToken = -1;
4404 }
4405 }
4406 }
4407}
4408protected void consumeMethodHeaderThrowsClause() {
4409 int length = this.astLengthStack[this.astLengthPtr--];
4411 this.astPtr -= length;
4412 AbstractMethodDeclaration md = (AbstractMethodDeclaration) this.astStack[this.astPtr];
4413 System.arraycopy(
4414 this.astStack,
4415 this.astPtr + 1,
4416 md.thrownExceptions = new TypeReference[length],
4417 0,
4418 length);
4419 md.sourceEnd = md.thrownExceptions[length-1].sourceEnd;
4420 md.bodyStart = md.thrownExceptions[length-1].sourceEnd + 1;
4421 this.listLength = 0; if (this.currentElement != null){
4424 this.lastCheckPoint = md.bodyStart;
4425 }
4426}
4427protected void consumeMethodInvocationName() {
4428
4430
4432 MessageSend m = newMessageSend();
4433 m.sourceEnd = this.rParenPos;
4434 m.sourceStart =
4435 (int) ((m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr]) >>> 32);
4436 m.selector = this.identifierStack[this.identifierPtr--];
4437 if (this.identifierLengthStack[this.identifierLengthPtr] == 1) {
4438 m.receiver = ThisReference.implicitThis();
4439 this.identifierLengthPtr--;
4440 } else {
4441 this.identifierLengthStack[this.identifierLengthPtr]--;
4442 m.receiver = getUnspecifiedReference();
4443 m.sourceStart = m.receiver.sourceStart;
4444 }
4445 pushOnExpressionStack(m);
4446}
4447protected void consumeMethodInvocationNameWithTypeArguments() {
4448
4450
4452 MessageSend m = newMessageSendWithTypeArguments();
4453 m.sourceEnd = this.rParenPos;
4454 m.sourceStart =
4455 (int) ((m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr]) >>> 32);
4456 m.selector = this.identifierStack[this.identifierPtr--];
4457 this.identifierLengthPtr--;
4458
4459 int length = this.genericsLengthStack[this.genericsLengthPtr--];
4461 this.genericsPtr -= length;
4462 System.arraycopy(this.genericsStack, this.genericsPtr + 1, m.typeArguments = new TypeReference[length], 0, length);
4463 intPtr--;
4464
4465 m.receiver = getUnspecifiedReference();
4466 m.sourceStart = m.receiver.sourceStart;
4467 pushOnExpressionStack(m);
4468}
4469protected void consumeMethodInvocationPrimary() {
4470
4473 MessageSend m = newMessageSend();
4474 m.sourceStart =
4475 (int) ((m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr]) >>> 32);
4476 m.selector = this.identifierStack[this.identifierPtr--];
4477 this.identifierLengthPtr--;
4478 m.receiver = this.expressionStack[this.expressionPtr];
4479 m.sourceStart = m.receiver.sourceStart;
4480 m.sourceEnd = this.rParenPos;
4481 this.expressionStack[this.expressionPtr] = m;
4482}
4483protected void consumeMethodInvocationPrimaryWithTypeArguments() {
4484
4487 MessageSend m = newMessageSendWithTypeArguments();
4488 m.sourceStart =
4489 (int) ((m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr]) >>> 32);
4490 m.selector = this.identifierStack[this.identifierPtr--];
4491 this.identifierLengthPtr--;
4492
4493 int length = this.genericsLengthStack[this.genericsLengthPtr--];
4495 this.genericsPtr -= length;
4496 System.arraycopy(this.genericsStack, this.genericsPtr + 1, m.typeArguments = new TypeReference[length], 0, length);
4497 intPtr--;
4498
4499 m.receiver = this.expressionStack[this.expressionPtr];
4500 m.sourceStart = m.receiver.sourceStart;
4501 m.sourceEnd = this.rParenPos;
4502 this.expressionStack[this.expressionPtr] = m;
4503}
4504protected void consumeMethodInvocationSuper() {
4505
4507 MessageSend m = newMessageSend();
4508 m.sourceStart = this.intStack[this.intPtr--]; m.sourceEnd = this.rParenPos;
4510 m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr];
4511 m.selector = this.identifierStack[this.identifierPtr--];
4512 this.identifierLengthPtr--;
4513 m.receiver = new SuperReference(m.sourceStart, this.endPosition);
4514 pushOnExpressionStack(m);
4515}
4516protected void consumeMethodInvocationSuperWithTypeArguments() {
4517
4519 MessageSend m = newMessageSendWithTypeArguments();
4520 intPtr--; m.sourceEnd = this.rParenPos;
4522 m.nameSourcePosition = this.identifierPositionStack[this.identifierPtr];
4523 m.selector = this.identifierStack[this.identifierPtr--];
4524 this.identifierLengthPtr--;
4525
4526 int length = this.genericsLengthStack[this.genericsLengthPtr--];
4528 this.genericsPtr -= length;
4529 System.arraycopy(this.genericsStack, this.genericsPtr + 1, m.typeArguments = new TypeReference[length], 0, length);
4530 m.sourceStart = this.intStack[this.intPtr--];
4532 m.receiver = new SuperReference(m.sourceStart, this.endPosition);
4533 pushOnExpressionStack(m);
4534}
4535protected void consumeModifiers() {
4536 int savedModifiersSourceStart = this.modifiersSourceStart;
4537 checkComment(); pushOnIntStack(this.modifiers); if (this.modifiersSourceStart >= savedModifiersSourceStart) {
4540 this.modifiersSourceStart = savedModifiersSourceStart;
4541 }
4542 pushOnIntStack(this.modifiersSourceStart);
4543 resetModifiers();
4544}
4545protected void consumeModifiers2() {
4546 this.expressionLengthStack[this.expressionLengthPtr - 1] += this.expressionLengthStack[this.expressionLengthPtr--];
4547}
4548protected void consumeNameArrayType() {
4549 pushOnGenericsLengthStack(0); pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
4551}
4552protected void consumeNestedMethod() {
4553 jumpOverMethodBody();
4555 this.nestedMethod[this.nestedType] ++;
4556 pushOnIntStack(this.scanner.currentPosition);
4557 consumeOpenBlock();
4558}
4559protected void consumeNestedType() {
4560 int length = this.nestedMethod.length;
4562 if (++this.nestedType >= length) {
4563 System.arraycopy(
4564 this.nestedMethod, 0,
4565 this.nestedMethod = new int[length + 30], 0,
4566 length);
4567 System.arraycopy(
4569 this.variablesCounter, 0,
4570 this.variablesCounter = new int[length + 30], 0,
4571 length);
4572 }
4573 this.nestedMethod[this.nestedType] = 0;
4574 this.variablesCounter[this.nestedType] = 0;
4575}
4576protected void consumeNormalAnnotation() {
4577 NormalAnnotation normalAnnotation = null;
4579 TypeReference typeReference = this.getAnnotationType();
4580 normalAnnotation = new NormalAnnotation(typeReference, this.intStack[this.intPtr--]);
4581 int length;
4582 if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
4583 System.arraycopy(
4584 this.astStack,
4585 (this.astPtr -= length) + 1,
4586 normalAnnotation.memberValuePairs = new MemberValuePair[length],
4587 0,
4588 length);
4589 }
4590 normalAnnotation.declarationSourceEnd = this.rParenPos;
4591 pushOnExpressionStack(normalAnnotation);
4592
4593 if(this.currentElement != null) {
4594 annotationRecoveryCheckPoint(normalAnnotation.sourceStart, normalAnnotation.declarationSourceEnd);
4595 }
4596
4597 if(!this.statementRecoveryActivated &&
4598 options.sourceLevel < ClassFileConstants.JDK1_5 &&
4599 this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
4600 this.problemReporter().invalidUsageOfAnnotation(normalAnnotation);
4601 }
4602 this.recordStringLiterals = true;
4603}
4604protected void consumeOneDimLoop() {
4605 this.dimensions++;
4607}
4608protected void consumeOnlySynchronized() {
4609 pushOnIntStack(this.synchronizedBlockSourceStart);
4611 resetModifiers();
4612 this.expressionLengthPtr--;
4613}
4614protected void consumeOnlyTypeArguments() {
4615 if(!this.statementRecoveryActivated &&
4616 options.sourceLevel < ClassFileConstants.JDK1_5 &&
4617 this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
4618 int length = this.genericsLengthStack[this.genericsLengthPtr];
4619 this.problemReporter().invalidUsageOfTypeArguments(
4620 (TypeReference)this.genericsStack[this.genericsPtr - length + 1],
4621 (TypeReference)this.genericsStack[this.genericsPtr]);
4622 }
4623}
4624protected void consumeOnlyTypeArgumentsForCastExpression() {
4625 }
4627protected void consumeOpenBlock() {
4628
4630 pushOnIntStack(this.scanner.startPosition);
4631 int stackLength = this.realBlockStack.length;
4632 if (++this.realBlockPtr >= stackLength) {
4633 System.arraycopy(
4634 this.realBlockStack, 0,
4635 this.realBlockStack = new int[stackLength + StackIncrement], 0,
4636 stackLength);
4637 }
4638 this.realBlockStack[this.realBlockPtr] = 0;
4639}
4640protected void consumePackageComment() {
4641 if(options.sourceLevel >= ClassFileConstants.JDK1_5) {
4643 checkComment();
4644 resetModifiers();
4645 }
4646}
4647protected void consumePackageDeclaration() {
4648
4651
4652 ImportReference impt = this.compilationUnit.currentPackage;
4653 this.compilationUnit.javadoc = this.javadoc;
4654 this.javadoc = null;
4655 impt.declarationEnd = this.endStatementPosition;
4657 impt.declarationSourceEnd = this.flushCommentsDefinedPriorTo(impt.declarationSourceEnd);
4658}
4659protected void consumePackageDeclarationName() {
4660
4663
4664 ImportReference impt;
4665 int length;
4666 char[][] tokens =
4667 new char[length = this.identifierLengthStack[this.identifierLengthPtr--]][];
4668 this.identifierPtr -= length;
4669 long[] positions = new long[length];
4670 System.arraycopy(this.identifierStack, ++this.identifierPtr, tokens, 0, length);
4671 System.arraycopy(
4672 this.identifierPositionStack,
4673 this.identifierPtr--,
4674 positions,
4675 0,
4676 length);
4677
4678 impt = new ImportReference(tokens, positions, true, ClassFileConstants.AccDefault);
4679 this.compilationUnit.currentPackage = impt;
4680
4681 if (this.currentToken == TokenNameSEMICOLON){
4682 impt.declarationSourceEnd = this.scanner.currentPosition - 1;
4683 } else {
4684 impt.declarationSourceEnd = impt.sourceEnd;
4685 }
4686 impt.declarationEnd = impt.declarationSourceEnd;
4687 impt.declarationSourceStart = this.intStack[this.intPtr--];
4689
4690 if(this.javadoc != null) {
4692 impt.declarationSourceStart = this.javadoc.sourceStart;
4693 }
4694
4695 if (this.currentElement != null){
4697 this.lastCheckPoint = impt.declarationSourceEnd+1;
4698 this.restartRecovery = true; }
4700}
4701protected void consumePackageDeclarationNameWithModifiers() {
4702
4705
4706 ImportReference impt;
4707 int length;
4708 char[][] tokens =
4709 new char[length = this.identifierLengthStack[this.identifierLengthPtr--]][];
4710 this.identifierPtr -= length;
4711 long[] positions = new long[length];
4712 System.arraycopy(this.identifierStack, ++this.identifierPtr, tokens, 0, length);
4713 System.arraycopy(
4714 this.identifierPositionStack,
4715 this.identifierPtr--,
4716 positions,
4717 0,
4718 length);
4719
4720 int packageModifiersSourceStart = this.intStack[this.intPtr--]; int packageModifiers = this.intStack[this.intPtr--];
4722
4723 impt = new ImportReference(tokens, positions, true, packageModifiers);
4724 this.compilationUnit.currentPackage = impt;
4725 if ((length = this.expressionLengthStack[this.expressionLengthPtr--]) != 0) {
4727 System.arraycopy(
4728 this.expressionStack,
4729 (this.expressionPtr -= length) + 1,
4730 impt.annotations = new Annotation[length],
4731 0,
4732 length);
4733 impt.declarationSourceStart = packageModifiersSourceStart;
4734 intPtr--; } else {
4736 impt.declarationSourceStart = this.intStack[this.intPtr--];
4737 if (this.javadoc != null) {
4739 impt.declarationSourceStart = this.javadoc.sourceStart;
4740 }
4741 }
4742
4743 if (this.currentToken == TokenNameSEMICOLON){
4744 impt.declarationSourceEnd = this.scanner.currentPosition - 1;
4745 } else {
4746 impt.declarationSourceEnd = impt.sourceEnd;
4747 }
4748 impt.declarationEnd = impt.declarationSourceEnd;
4749
4750 if (this.currentElement != null){
4752 this.lastCheckPoint = impt.declarationSourceEnd+1;
4753 this.restartRecovery = true; }
4755}
4756protected void consumePostfixExpression() {
4757 pushOnExpressionStack(getUnspecifiedReferenceOptimized());
4759}
4760protected void consumePrimaryNoNewArray() {
4761 final Expression parenthesizedExpression = this.expressionStack[this.expressionPtr];
4763 updateSourcePosition(parenthesizedExpression);
4764 int numberOfParenthesis = (parenthesizedExpression.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT;
4765 parenthesizedExpression.bits &= ~ASTNode.ParenthesizedMASK;
4766 parenthesizedExpression.bits |= (numberOfParenthesis + 1) << ASTNode.ParenthesizedSHIFT;
4767}
4768protected void consumePrimaryNoNewArrayArrayType() {
4769 this.intPtr--;
4772 pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
4773 pushOnGenericsLengthStack(0);
4774
4775 pushOnExpressionStack(
4776 new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(this.intStack[this.intPtr--])));
4777}
4778protected void consumePrimaryNoNewArrayName() {
4779 this.intPtr--;
4782 pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
4784 pushOnGenericsLengthStack(0);
4785 TypeReference typeReference = getTypeReference(0);
4786
4787 pushOnExpressionStack(
4788 new ClassLiteralAccess(this.intStack[this.intPtr--], typeReference));
4789}
4790protected void consumePrimaryNoNewArrayNameSuper() {
4791 pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
4794 pushOnGenericsLengthStack(0);
4795 TypeReference typeReference = getTypeReference(0);
4796
4797 pushOnExpressionStack(
4798 new QualifiedSuperReference(
4799 typeReference,
4800 this.intStack[this.intPtr--],
4801 this.endPosition));
4802}
4803protected void consumePrimaryNoNewArrayNameThis() {
4804 pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
4807 pushOnGenericsLengthStack(0);
4809 TypeReference typeReference = getTypeReference(0);
4810
4811 pushOnExpressionStack(
4812 new QualifiedThisReference(
4813 typeReference,
4814 this.intStack[this.intPtr--],
4815 this.endPosition));
4816}
4817protected void consumePrimaryNoNewArrayPrimitiveArrayType() {
4818 this.intPtr--; pushOnExpressionStack(
4821 new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(this.intStack[this.intPtr--])));
4822}
4823protected void consumePrimaryNoNewArrayPrimitiveType() {
4824 this.intPtr--; pushOnExpressionStack(
4827 new ClassLiteralAccess(this.intStack[this.intPtr--], getTypeReference(0)));
4828}
4829protected void consumePrimaryNoNewArrayThis() {
4830 pushOnExpressionStack(new ThisReference(this.intStack[this.intPtr--], this.endPosition));
4832}
4833protected void consumePrimaryNoNewArrayWithName() {
4834 pushOnExpressionStack(getUnspecifiedReferenceOptimized());
4836 final Expression parenthesizedExpression = this.expressionStack[this.expressionPtr];
4837 updateSourcePosition(parenthesizedExpression);
4838 int numberOfParenthesis = (parenthesizedExpression.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT;
4839 parenthesizedExpression.bits &= ~ASTNode.ParenthesizedMASK;
4840 parenthesizedExpression.bits |= (numberOfParenthesis + 1) << ASTNode.ParenthesizedSHIFT;
4841}
4842protected void consumePrimitiveArrayType() {
4843 }
4846protected void consumePrimitiveType() {
4847 pushOnIntStack(0);
4849}
4850protected void consumePushLeftBrace() {
4851 pushOnIntStack(this.endPosition); }
4853protected void consumePushRealModifiers() {
4854 checkComment(); pushOnIntStack(this.modifiers); pushOnIntStack(this.modifiersSourceStart);
4857 resetModifiers();
4858}
4859protected void consumePushModifiers() {
4860 pushOnIntStack(this.modifiers); pushOnIntStack(this.modifiersSourceStart);
4862 resetModifiers();
4863 pushOnExpressionStackLengthStack(0);
4864}
4865protected void consumePushModifiersForHeader() {
4866 checkComment(); pushOnIntStack(this.modifiers); pushOnIntStack(this.modifiersSourceStart);
4869 resetModifiers();
4870 pushOnExpressionStackLengthStack(0);
4871}
4872protected void consumePushPosition() {
4873 pushOnIntStack(this.endPosition);
4876}
4877protected void consumeQualifiedName() {
4878
4881
4882 this.identifierLengthStack[--this.identifierLengthPtr]++;
4883}
4884protected void consumeRecoveryMethodHeaderName() {
4885 boolean isAnnotationMethod = false;
4887 if(this.currentElement instanceof RecoveredType) {
4888 isAnnotationMethod = (((RecoveredType)this.currentElement).typeDeclaration.modifiers & ClassFileConstants.AccAnnotation) != 0;
4889 } else {
4890 RecoveredType recoveredType = this.currentElement.enclosingType();
4891 if(recoveredType != null) {
4892 isAnnotationMethod = (recoveredType.typeDeclaration.modifiers & ClassFileConstants.AccAnnotation) != 0;
4893 }
4894 }
4895 this.consumeMethodHeaderName(isAnnotationMethod);
4896}
4897protected void consumeRecoveryMethodHeaderNameWithTypeParameters() {
4898 boolean isAnnotationMethod = false;
4900 if(this.currentElement instanceof RecoveredType) {
4901 isAnnotationMethod = (((RecoveredType)this.currentElement).typeDeclaration.modifiers & ClassFileConstants.AccAnnotation) != 0;
4902 } else {
4903 RecoveredType recoveredType = this.currentElement.enclosingType();
4904 if(recoveredType != null) {
4905 isAnnotationMethod = (recoveredType.typeDeclaration.modifiers & ClassFileConstants.AccAnnotation) != 0;
4906 }
4907 }
4908 this.consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod);
4909}
4910protected void consumeReduceImports() {
4911 int length;
4913 if ((length = this.astLengthStack[this.astLengthPtr--]) != 0) {
4914 this.astPtr -= length;
4915 System.arraycopy(
4916 this.astStack,
4917 this.astPtr + 1,
4918 this.compilationUnit.imports = new ImportReference[length],
4919 0,
4920 length);
4921 }
4922}
4923protected void consumeReferenceType() {
4924 pushOnIntStack(0); }
4926protected void consumeReferenceType1() {
4927 pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));
4928}
4929protected void consumeReferenceType2() {
4930 pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));
4931}
4932protected void consumeReferenceType3() {
4933 pushOnGenericsStack(getTypeReference(this.intStack[this.intPtr--]));
4934}
4935protected void consumeRestoreDiet() {
4936 this.dietInt--;
4938}
4939protected void consumeRightParen() {
4940 pushOnIntStack(this.rParenPos);
4942}
4943protected void consumeRule(int act) {
4945 switch ( act ) {
4946 case 30 : if (DEBUG) { System.out.println("Type ::= PrimitiveType"); } consumePrimitiveType();
4948 break;
4949
4950 case 44 : if (DEBUG) { System.out.println("ReferenceType ::= ClassOrInterfaceType"); } consumeReferenceType();
4952 break;
4953
4954 case 48 : if (DEBUG) { System.out.println("ClassOrInterface ::= Name"); } consumeClassOrInterfaceName();
4956 break;
4957
4958 case 49 : if (DEBUG) { System.out.println("ClassOrInterface ::= GenericType DOT Name"); } consumeClassOrInterface();
4960 break;
4961
4962 case 50 : if (DEBUG) { System.out.println("GenericType ::= ClassOrInterface TypeArguments"); } consumeGenericType();
4964 break;
4965
4966 case 51 : if (DEBUG) { System.out.println("ArrayTypeWithTypeArgumentsName ::= GenericType DOT Name"); } consumeArrayTypeWithTypeArgumentsName();
4968 break;
4969
4970 case 52 : if (DEBUG) { System.out.println("ArrayType ::= PrimitiveType Dims"); } consumePrimitiveArrayType();
4972 break;
4973
4974 case 53 : if (DEBUG) { System.out.println("ArrayType ::= Name Dims"); } consumeNameArrayType();
4976 break;
4977
4978 case 54 : if (DEBUG) { System.out.println("ArrayType ::= ArrayTypeWithTypeArgumentsName Dims"); } consumeGenericTypeNameArrayType();
4980 break;
4981
4982 case 55 : if (DEBUG) { System.out.println("ArrayType ::= GenericType Dims"); } consumeGenericTypeArrayType();
4984 break;
4985
4986 case 60 : if (DEBUG) { System.out.println("QualifiedName ::= Name DOT SimpleName"); } consumeQualifiedName();
4988 break;
4989
4990 case 61 : if (DEBUG) { System.out.println("CompilationUnit ::= EnterCompilationUnit..."); } consumeCompilationUnit();
4992 break;
4993
4994 case 62 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration"); } consumeInternalCompilationUnit();
4996 break;
4997
4998 case 63 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } consumeInternalCompilationUnit();
5000 break;
5001
5002 case 64 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } consumeInternalCompilationUnitWithTypes();
5004 break;
5005
5006 case 65 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); } consumeInternalCompilationUnitWithTypes();
5008 break;
5009
5010 case 66 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } consumeInternalCompilationUnit();
5012 break;
5013
5014 case 67 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= TypeDeclarations"); } consumeInternalCompilationUnitWithTypes();
5016 break;
5017
5018 case 68 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); } consumeInternalCompilationUnitWithTypes();
5020 break;
5021
5022 case 69 : if (DEBUG) { System.out.println("InternalCompilationUnit ::="); } consumeEmptyInternalCompilationUnit();
5024 break;
5025
5026 case 70 : if (DEBUG) { System.out.println("ReduceImports ::="); } consumeReduceImports();
5028 break;
5029
5030 case 71 : if (DEBUG) { System.out.println("EnterCompilationUnit ::="); } consumeEnterCompilationUnit();
5032 break;
5033
5034 case 87 : if (DEBUG) { System.out.println("CatchHeader ::= catch LPAREN FormalParameter RPAREN..."); } consumeCatchHeader();
5036 break;
5037
5038 case 89 : if (DEBUG) { System.out.println("ImportDeclarations ::= ImportDeclarations..."); } consumeImportDeclarations();
5040 break;
5041
5042 case 91 : if (DEBUG) { System.out.println("TypeDeclarations ::= TypeDeclarations TypeDeclaration"); } consumeTypeDeclarations();
5044 break;
5045
5046 case 92 : if (DEBUG) { System.out.println("PackageDeclaration ::= PackageDeclarationName SEMICOLON"); } consumePackageDeclaration();
5048 break;
5049
5050 case 93 : if (DEBUG) { System.out.println("PackageDeclarationName ::= Modifiers package..."); } consumePackageDeclarationNameWithModifiers();
5052 break;
5053
5054 case 94 : if (DEBUG) { System.out.println("PackageDeclarationName ::= PackageComment package Name"); } consumePackageDeclarationName();
5056 break;
5057
5058 case 95 : if (DEBUG) { System.out.println("PackageComment ::="); } consumePackageComment();
5060 break;
5061
5062 case 100 : if (DEBUG) { System.out.println("SingleTypeImportDeclaration ::=..."); } consumeImportDeclaration();
5064 break;
5065
5066 case 101 : if (DEBUG) { System.out.println("SingleTypeImportDeclarationName ::= import Name"); } consumeSingleTypeImportDeclarationName();
5068 break;
5069
5070 case 102 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclaration ::=..."); } consumeImportDeclaration();
5072 break;
5073
5074 case 103 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclarationName ::= import Name DOT..."); } consumeTypeImportOnDemandDeclarationName();
5076 break;
5077
5078 case 106 : if (DEBUG) { System.out.println("TypeDeclaration ::= SEMICOLON"); } consumeEmptyTypeDeclaration();
5080 break;
5081
5082 case 110 : if (DEBUG) { System.out.println("Modifiers ::= Modifiers Modifier"); } consumeModifiers2();
5084 break;
5085
5086 case 122 : if (DEBUG) { System.out.println("Modifier ::= Annotation"); } consumeAnnotationAsModifier();
5088 break;
5089
5090 case 123 : if (DEBUG) { System.out.println("ClassDeclaration ::= ClassHeader ClassBody"); } consumeClassDeclaration();
5092 break;
5093
5094 case 124 : if (DEBUG) { System.out.println("ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt..."); } consumeClassHeader();
5096 break;
5097
5098 case 125 : if (DEBUG) { System.out.println("ClassHeaderName ::= ClassHeaderName1 TypeParameters"); } consumeTypeHeaderNameWithTypeParameters();
5100 break;
5101
5102 case 127 : if (DEBUG) { System.out.println("ClassHeaderName1 ::= Modifiersopt class Identifier"); } consumeClassHeaderName1();
5104 break;
5105
5106 case 128 : if (DEBUG) { System.out.println("ClassHeaderExtends ::= extends ClassType"); } consumeClassHeaderExtends();
5108 break;
5109
5110 case 129 : if (DEBUG) { System.out.println("ClassHeaderImplements ::= implements InterfaceTypeList"); } consumeClassHeaderImplements();
5112 break;
5113
5114 case 131 : if (DEBUG) { System.out.println("InterfaceTypeList ::= InterfaceTypeList COMMA..."); } consumeInterfaceTypeList();
5116 break;
5117
5118 case 132 : if (DEBUG) { System.out.println("InterfaceType ::= ClassOrInterfaceType"); } consumeInterfaceType();
5120 break;
5121
5122 case 135 : if (DEBUG) { System.out.println("ClassBodyDeclarations ::= ClassBodyDeclarations..."); } consumeClassBodyDeclarations();
5124 break;
5125
5126 case 139 : if (DEBUG) { System.out.println("ClassBodyDeclaration ::= Diet NestedMethod Block"); } consumeClassBodyDeclaration();
5128 break;
5129
5130 case 140 : if (DEBUG) { System.out.println("Diet ::="); } consumeDiet();
5132 break;
5133
5134 case 141 : if (DEBUG) { System.out.println("Initializer ::= Diet NestedMethod Block"); } consumeClassBodyDeclaration();
5136 break;
5137
5138 case 148 : if (DEBUG) { System.out.println("ClassMemberDeclaration ::= SEMICOLON"); } consumeEmptyTypeDeclaration();
5140 break;
5141
5142 case 151 : if (DEBUG) { System.out.println("FieldDeclaration ::= Modifiersopt Type..."); } consumeFieldDeclaration();
5144 break;
5145
5146 case 153 : if (DEBUG) { System.out.println("VariableDeclarators ::= VariableDeclarators COMMA..."); } consumeVariableDeclarators();
5148 break;
5149
5150 case 156 : if (DEBUG) { System.out.println("EnterVariable ::="); } consumeEnterVariable();
5152 break;
5153
5154 case 157 : if (DEBUG) { System.out.println("ExitVariableWithInitialization ::="); } consumeExitVariableWithInitialization();
5156 break;
5157
5158 case 158 : if (DEBUG) { System.out.println("ExitVariableWithoutInitialization ::="); } consumeExitVariableWithoutInitialization();
5160 break;
5161
5162 case 159 : if (DEBUG) { System.out.println("ForceNoDiet ::="); } consumeForceNoDiet();
5164 break;
5165
5166 case 160 : if (DEBUG) { System.out.println("RestoreDiet ::="); } consumeRestoreDiet();
5168 break;
5169
5170 case 165 : if (DEBUG) { System.out.println("MethodDeclaration ::= MethodHeader MethodBody"); } consumeMethodDeclaration(true);
5173 break;
5174
5175 case 166 : if (DEBUG) { System.out.println("AbstractMethodDeclaration ::= MethodHeader SEMICOLON"); } consumeMethodDeclaration(false);
5178 break;
5179
5180 case 167 : if (DEBUG) { System.out.println("MethodHeader ::= MethodHeaderName FormalParameterListopt"); } consumeMethodHeader();
5182 break;
5183
5184 case 168 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt TypeParameters Type..."); } consumeMethodHeaderNameWithTypeParameters(false);
5186 break;
5187
5188 case 169 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt Type Identifier LPAREN"); } consumeMethodHeaderName(false);
5190 break;
5191
5192 case 170 : if (DEBUG) { System.out.println("MethodHeaderRightParen ::= RPAREN"); } consumeMethodHeaderRightParen();
5194 break;
5195
5196 case 171 : if (DEBUG) { System.out.println("MethodHeaderExtendedDims ::= Dimsopt"); } consumeMethodHeaderExtendedDims();
5198 break;
5199
5200 case 172 : if (DEBUG) { System.out.println("MethodHeaderThrowsClause ::= throws ClassTypeList"); } consumeMethodHeaderThrowsClause();
5202 break;
5203
5204 case 173 : if (DEBUG) { System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); } consumeConstructorHeader();
5206 break;
5207
5208 case 174 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt TypeParameters..."); } consumeConstructorHeaderNameWithTypeParameters();
5210 break;
5211
5212 case 175 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt Identifier LPAREN"); } consumeConstructorHeaderName();
5214 break;
5215
5216 case 177 : if (DEBUG) { System.out.println("FormalParameterList ::= FormalParameterList COMMA..."); } consumeFormalParameterList();
5218 break;
5219
5220 case 178 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Type..."); } consumeFormalParameter(false);
5222 break;
5223
5224 case 179 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Type ELLIPSIS..."); } consumeFormalParameter(true);
5226 break;
5227
5228 case 181 : if (DEBUG) { System.out.println("ClassTypeList ::= ClassTypeList COMMA ClassTypeElt"); } consumeClassTypeList();
5230 break;
5231
5232 case 182 : if (DEBUG) { System.out.println("ClassTypeElt ::= ClassType"); } consumeClassTypeElt();
5234 break;
5235
5236 case 183 : if (DEBUG) { System.out.println("MethodBody ::= NestedMethod LBRACE BlockStatementsopt..."); } consumeMethodBody();
5238 break;
5239
5240 case 184 : if (DEBUG) { System.out.println("NestedMethod ::="); } consumeNestedMethod();
5242 break;
5243
5244 case 185 : if (DEBUG) { System.out.println("StaticInitializer ::= StaticOnly Block"); } consumeStaticInitializer();
5246 break;
5247
5248 case 186 : if (DEBUG) { System.out.println("StaticOnly ::= static"); } consumeStaticOnly();
5250 break;
5251
5252 case 187 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader MethodBody"); } consumeConstructorDeclaration() ;
5254 break;
5255
5256 case 188 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader SEMICOLON"); } consumeInvalidConstructorDeclaration() ;
5258 break;
5259
5260 case 189 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= this LPAREN..."); } consumeExplicitConstructorInvocation(0, THIS_CALL);
5262 break;
5263
5264 case 190 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments this"); } consumeExplicitConstructorInvocationWithTypeArguments(0,THIS_CALL);
5266 break;
5267
5268 case 191 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= super LPAREN..."); } consumeExplicitConstructorInvocation(0,SUPER_CALL);
5270 break;
5271
5272 case 192 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments..."); } consumeExplicitConstructorInvocationWithTypeArguments(0,SUPER_CALL);
5274 break;
5275
5276 case 193 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT super..."); } consumeExplicitConstructorInvocation(1, SUPER_CALL);
5278 break;
5279
5280 case 194 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } consumeExplicitConstructorInvocationWithTypeArguments(1, SUPER_CALL);
5282 break;
5283
5284 case 195 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT super LPAREN"); } consumeExplicitConstructorInvocation(2, SUPER_CALL);
5286 break;
5287
5288 case 196 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } consumeExplicitConstructorInvocationWithTypeArguments(2, SUPER_CALL);
5290 break;
5291
5292 case 197 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT this..."); } consumeExplicitConstructorInvocation(1, THIS_CALL);
5294 break;
5295
5296 case 198 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); } consumeExplicitConstructorInvocationWithTypeArguments(1, THIS_CALL);
5298 break;
5299
5300 case 199 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT this LPAREN"); } consumeExplicitConstructorInvocation(2, THIS_CALL);
5302 break;
5303
5304 case 200 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); } consumeExplicitConstructorInvocationWithTypeArguments(2, THIS_CALL);
5306 break;
5307
5308 case 201 : if (DEBUG) { System.out.println("InterfaceDeclaration ::= InterfaceHeader InterfaceBody"); } consumeInterfaceDeclaration();
5310 break;
5311
5312 case 202 : if (DEBUG) { System.out.println("InterfaceHeader ::= InterfaceHeaderName..."); } consumeInterfaceHeader();
5314 break;
5315
5316 case 203 : if (DEBUG) { System.out.println("InterfaceHeaderName ::= InterfaceHeaderName1..."); } consumeTypeHeaderNameWithTypeParameters();
5318 break;
5319
5320 case 205 : if (DEBUG) { System.out.println("InterfaceHeaderName1 ::= Modifiersopt interface..."); } consumeInterfaceHeaderName1();
5322 break;
5323
5324 case 206 : if (DEBUG) { System.out.println("InterfaceHeaderExtends ::= extends InterfaceTypeList"); } consumeInterfaceHeaderExtends();
5326 break;
5327
5328 case 209 : if (DEBUG) { System.out.println("InterfaceMemberDeclarations ::=..."); } consumeInterfaceMemberDeclarations();
5330 break;
5331
5332 case 210 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= SEMICOLON"); } consumeEmptyTypeDeclaration();
5334 break;
5335
5336 case 212 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= MethodHeader MethodBody"); } consumeInvalidMethodDeclaration();
5338 break;
5339
5340 case 213 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } consumeInvalidConstructorDeclaration(true);
5342 break;
5343
5344 case 214 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); } consumeInvalidConstructorDeclaration(false);
5346 break;
5347
5348 case 222 : if (DEBUG) { System.out.println("PushLeftBrace ::="); } consumePushLeftBrace();
5350 break;
5351
5352 case 223 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace ,opt RBRACE"); } consumeEmptyArrayInitializer();
5354 break;
5355
5356 case 224 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } consumeArrayInitializer();
5358 break;
5359
5360 case 225 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); } consumeArrayInitializer();
5362 break;
5363
5364 case 227 : if (DEBUG) { System.out.println("VariableInitializers ::= VariableInitializers COMMA..."); } consumeVariableInitializers();
5366 break;
5367
5368 case 228 : if (DEBUG) { System.out.println("Block ::= OpenBlock LBRACE BlockStatementsopt RBRACE"); } consumeBlock();
5370 break;
5371
5372 case 229 : if (DEBUG) { System.out.println("OpenBlock ::="); } consumeOpenBlock() ;
5374 break;
5375
5376 case 231 : if (DEBUG) { System.out.println("BlockStatements ::= BlockStatements BlockStatement"); } consumeBlockStatements() ;
5378 break;
5379
5380 case 235 : if (DEBUG) { System.out.println("BlockStatement ::= InterfaceDeclaration"); } consumeInvalidInterfaceDeclaration();
5382 break;
5383
5384 case 236 : if (DEBUG) { System.out.println("BlockStatement ::= AnnotationTypeDeclaration"); } consumeInvalidAnnotationTypeDeclaration();
5386 break;
5387
5388 case 237 : if (DEBUG) { System.out.println("BlockStatement ::= EnumDeclaration"); } consumeInvalidEnumDeclaration();
5390 break;
5391
5392 case 238 : if (DEBUG) { System.out.println("LocalVariableDeclarationStatement ::=..."); } consumeLocalVariableDeclarationStatement();
5394 break;
5395
5396 case 239 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Type PushModifiers..."); } consumeLocalVariableDeclaration();
5398 break;
5399
5400 case 240 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Modifiers Type..."); } consumeLocalVariableDeclaration();
5402 break;
5403
5404 case 241 : if (DEBUG) { System.out.println("PushModifiers ::="); } consumePushModifiers();
5406 break;
5407
5408 case 242 : if (DEBUG) { System.out.println("PushModifiersForHeader ::="); } consumePushModifiersForHeader();
5410 break;
5411
5412 case 243 : if (DEBUG) { System.out.println("PushRealModifiers ::="); } consumePushRealModifiers();
5414 break;
5415
5416 case 269 : if (DEBUG) { System.out.println("EmptyStatement ::= SEMICOLON"); } consumeEmptyStatement();
5418 break;
5419
5420 case 270 : if (DEBUG) { System.out.println("LabeledStatement ::= Label COLON Statement"); } consumeStatementLabel() ;
5422 break;
5423
5424 case 271 : if (DEBUG) { System.out.println("LabeledStatementNoShortIf ::= Label COLON..."); } consumeStatementLabel() ;
5426 break;
5427
5428 case 272 : if (DEBUG) { System.out.println("Label ::= Identifier"); } consumeLabel() ;
5430 break;
5431
5432 case 273 : if (DEBUG) { System.out.println("ExpressionStatement ::= StatementExpression SEMICOLON"); } consumeExpressionStatement();
5434 break;
5435
5436 case 282 : if (DEBUG) { System.out.println("IfThenStatement ::= if LPAREN Expression RPAREN..."); } consumeStatementIfNoElse();
5438 break;
5439
5440 case 283 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); } consumeStatementIfWithElse();
5442 break;
5443
5444 case 284 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); } consumeStatementIfWithElse();
5446 break;
5447
5448 case 285 : if (DEBUG) { System.out.println("SwitchStatement ::= switch LPAREN Expression RPAREN..."); } consumeStatementSwitch() ;
5450 break;
5451
5452 case 286 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE RBRACE"); } consumeEmptySwitchBlock() ;
5454 break;
5455
5456 case 289 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE SwitchBlockStatements..."); } consumeSwitchBlock() ;
5458 break;
5459
5460 case 291 : if (DEBUG) { System.out.println("SwitchBlockStatements ::= SwitchBlockStatements..."); } consumeSwitchBlockStatements() ;
5462 break;
5463
5464 case 292 : if (DEBUG) { System.out.println("SwitchBlockStatement ::= SwitchLabels BlockStatements"); } consumeSwitchBlockStatement() ;
5466 break;
5467
5468 case 294 : if (DEBUG) { System.out.println("SwitchLabels ::= SwitchLabels SwitchLabel"); } consumeSwitchLabels() ;
5470 break;
5471
5472 case 295 : if (DEBUG) { System.out.println("SwitchLabel ::= case ConstantExpression COLON"); } consumeCaseLabel();
5474 break;
5475
5476 case 296 : if (DEBUG) { System.out.println("SwitchLabel ::= default COLON"); } consumeDefaultLabel();
5478 break;
5479
5480 case 297 : if (DEBUG) { System.out.println("WhileStatement ::= while LPAREN Expression RPAREN..."); } consumeStatementWhile() ;
5482 break;
5483
5484 case 298 : if (DEBUG) { System.out.println("WhileStatementNoShortIf ::= while LPAREN Expression..."); } consumeStatementWhile() ;
5486 break;
5487
5488 case 299 : if (DEBUG) { System.out.println("DoStatement ::= do Statement while LPAREN Expression..."); } consumeStatementDo() ;
5490 break;
5491
5492 case 300 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInitopt SEMICOLON..."); } consumeStatementFor() ;
5494 break;
5495
5496 case 301 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInitopt..."); } consumeStatementFor() ;
5498 break;
5499
5500 case 302 : if (DEBUG) { System.out.println("ForInit ::= StatementExpressionList"); } consumeForInit() ;
5502 break;
5503
5504 case 306 : if (DEBUG) { System.out.println("StatementExpressionList ::= StatementExpressionList..."); } consumeStatementExpressionList() ;
5506 break;
5507
5508 case 307 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression SEMICOLON"); } consumeSimpleAssertStatement() ;
5510 break;
5511
5512 case 308 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression COLON Expression"); } consumeAssertStatement() ;
5514 break;
5515
5516 case 309 : if (DEBUG) { System.out.println("BreakStatement ::= break SEMICOLON"); } consumeStatementBreak() ;
5518 break;
5519
5520 case 310 : if (DEBUG) { System.out.println("BreakStatement ::= break Identifier SEMICOLON"); } consumeStatementBreakWithLabel() ;
5522 break;
5523
5524 case 311 : if (DEBUG) { System.out.println("ContinueStatement ::= continue SEMICOLON"); } consumeStatementContinue() ;
5526 break;
5527
5528 case 312 : if (DEBUG) { System.out.println("ContinueStatement ::= continue Identifier SEMICOLON"); } consumeStatementContinueWithLabel() ;
5530 break;
5531
5532 case 313 : if (DEBUG) { System.out.println("ReturnStatement ::= return Expressionopt SEMICOLON"); } consumeStatementReturn() ;
5534 break;
5535
5536 case 314 : if (DEBUG) { System.out.println("ThrowStatement ::= throw Expression SEMICOLON"); } consumeStatementThrow();
5538 break;
5539
5540 case 315 : if (DEBUG) { System.out.println("SynchronizedStatement ::= OnlySynchronized LPAREN..."); } consumeStatementSynchronized();
5542 break;
5543
5544 case 316 : if (DEBUG) { System.out.println("OnlySynchronized ::= synchronized"); } consumeOnlySynchronized();
5546 break;
5547
5548 case 317 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catches"); } consumeStatementTry(false);
5550 break;
5551
5552 case 318 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catchesopt Finally"); } consumeStatementTry(true);
5554 break;
5555
5556 case 320 : if (DEBUG) { System.out.println("ExitTryBlock ::="); } consumeExitTryBlock();
5558 break;
5559
5560 case 322 : if (DEBUG) { System.out.println("Catches ::= Catches CatchClause"); } consumeCatches();
5562 break;
5563
5564 case 323 : if (DEBUG) { System.out.println("CatchClause ::= catch LPAREN FormalParameter RPAREN..."); } consumeStatementCatch() ;
5566 break;
5567
5568 case 325 : if (DEBUG) { System.out.println("PushLPAREN ::= LPAREN"); } consumeLeftParen();
5570 break;
5571
5572 case 326 : if (DEBUG) { System.out.println("PushRPAREN ::= RPAREN"); } consumeRightParen();
5574 break;
5575
5576 case 331 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= this"); } consumePrimaryNoNewArrayThis();
5578 break;
5579
5580 case 332 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Expression_NotName..."); } consumePrimaryNoNewArray();
5582 break;
5583
5584 case 333 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Name PushRPAREN"); } consumePrimaryNoNewArrayWithName();
5586 break;
5587
5588 case 336 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT this"); } consumePrimaryNoNewArrayNameThis();
5590 break;
5591
5592 case 337 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT super"); } consumePrimaryNoNewArrayNameSuper();
5594 break;
5595
5596 case 338 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT class"); } consumePrimaryNoNewArrayName();
5598 break;
5599
5600 case 339 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name Dims DOT class"); } consumePrimaryNoNewArrayArrayType();
5602 break;
5603
5604 case 340 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType Dims DOT class"); } consumePrimaryNoNewArrayPrimitiveArrayType();
5606 break;
5607
5608 case 341 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType DOT class"); } consumePrimaryNoNewArrayPrimitiveType();
5610 break;
5611
5612 case 344 : if (DEBUG) { System.out.println("AllocationHeader ::= new ClassType LPAREN..."); } consumeAllocationHeader();
5614 break;
5615
5616 case 345 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new..."); } consumeClassInstanceCreationExpressionWithTypeArguments();
5618 break;
5619
5620 case 346 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new ClassType LPAREN"); } consumeClassInstanceCreationExpression();
5622 break;
5623
5624 case 347 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;
5626 break;
5627
5628 case 348 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); } consumeClassInstanceCreationExpressionQualified() ;
5630 break;
5631
5632 case 349 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } consumeClassInstanceCreationExpressionQualified() ;
5634 break;
5635
5636 case 350 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); } consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;
5638 break;
5639
5640 case 351 : if (DEBUG) { System.out.println("ClassInstanceCreationExpressionName ::= Name DOT"); } consumeClassInstanceCreationExpressionName() ;
5642 break;
5643
5644 case 352 : if (DEBUG) { System.out.println("ClassBodyopt ::="); } consumeClassBodyopt();
5646 break;
5647
5648 case 354 : if (DEBUG) { System.out.println("EnterAnonymousClassBody ::="); } consumeEnterAnonymousClassBody();
5650 break;
5651
5652 case 356 : if (DEBUG) { System.out.println("ArgumentList ::= ArgumentList COMMA Expression"); } consumeArgumentList();
5654 break;
5655
5656 case 357 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new PrimitiveType..."); } consumeArrayCreationHeader();
5658 break;
5659
5660 case 358 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new ClassOrInterfaceType..."); } consumeArrayCreationHeader();
5662 break;
5663
5664 case 359 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } consumeArrayCreationExpressionWithoutInitializer();
5666 break;
5667
5668 case 360 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new PrimitiveType"); } consumeArrayCreationExpressionWithInitializer();
5670 break;
5671
5672 case 361 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); } consumeArrayCreationExpressionWithoutInitializer();
5674 break;
5675
5676 case 362 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); } consumeArrayCreationExpressionWithInitializer();
5678 break;
5679
5680 case 364 : if (DEBUG) { System.out.println("DimWithOrWithOutExprs ::= DimWithOrWithOutExprs..."); } consumeDimWithOrWithOutExprs();
5682 break;
5683
5684 case 366 : if (DEBUG) { System.out.println("DimWithOrWithOutExpr ::= LBRACKET RBRACKET"); } consumeDimWithOrWithOutExpr();
5686 break;
5687
5688 case 367 : if (DEBUG) { System.out.println("Dims ::= DimsLoop"); } consumeDims();
5690 break;
5691
5692 case 370 : if (DEBUG) { System.out.println("OneDimLoop ::= LBRACKET RBRACKET"); } consumeOneDimLoop();
5694 break;
5695
5696 case 371 : if (DEBUG) { System.out.println("FieldAccess ::= Primary DOT Identifier"); } consumeFieldAccess(false);
5698 break;
5699
5700 case 372 : if (DEBUG) { System.out.println("FieldAccess ::= super DOT Identifier"); } consumeFieldAccess(true);
5702 break;
5703
5704 case 373 : if (DEBUG) { System.out.println("MethodInvocation ::= Name LPAREN ArgumentListopt RPAREN"); } consumeMethodInvocationName();
5706 break;
5707
5708 case 374 : if (DEBUG) { System.out.println("MethodInvocation ::= Name DOT OnlyTypeArguments..."); } consumeMethodInvocationNameWithTypeArguments();
5710 break;
5711
5712 case 375 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT OnlyTypeArguments..."); } consumeMethodInvocationPrimaryWithTypeArguments();
5714 break;
5715
5716 case 376 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT Identifier LPAREN..."); } consumeMethodInvocationPrimary();
5718 break;
5719
5720 case 377 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT OnlyTypeArguments..."); } consumeMethodInvocationSuperWithTypeArguments();
5722 break;
5723
5724 case 378 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT Identifier LPAREN..."); } consumeMethodInvocationSuper();
5726 break;
5727
5728 case 379 : if (DEBUG) { System.out.println("ArrayAccess ::= Name LBRACKET Expression RBRACKET"); } consumeArrayAccess(true);
5730 break;
5731
5732 case 380 : if (DEBUG) { System.out.println("ArrayAccess ::= PrimaryNoNewArray LBRACKET Expression..."); } consumeArrayAccess(false);
5734 break;
5735
5736 case 381 : if (DEBUG) { System.out.println("ArrayAccess ::= ArrayCreationWithArrayInitializer..."); } consumeArrayAccess(false);
5738 break;
5739
5740 case 383 : if (DEBUG) { System.out.println("PostfixExpression ::= Name"); } consumePostfixExpression();
5742 break;
5743
5744 case 386 : if (DEBUG) { System.out.println("PostIncrementExpression ::= PostfixExpression PLUS_PLUS"); } consumeUnaryExpression(OperatorIds.PLUS,true);
5746 break;
5747
5748 case 387 : if (DEBUG) { System.out.println("PostDecrementExpression ::= PostfixExpression..."); } consumeUnaryExpression(OperatorIds.MINUS,true);
5750 break;
5751
5752 case 388 : if (DEBUG) { System.out.println("PushPosition ::="); } consumePushPosition();
5754 break;
5755
5756 case 391 : if (DEBUG) { System.out.println("UnaryExpression ::= PLUS PushPosition UnaryExpression"); } consumeUnaryExpression(OperatorIds.PLUS);
5758 break;
5759
5760 case 392 : if (DEBUG) { System.out.println("UnaryExpression ::= MINUS PushPosition UnaryExpression"); } consumeUnaryExpression(OperatorIds.MINUS);
5762 break;
5763
5764 case 394 : if (DEBUG) { System.out.println("PreIncrementExpression ::= PLUS_PLUS PushPosition..."); } consumeUnaryExpression(OperatorIds.PLUS,false);
5766 break;
5767
5768 case 395 : if (DEBUG) { System.out.println("PreDecrementExpression ::= MINUS_MINUS PushPosition..."); } consumeUnaryExpression(OperatorIds.MINUS,false);
5770 break;
5771
5772 case 397 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= TWIDDLE PushPosition..."); } consumeUnaryExpression(OperatorIds.TWIDDLE);
5774 break;
5775
5776 case 398 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= NOT PushPosition..."); } consumeUnaryExpression(OperatorIds.NOT);
5778 break;
5779
5780 case 400 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN PrimitiveType Dimsopt..."); } consumeCastExpressionWithPrimitiveType();
5782 break;
5783
5784 case 401 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } consumeCastExpressionWithGenericsArray();
5786 break;
5787
5788 case 402 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); } consumeCastExpressionWithQualifiedGenericsArray();
5790 break;
5791
5792 case 403 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name PushRPAREN..."); } consumeCastExpressionLL1();
5794 break;
5795
5796 case 404 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name Dims PushRPAREN..."); } consumeCastExpressionWithNameArray();
5798 break;
5799
5800 case 405 : if (DEBUG) { System.out.println("OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments"); } consumeOnlyTypeArgumentsForCastExpression();
5802 break;
5803
5804 case 406 : if (DEBUG) { System.out.println("InsideCastExpression ::="); } consumeInsideCastExpression();
5806 break;
5807
5808 case 407 : if (DEBUG) { System.out.println("InsideCastExpressionLL1 ::="); } consumeInsideCastExpressionLL1();
5810 break;
5811
5812 case 408 : if (DEBUG) { System.out.println("InsideCastExpressionWithQualifiedGenerics ::="); } consumeInsideCastExpressionWithQualifiedGenerics();
5814 break;
5815
5816 case 410 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } consumeBinaryExpression(OperatorIds.MULTIPLY);
5818 break;
5819
5820 case 411 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } consumeBinaryExpression(OperatorIds.DIVIDE);
5822 break;
5823
5824 case 412 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); } consumeBinaryExpression(OperatorIds.REMAINDER);
5826 break;
5827
5828 case 414 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression PLUS..."); } consumeBinaryExpression(OperatorIds.PLUS);
5830 break;
5831
5832 case 415 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression MINUS..."); } consumeBinaryExpression(OperatorIds.MINUS);
5834 break;
5835
5836 case 417 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression LEFT_SHIFT..."); } consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
5838 break;
5839
5840 case 418 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression RIGHT_SHIFT..."); } consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
5842 break;
5843
5844 case 419 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression UNSIGNED_RIGHT_SHIFT"); } consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
5846 break;
5847
5848 case 421 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS..."); } consumeBinaryExpression(OperatorIds.LESS);
5850 break;
5851
5852 case 422 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression GREATER..."); } consumeBinaryExpression(OperatorIds.GREATER);
5854 break;
5855
5856 case 423 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS_EQUAL"); } consumeBinaryExpression(OperatorIds.LESS_EQUAL);
5858 break;
5859
5860 case 424 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression..."); } consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
5862 break;
5863
5864 case 426 : if (DEBUG) { System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); } consumeInstanceOfExpression();
5866 break;
5867
5868 case 428 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression EQUAL_EQUAL..."); } consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
5870 break;
5871
5872 case 429 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression NOT_EQUAL..."); } consumeEqualityExpression(OperatorIds.NOT_EQUAL);
5874 break;
5875
5876 case 431 : if (DEBUG) { System.out.println("AndExpression ::= AndExpression AND EqualityExpression"); } consumeBinaryExpression(OperatorIds.AND);
5878 break;
5879
5880 case 433 : if (DEBUG) { System.out.println("ExclusiveOrExpression ::= ExclusiveOrExpression XOR..."); } consumeBinaryExpression(OperatorIds.XOR);
5882 break;
5883
5884 case 435 : if (DEBUG) { System.out.println("InclusiveOrExpression ::= InclusiveOrExpression OR..."); } consumeBinaryExpression(OperatorIds.OR);
5886 break;
5887
5888 case 437 : if (DEBUG) { System.out.println("ConditionalAndExpression ::= ConditionalAndExpression..."); } consumeBinaryExpression(OperatorIds.AND_AND);
5890 break;
5891
5892 case 439 : if (DEBUG) { System.out.println("ConditionalOrExpression ::= ConditionalOrExpression..."); } consumeBinaryExpression(OperatorIds.OR_OR);
5894 break;
5895
5896 case 441 : if (DEBUG) { System.out.println("ConditionalExpression ::= ConditionalOrExpression..."); } consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;
5898 break;
5899
5900 case 444 : if (DEBUG) { System.out.println("Assignment ::= PostfixExpression AssignmentOperator..."); } consumeAssignment();
5902 break;
5903
5904 case 446 : if (DEBUG) { System.out.println("Assignment ::= InvalidArrayInitializerAssignement"); } ignoreExpressionAssignment();
5906 break;
5907
5908 case 447 : if (DEBUG) { System.out.println("AssignmentOperator ::= EQUAL"); } consumeAssignmentOperator(EQUAL);
5910 break;
5911
5912 case 448 : if (DEBUG) { System.out.println("AssignmentOperator ::= MULTIPLY_EQUAL"); } consumeAssignmentOperator(MULTIPLY);
5914 break;
5915
5916 case 449 : if (DEBUG) { System.out.println("AssignmentOperator ::= DIVIDE_EQUAL"); } consumeAssignmentOperator(DIVIDE);
5918 break;
5919
5920 case 450 : if (DEBUG) { System.out.println("AssignmentOperator ::= REMAINDER_EQUAL"); } consumeAssignmentOperator(REMAINDER);
5922 break;
5923
5924 case 451 : if (DEBUG) { System.out.println("AssignmentOperator ::= PLUS_EQUAL"); } consumeAssignmentOperator(PLUS);
5926 break;
5927
5928 case 452 : if (DEBUG) { System.out.println("AssignmentOperator ::= MINUS_EQUAL"); } consumeAssignmentOperator(MINUS);
5930 break;
5931
5932 case 453 : if (DEBUG) { System.out.println("AssignmentOperator ::= LEFT_SHIFT_EQUAL"); } consumeAssignmentOperator(LEFT_SHIFT);
5934 break;
5935
5936 case 454 : if (DEBUG) { System.out.println("AssignmentOperator ::= RIGHT_SHIFT_EQUAL"); } consumeAssignmentOperator(RIGHT_SHIFT);
5938 break;
5939
5940 case 455 : if (DEBUG) { System.out.println("AssignmentOperator ::= UNSIGNED_RIGHT_SHIFT_EQUAL"); } consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT);
5942 break;
5943
5944 case 456 : if (DEBUG) { System.out.println("AssignmentOperator ::= AND_EQUAL"); } consumeAssignmentOperator(AND);
5946 break;
5947
5948 case 457 : if (DEBUG) { System.out.println("AssignmentOperator ::= XOR_EQUAL"); } consumeAssignmentOperator(XOR);
5950 break;
5951
5952 case 458 : if (DEBUG) { System.out.println("AssignmentOperator ::= OR_EQUAL"); } consumeAssignmentOperator(OR);
5954 break;
5955
5956 case 462 : if (DEBUG) { System.out.println("Expressionopt ::="); } consumeEmptyExpression();
5958 break;
5959
5960 case 467 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::="); } consumeEmptyClassBodyDeclarationsopt();
5962 break;
5963
5964 case 468 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::= NestedType..."); } consumeClassBodyDeclarationsopt();
5966 break;
5967
5968 case 469 : if (DEBUG) { System.out.println("Modifiersopt ::="); } consumeDefaultModifiers();
5970 break;
5971
5972 case 470 : if (DEBUG) { System.out.println("Modifiersopt ::= Modifiers"); } consumeModifiers();
5974 break;
5975
5976 case 471 : if (DEBUG) { System.out.println("BlockStatementsopt ::="); } consumeEmptyBlockStatementsopt();
5978 break;
5979
5980 case 473 : if (DEBUG) { System.out.println("Dimsopt ::="); } consumeEmptyDimsopt();
5982 break;
5983
5984 case 475 : if (DEBUG) { System.out.println("ArgumentListopt ::="); } consumeEmptyArgumentListopt();
5986 break;
5987
5988 case 479 : if (DEBUG) { System.out.println("FormalParameterListopt ::="); } consumeFormalParameterListopt();
5990 break;
5991
5992 case 483 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::="); } consumeEmptyInterfaceMemberDeclarationsopt();
5994 break;
5995
5996 case 484 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::= NestedType..."); } consumeInterfaceMemberDeclarationsopt();
5998 break;
5999
6000 case 485 : if (DEBUG) { System.out.println("NestedType ::="); } consumeNestedType();
6002 break;
6003
6004 case 486 : if (DEBUG) { System.out.println("ForInitopt ::="); } consumeEmptyForInitopt();
6006 break;
6007
6008 case 488 : if (DEBUG) { System.out.println("ForUpdateopt ::="); } consumeEmptyForUpdateopt();
6010 break;
6011
6012 case 492 : if (DEBUG) { System.out.println("Catchesopt ::="); } consumeEmptyCatchesopt();
6014 break;
6015
6016 case 494 : if (DEBUG) { System.out.println("EnumDeclaration ::= EnumHeader EnumBody"); } consumeEnumDeclaration();
6018 break;
6019
6020 case 495 : if (DEBUG) { System.out.println("EnumHeader ::= EnumHeaderName ClassHeaderImplementsopt"); } consumeEnumHeader();
6022 break;
6023
6024 case 496 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier"); } consumeEnumHeaderName();
6026 break;
6027
6028 case 497 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumBodyDeclarationsopt RBRACE"); } consumeEnumBodyNoConstants();
6030 break;
6031
6032 case 498 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE COMMA EnumBodyDeclarationsopt..."); } consumeEnumBodyNoConstants();
6034 break;
6035
6036 case 499 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants COMMA..."); } consumeEnumBodyWithConstants();
6038 break;
6039
6040 case 500 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants..."); } consumeEnumBodyWithConstants();
6042 break;
6043
6044 case 502 : if (DEBUG) { System.out.println("EnumConstants ::= EnumConstants COMMA EnumConstant"); } consumeEnumConstants();
6046 break;
6047
6048 case 503 : if (DEBUG) { System.out.println("EnumConstantHeaderName ::= Modifiersopt Identifier"); } consumeEnumConstantHeaderName();
6050 break;
6051
6052 case 504 : if (DEBUG) { System.out.println("EnumConstantHeader ::= EnumConstantHeaderName..."); } consumeEnumConstantHeader();
6054 break;
6055
6056 case 505 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader ForceNoDiet..."); } consumeEnumConstantWithClassBody();
6058 break;
6059
6060 case 506 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader"); } consumeEnumConstantNoClassBody();
6062 break;
6063
6064 case 507 : if (DEBUG) { System.out.println("Arguments ::= LPAREN ArgumentListopt RPAREN"); } consumeArguments();
6066 break;
6067
6068 case 508 : if (DEBUG) { System.out.println("Argumentsopt ::="); } consumeEmptyArguments();
6070 break;
6071
6072 case 510 : if (DEBUG) { System.out.println("EnumDeclarations ::= SEMICOLON ClassBodyDeclarationsopt"); } consumeEnumDeclarations();
6074 break;
6075
6076 case 511 : if (DEBUG) { System.out.println("EnumBodyDeclarationsopt ::="); } consumeEmptyEnumDeclarations();
6078 break;
6079
6080 case 513 : if (DEBUG) { System.out.println("EnhancedForStatement ::= EnhancedForStatementHeader..."); } consumeEnhancedForStatement();
6082 break;
6083
6084 case 514 : if (DEBUG) { System.out.println("EnhancedForStatementNoShortIf ::=..."); } consumeEnhancedForStatement();
6086 break;
6087
6088 case 515 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Type..."); } consumeEnhancedForStatementHeaderInit(false);
6090 break;
6091
6092 case 516 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Modifiers"); } consumeEnhancedForStatementHeaderInit(true);
6094 break;
6095
6096 case 517 : if (DEBUG) { System.out.println("EnhancedForStatementHeader ::=..."); } consumeEnhancedForStatementHeader();
6098 break;
6099
6100 case 518 : if (DEBUG) { System.out.println("SingleStaticImportDeclaration ::=..."); } consumeImportDeclaration();
6102 break;
6103
6104 case 519 : if (DEBUG) { System.out.println("SingleStaticImportDeclarationName ::= import static Name"); } consumeSingleStaticImportDeclarationName();
6106 break;
6107
6108 case 520 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclaration ::=..."); } consumeImportDeclaration();
6110 break;
6111
6112 case 521 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclarationName ::= import static..."); } consumeStaticImportOnDemandDeclarationName();
6114 break;
6115
6116 case 522 : if (DEBUG) { System.out.println("TypeArguments ::= LESS TypeArgumentList1"); } consumeTypeArguments();
6118 break;
6119
6120 case 523 : if (DEBUG) { System.out.println("OnlyTypeArguments ::= LESS TypeArgumentList1"); } consumeOnlyTypeArguments();
6122 break;
6123
6124 case 525 : if (DEBUG) { System.out.println("TypeArgumentList1 ::= TypeArgumentList COMMA..."); } consumeTypeArgumentList1();
6126 break;
6127
6128 case 527 : if (DEBUG) { System.out.println("TypeArgumentList ::= TypeArgumentList COMMA TypeArgument"); } consumeTypeArgumentList();
6130 break;
6131
6132 case 528 : if (DEBUG) { System.out.println("TypeArgument ::= ReferenceType"); } consumeTypeArgument();
6134 break;
6135
6136 case 532 : if (DEBUG) { System.out.println("ReferenceType1 ::= ReferenceType GREATER"); } consumeReferenceType1();
6138 break;
6139
6140 case 533 : if (DEBUG) { System.out.println("ReferenceType1 ::= ClassOrInterface LESS..."); } consumeTypeArgumentReferenceType1();
6142 break;
6143
6144 case 535 : if (DEBUG) { System.out.println("TypeArgumentList2 ::= TypeArgumentList COMMA..."); } consumeTypeArgumentList2();
6146 break;
6147
6148 case 538 : if (DEBUG) { System.out.println("ReferenceType2 ::= ReferenceType RIGHT_SHIFT"); } consumeReferenceType2();
6150 break;
6151
6152 case 539 : if (DEBUG) { System.out.println("ReferenceType2 ::= ClassOrInterface LESS..."); } consumeTypeArgumentReferenceType2();
6154 break;
6155
6156 case 541 : if (DEBUG) { System.out.println("TypeArgumentList3 ::= TypeArgumentList COMMA..."); } consumeTypeArgumentList3();
6158 break;
6159
6160 case 544 : if (DEBUG) { System.out.println("ReferenceType3 ::= ReferenceType UNSIGNED_RIGHT_SHIFT"); } consumeReferenceType3();
6162 break;
6163
6164 case 545 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION"); } consumeWildcard();
6166 break;
6167
6168 case 546 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION WildcardBounds"); } consumeWildcardWithBounds();
6170 break;
6171
6172 case 547 : if (DEBUG) { System.out.println("WildcardBounds ::= extends ReferenceType"); } consumeWildcardBoundsExtends();
6174 break;
6175
6176 case 548 : if (DEBUG) { System.out.println("WildcardBounds ::= super ReferenceType"); } consumeWildcardBoundsSuper();
6178 break;
6179
6180 case 549 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION GREATER"); } consumeWildcard1();
6182 break;
6183
6184 case 550 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION WildcardBounds1"); } consumeWildcard1WithBounds();
6186 break;
6187
6188 case 551 : if (DEBUG) { System.out.println("WildcardBounds1 ::= extends ReferenceType1"); } consumeWildcardBounds1Extends();
6190 break;
6191
6192 case 552 : if (DEBUG) { System.out.println("WildcardBounds1 ::= super ReferenceType1"); } consumeWildcardBounds1Super();
6194 break;
6195
6196 case 553 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION RIGHT_SHIFT"); } consumeWildcard2();
6198 break;
6199
6200 case 554 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION WildcardBounds2"); } consumeWildcard2WithBounds();
6202 break;
6203
6204 case 555 : if (DEBUG) { System.out.println("WildcardBounds2 ::= extends ReferenceType2"); } consumeWildcardBounds2Extends();
6206 break;
6207
6208 case 556 : if (DEBUG) { System.out.println("WildcardBounds2 ::= super ReferenceType2"); } consumeWildcardBounds2Super();
6210 break;
6211
6212 case 557 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION UNSIGNED_RIGHT_SHIFT"); } consumeWildcard3();
6214 break;
6215
6216 case 558 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION WildcardBounds3"); } consumeWildcard3WithBounds();
6218 break;
6219
6220 case 559 : if (DEBUG) { System.out.println("WildcardBounds3 ::= extends ReferenceType3"); } consumeWildcardBounds3Extends();
6222 break;
6223
6224 case 560 : if (DEBUG) { System.out.println("WildcardBounds3 ::= super ReferenceType3"); } consumeWildcardBounds3Super();
6226 break;
6227
6228 case 561 : if (DEBUG) { System.out.println("TypeParameterHeader ::= Identifier"); } consumeTypeParameterHeader();
6230 break;
6231
6232 case 562 : if (DEBUG) { System.out.println("TypeParameters ::= LESS TypeParameterList1"); } consumeTypeParameters();
6234 break;
6235
6236 case 564 : if (DEBUG) { System.out.println("TypeParameterList ::= TypeParameterList COMMA..."); } consumeTypeParameterList();
6238 break;
6239
6240 case 566 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } consumeTypeParameterWithExtends();
6242 break;
6243
6244 case 567 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); } consumeTypeParameterWithExtendsAndBounds();
6246 break;
6247
6248 case 569 : if (DEBUG) { System.out.println("AdditionalBoundList ::= AdditionalBoundList..."); } consumeAdditionalBoundList();
6250 break;
6251
6252 case 570 : if (DEBUG) { System.out.println("AdditionalBound ::= AND ReferenceType"); } consumeAdditionalBound();
6254 break;
6255
6256 case 572 : if (DEBUG) { System.out.println("TypeParameterList1 ::= TypeParameterList COMMA..."); } consumeTypeParameterList1();
6258 break;
6259
6260 case 573 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader GREATER"); } consumeTypeParameter1();
6262 break;
6263
6264 case 574 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } consumeTypeParameter1WithExtends();
6266 break;
6267
6268 case 575 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); } consumeTypeParameter1WithExtendsAndBounds();
6270 break;
6271
6272 case 577 : if (DEBUG) { System.out.println("AdditionalBoundList1 ::= AdditionalBoundList..."); } consumeAdditionalBoundList1();
6274 break;
6275
6276 case 578 : if (DEBUG) { System.out.println("AdditionalBound1 ::= AND ReferenceType1"); } consumeAdditionalBound1();
6278 break;
6279
6280 case 584 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= PLUS PushPosition..."); } consumeUnaryExpression(OperatorIds.PLUS);
6282 break;
6283
6284 case 585 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= MINUS PushPosition..."); } consumeUnaryExpression(OperatorIds.MINUS);
6286 break;
6287
6288 case 588 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= TWIDDLE..."); } consumeUnaryExpression(OperatorIds.TWIDDLE);
6290 break;
6291
6292 case 589 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= NOT PushPosition"); } consumeUnaryExpression(OperatorIds.NOT);
6294 break;
6295
6296 case 592 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } consumeBinaryExpression(OperatorIds.MULTIPLY);
6298 break;
6299
6300 case 593 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name MULTIPLY..."); } consumeBinaryExpressionWithName(OperatorIds.MULTIPLY);
6302 break;
6303
6304 case 594 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } consumeBinaryExpression(OperatorIds.DIVIDE);
6306 break;
6307
6308 case 595 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name DIVIDE..."); } consumeBinaryExpressionWithName(OperatorIds.DIVIDE);
6310 break;
6311
6312 case 596 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); } consumeBinaryExpression(OperatorIds.REMAINDER);
6314 break;
6315
6316 case 597 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name REMAINDER..."); } consumeBinaryExpressionWithName(OperatorIds.REMAINDER);
6318 break;
6319
6320 case 599 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } consumeBinaryExpression(OperatorIds.PLUS);
6322 break;
6323
6324 case 600 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name PLUS..."); } consumeBinaryExpressionWithName(OperatorIds.PLUS);
6326 break;
6327
6328 case 601 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); } consumeBinaryExpression(OperatorIds.MINUS);
6330 break;
6331
6332 case 602 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name MINUS..."); } consumeBinaryExpressionWithName(OperatorIds.MINUS);
6334 break;
6335
6336 case 604 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
6338 break;
6339
6340 case 605 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name LEFT_SHIFT..."); } consumeBinaryExpressionWithName(OperatorIds.LEFT_SHIFT);
6342 break;
6343
6344 case 606 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
6346 break;
6347
6348 case 607 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name RIGHT_SHIFT..."); } consumeBinaryExpressionWithName(OperatorIds.RIGHT_SHIFT);
6350 break;
6351
6352 case 608 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); } consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
6354 break;
6355
6356 case 609 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name UNSIGNED_RIGHT_SHIFT..."); } consumeBinaryExpressionWithName(OperatorIds.UNSIGNED_RIGHT_SHIFT);
6358 break;
6359
6360 case 611 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } consumeBinaryExpression(OperatorIds.LESS);
6362 break;
6363
6364 case 612 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS..."); } consumeBinaryExpressionWithName(OperatorIds.LESS);
6366 break;
6367
6368 case 613 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); } consumeBinaryExpression(OperatorIds.GREATER);
6370 break;
6371
6372 case 614 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER..."); } consumeBinaryExpressionWithName(OperatorIds.GREATER);
6374 break;
6375
6376 case 615 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } consumeBinaryExpression(OperatorIds.LESS_EQUAL);
6378 break;
6379
6380 case 616 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS_EQUAL..."); } consumeBinaryExpressionWithName(OperatorIds.LESS_EQUAL);
6382 break;
6383
6384 case 617 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); } consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
6386 break;
6387
6388 case 618 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER_EQUAL..."); } consumeBinaryExpressionWithName(OperatorIds.GREATER_EQUAL);
6390 break;
6391
6392 case 620 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); } consumeInstanceOfExpressionWithName();
6394 break;
6395
6396 case 621 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); } consumeInstanceOfExpression();
6398 break;
6399
6400 case 623 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
6402 break;
6403
6404 case 624 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name EQUAL_EQUAL..."); } consumeEqualityExpressionWithName(OperatorIds.EQUAL_EQUAL);
6406 break;
6407
6408 case 625 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); } consumeEqualityExpression(OperatorIds.NOT_EQUAL);
6410 break;
6411
6412 case 626 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name NOT_EQUAL..."); } consumeEqualityExpressionWithName(OperatorIds.NOT_EQUAL);
6414 break;
6415
6416 case 628 : if (DEBUG) { System.out.println("AndExpression_NotName ::= AndExpression_NotName AND..."); } consumeBinaryExpression(OperatorIds.AND);
6418 break;
6419
6420 case 629 : if (DEBUG) { System.out.println("AndExpression_NotName ::= Name AND EqualityExpression"); } consumeBinaryExpressionWithName(OperatorIds.AND);
6422 break;
6423
6424 case 631 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::=..."); } consumeBinaryExpression(OperatorIds.XOR);
6426 break;
6427
6428 case 632 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::= Name XOR AndExpression"); } consumeBinaryExpressionWithName(OperatorIds.XOR);
6430 break;
6431
6432 case 634 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::=..."); } consumeBinaryExpression(OperatorIds.OR);
6434 break;
6435
6436 case 635 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::= Name OR..."); } consumeBinaryExpressionWithName(OperatorIds.OR);
6438 break;
6439
6440 case 637 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::=..."); } consumeBinaryExpression(OperatorIds.AND_AND);
6442 break;
6443
6444 case 638 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::= Name AND_AND..."); } consumeBinaryExpressionWithName(OperatorIds.AND_AND);
6446 break;
6447
6448 case 640 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::=..."); } consumeBinaryExpression(OperatorIds.OR_OR);
6450 break;
6451
6452 case 641 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::= Name OR_OR..."); } consumeBinaryExpressionWithName(OperatorIds.OR_OR);
6454 break;
6455
6456 case 643 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::=..."); } consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;
6458 break;
6459
6460 case 644 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::= Name QUESTION..."); } consumeConditionalExpressionWithName(OperatorIds.QUESTIONCOLON) ;
6462 break;
6463
6464 case 648 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); } consumeAnnotationTypeDeclarationHeaderName() ;
6466 break;
6467
6468 case 649 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); } consumeAnnotationTypeDeclarationHeaderName() ;
6470 break;
6471
6472 case 650 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeader ::=..."); } consumeAnnotationTypeDeclarationHeader() ;
6474 break;
6475
6476 case 651 : if (DEBUG) { System.out.println("AnnotationTypeDeclaration ::=..."); } consumeAnnotationTypeDeclaration() ;
6478 break;
6479
6480 case 653 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::="); } consumeEmptyAnnotationTypeMemberDeclarationsopt() ;
6482 break;
6483
6484 case 654 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::= NestedType..."); } consumeAnnotationTypeMemberDeclarationsopt() ;
6486 break;
6487
6488 case 656 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarations ::=..."); } consumeAnnotationTypeMemberDeclarations() ;
6490 break;
6491
6492 case 657 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt..."); } consumeMethodHeaderNameWithTypeParameters(true);
6494 break;
6495
6496 case 658 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt Type..."); } consumeMethodHeaderName(true);
6498 break;
6499
6500 case 659 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::="); } consumeEmptyMethodHeaderDefaultValue() ;
6502 break;
6503
6504 case 660 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::= DefaultValue"); } consumeMethodHeaderDefaultValue();
6506 break;
6507
6508 case 661 : if (DEBUG) { System.out.println("AnnotationMethodHeader ::= AnnotationMethodHeaderName..."); } consumeMethodHeader();
6510 break;
6511
6512 case 662 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclaration ::=..."); } consumeAnnotationTypeMemberDeclaration() ;
6514 break;
6515
6516 case 670 : if (DEBUG) { System.out.println("AnnotationName ::= AT Name"); } consumeAnnotationName() ;
6518 break;
6519
6520 case 671 : if (DEBUG) { System.out.println("NormalAnnotation ::= AnnotationName LPAREN..."); } consumeNormalAnnotation() ;
6522 break;
6523
6524 case 672 : if (DEBUG) { System.out.println("MemberValuePairsopt ::="); } consumeEmptyMemberValuePairsopt() ;
6526 break;
6527
6528 case 675 : if (DEBUG) { System.out.println("MemberValuePairs ::= MemberValuePairs COMMA..."); } consumeMemberValuePairs() ;
6530 break;
6531
6532 case 676 : if (DEBUG) { System.out.println("MemberValuePair ::= SimpleName EQUAL EnterMemberValue..."); } consumeMemberValuePair() ;
6534 break;
6535
6536 case 677 : if (DEBUG) { System.out.println("EnterMemberValue ::="); } consumeEnterMemberValue() ;
6538 break;
6539
6540 case 678 : if (DEBUG) { System.out.println("ExitMemberValue ::="); } consumeExitMemberValue() ;
6542 break;
6543
6544 case 680 : if (DEBUG) { System.out.println("MemberValue ::= Name"); } consumeMemberValueAsName() ;
6546 break;
6547
6548 case 683 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } consumeMemberValueArrayInitializer() ;
6550 break;
6551
6552 case 684 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } consumeMemberValueArrayInitializer() ;
6554 break;
6555
6556 case 685 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } consumeEmptyMemberValueArrayInitializer() ;
6558 break;
6559
6560 case 686 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); } consumeEmptyMemberValueArrayInitializer() ;
6562 break;
6563
6564 case 687 : if (DEBUG) { System.out.println("EnterMemberValueArrayInitializer ::="); } consumeEnterMemberValueArrayInitializer() ;
6566 break;
6567
6568 case 689 : if (DEBUG) { System.out.println("MemberValues ::= MemberValues COMMA MemberValue"); } consumeMemberValues() ;
6570 break;
6571
6572 case 690 : if (DEBUG) { System.out.println("MarkerAnnotation ::= AnnotationName"); } consumeMarkerAnnotation() ;
6574 break;
6575
6576 case 691 : if (DEBUG) { System.out.println("SingleMemberAnnotation ::= AnnotationName LPAREN..."); } consumeSingleMemberAnnotation() ;
6578 break;
6579
6580 case 692 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); } consumeRecoveryMethodHeaderNameWithTypeParameters();
6582 break;
6583
6584 case 693 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt Type..."); } consumeRecoveryMethodHeaderName();
6586 break;
6587
6588 case 694 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } consumeMethodHeader();
6590 break;
6591
6592 case 695 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); } consumeMethodHeader();
6594 break;
6595
6596 }
6597}
6598protected void consumeSimpleAssertStatement() {
6599 this.expressionLengthPtr--;
6601 pushOnAstStack(new AssertStatement(this.expressionStack[this.expressionPtr--], this.intStack[this.intPtr--]));
6602}
6603protected void consumeSingleMemberAnnotation() {
6604 SingleMemberAnnotation singleMemberAnnotation = null;
6606 TypeReference typeReference = this.getAnnotationType();
6607 singleMemberAnnotation = new SingleMemberAnnotation(typeReference, this.intStack[this.intPtr--]);
6608 singleMemberAnnotation.memberValue = this.expressionStack[this.expressionPtr--];
6609 this.expressionLengthPtr--;
6610 singleMemberAnnotation.declarationSourceEnd = this.rParenPos;
6611 pushOnExpressionStack(singleMemberAnnotation);
6612
6613
6614 if(this.currentElement != null) {
6615 annotationRecoveryCheckPoint(singleMemberAnnotation.sourceStart, singleMemberAnnotation.declarationSourceEnd);
6616 }
6617
6618 if(!this.statementRecoveryActivated &&
6619 options.sourceLevel < ClassFileConstants.JDK1_5 &&
6620 this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
6621 this.problemReporter().invalidUsageOfAnnotation(singleMemberAnnotation);
6622 }
6623 this.recordStringLiterals = true;
6624}
6625protected void consumeSingleStaticImportDeclarationName() {
6626
6629
6630 ImportReference impt;
6631 int length;
6632 char[][] tokens = new char[length = this.identifierLengthStack[this.identifierLengthPtr--]][];
6633 this.identifierPtr -= length;
6634 long[] positions = new long[length];
6635 System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, 0, length);
6636 System.arraycopy(this.identifierPositionStack, this.identifierPtr + 1, positions, 0, length);
6637 pushOnAstStack(impt = new ImportReference(tokens, positions, false, ClassFileConstants.AccStatic));
6638
6639 this.modifiers = ClassFileConstants.AccDefault;
6640 this.modifiersSourceStart = -1;
6642 if (this.currentToken == TokenNameSEMICOLON){
6643 impt.declarationSourceEnd = this.scanner.currentPosition - 1;
6644 } else {
6645 impt.declarationSourceEnd = impt.sourceEnd;
6646 }
6647 impt.declarationEnd = impt.declarationSourceEnd;
6648 impt.declarationSourceStart = this.intStack[this.intPtr--];
6650
6651 if(!this.statementRecoveryActivated &&
6652 this.options.sourceLevel < ClassFileConstants.JDK1_5 &&
6653 this.lastErrorEndPositionBeforeRecovery < this.scanner.currentPosition) {
6654 impt.modifiers = ClassFileConstants.AccDefault; this.problemReporter().invalidUsageOfStaticImports(impt);
6656 }
6657
6658 if (this.currentElement != null){
6660 this.lastCheckPoint = impt.declarationSourceEnd+1;
6661 this.currentElement = this.currentElement.add(impt, 0);
6662 this.lastIgnoredToken = -1;
6663 this.restartRecovery = true; }
6665}
6666protected void consumeSingleTypeImportDeclarationName() {
6667
6670
6671 ImportReference impt;
6672 int length;
6673 char[][] tokens = new char[length = this.identifierLengthStack[this.identifierLengthPtr--]][];
6674 this.identifierPtr -= length;
6675 long[] positions = new long[length];
6676 System.arraycopy(this.identifierStack, this.identifierPtr + 1, tokens, 0, length);
6677 System.arraycopy(this.identifierPositionStack, this.identifierPtr + 1, positions, 0, length);
6678 pushOnAstStack(impt = new ImportReference(tokens, positions, false, ClassFileConstants.AccDefault));
6679
6680 if (this.currentToken == TokenNameSEMICOLON){
6681 impt.declarationSourceEnd = this.scanner.currentPosition - 1;
6682 } else {
6683 impt.declarationSourceEnd = impt.sourceEnd;
6684 }
6685 impt.declarationEnd = impt.declarationSourceEnd;
6686 impt.declarationSourceStart = this.intStack[this.intPtr--];
6688
6689 if (this.currentElement != null){
6691 this.lastCheckPoint = impt.declarationSourceEnd+1;
6692 this.currentElement = this.currentElement.add(impt, 0);
6693 this.lastIgnoredToken = -1;
6694 this.restartRecovery = true; }
6696}
6697protected void consumeStatementBreak() {
6698
6701 pushOnAstStack(new BreakStatement(null, this.intStack[this.intPtr--], this.endStatementPosition));
6702
6703 if (this.pendingRecoveredType != null) {
6704 if (this.pendingRecoveredType.allocation == null &&
6708 this.endPosition <= this.pendingRecoveredType.declarationSourceEnd) {
6709 this.astStack[this.astPtr] = this.pendingRecoveredType;
6710 this.pendingRecoveredType = null;
6711 return;
6712 }
6713 this.pendingRecoveredType = null;
6714 }
6715}
6716protected void consumeStatementBreakWithLabel() {
6717
6720 pushOnAstStack(
6721 new BreakStatement(
6722 this.identifierStack[this.identifierPtr--],
6723 this.intStack[this.intPtr--],
6724 this.endStatementPosition));
6725 this.identifierLengthPtr--;
6726}
6727protected void consumeStatementCatch() {
6728
6730
6736 this.astLengthPtr--;
6737 this.listLength = 0; }
6739protected void consumeStatementContinue() {
6740
6743 pushOnAstStack(
6744 new ContinueStatement(
6745 null,
6746 this.intStack[this.intPtr--],
6747 this.endStatementPosition));
6748}
6749protected void consumeStatementContinueWithLabel() {
6750
6753 pushOnAstStack(
6754 new ContinueStatement(
6755 this.identifierStack[this.identifierPtr--],
6756 this.intStack[this.intPtr--],
6757 this.endStatementPosition));
6758 this.identifierLengthPtr--;
6759}
6760protected void consumeStatementDo() {
6761
6763 this.intPtr--;
6765
6766 Statement statement = (Statement) this.astStack[this.astPtr];
6767 this.expressionLengthPtr--;
6768 this.astS
|
Java API By Example, From Geeks To Geeks.