|
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}
32
|
Java API By Example, From Geeks To Geeks.