misc changes
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / DocumentElementParser.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v0.5 
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v05.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  ******************************************************************************/
11 package net.sourceforge.phpdt.internal.compiler;
12
13 /*
14  * A document element parser extracts structural information
15  * from a piece of source, providing detailed source positions info.
16  *
17  * also see @IDocumentElementRequestor
18  *
19  * The structural investigation includes:
20  * - the package statement
21  * - import statements
22  * - top-level types: package member, member types (member types of member types...)
23  * - fields
24  * - methods
25  *
26  * Any (parsing) problem encountered is also provided.
27  */
28 import net.sourceforge.phpdt.core.compiler.IProblem;
29 import net.sourceforge.phpdt.internal.compiler.ast.AbstractVariableDeclaration;
30 import net.sourceforge.phpdt.internal.compiler.ast.Argument;
31 import net.sourceforge.phpdt.internal.compiler.ast.ArrayQualifiedTypeReference;
32 import net.sourceforge.phpdt.internal.compiler.ast.ArrayTypeReference;
33 import net.sourceforge.phpdt.internal.compiler.ast.CompilationUnitDeclaration;
34 import net.sourceforge.phpdt.internal.compiler.ast.ConstructorDeclaration;
35 import net.sourceforge.phpdt.internal.compiler.ast.FieldDeclaration;
36 import net.sourceforge.phpdt.internal.compiler.ast.ImportReference;
37 import net.sourceforge.phpdt.internal.compiler.ast.Initializer;
38 import net.sourceforge.phpdt.internal.compiler.ast.LocalDeclaration;
39 import net.sourceforge.phpdt.internal.compiler.ast.LocalTypeDeclaration;
40 import net.sourceforge.phpdt.internal.compiler.ast.MemberTypeDeclaration;
41 import net.sourceforge.phpdt.internal.compiler.ast.MethodDeclaration;
42 import net.sourceforge.phpdt.internal.compiler.ast.QualifiedTypeReference;
43 import net.sourceforge.phpdt.internal.compiler.ast.SingleTypeReference;
44 import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
45 import net.sourceforge.phpdt.internal.compiler.ast.TypeReference;
46 import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit;
47 import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
48 import net.sourceforge.phpdt.internal.compiler.parser.Parser;
49 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
50 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
51 import net.sourceforge.phpdt.internal.compiler.util.CharOperation;
52
53 public class DocumentElementParser extends Parser {
54         IDocumentElementRequestor requestor;
55         private int localIntPtr;
56         private int lastFieldEndPosition;
57         private int lastFieldBodyEndPosition;   
58         private int typeStartPosition;
59         private long selectorSourcePositions;
60         private int typeDims;
61         private int extendsDim;
62         private int declarationSourceStart;
63
64         /* int[] stack for storing javadoc positions */
65         int[][] intArrayStack;
66         int intArrayPtr;
67         
68         CompilerOptions options;
69         
70 public DocumentElementParser(
71         final IDocumentElementRequestor requestor, 
72         IProblemFactory problemFactory,
73         CompilerOptions options) {
74         super(new ProblemReporter(
75                 DefaultErrorHandlingPolicies.exitAfterAllProblems(), 
76                 options, 
77                 problemFactory) {
78                 public void record(IProblem problem, CompilationResult unitResult) {
79                         requestor.acceptProblem(problem);
80                 }
81         },
82         false,
83         options.assertMode);
84         this.requestor = requestor;
85         intArrayStack = new int[30][];
86         this.options = options;
87 }
88
89 /**
90  *
91  * INTERNAL USE-ONLY
92  */
93 protected void adjustInterfaceModifiers() {
94         intStack[intPtr - 2] |= AccInterface;
95 }
96 /*
97  * Will clear the comment stack when looking
98  * for a potential JavaDoc which might contain @deprecated.
99  *
100  * Additionally, before investigating for @deprecated, retrieve the positions
101  * of the JavaDoc comments so as to notify requestor with them.
102  */
103 public void checkAnnotation() {
104
105         /* persisting javadoc positions */
106         pushOnIntArrayStack(this.getJavaDocPositions());
107         boolean deprecated = false;
108         int lastAnnotationIndex = -1;
109
110         //since jdk1.2 look only in the last java doc comment...
111         found : {
112                 if ((lastAnnotationIndex = scanner.commentPtr) >= 0) { //look for @deprecated
113                         scanner.commentPtr = -1;
114                         // reset the comment stack, since not necessary after having checked
115                         int commentSourceStart = scanner.commentStarts[lastAnnotationIndex];
116                         // javadoc only (non javadoc comment have negative end positions.)
117                         int commentSourceEnd = scanner.commentStops[lastAnnotationIndex] - 1;
118                         //stop is one over
119                         char[] comment = scanner.source;
120
121                         for (int i = commentSourceStart + 3; i < commentSourceEnd - 10; i++) {
122                                 if ((comment[i] == '@')
123                                         && (comment[i + 1] == 'd')
124                                         && (comment[i + 2] == 'e')
125                                         && (comment[i + 3] == 'p')
126                                         && (comment[i + 4] == 'r')
127                                         && (comment[i + 5] == 'e')
128                                         && (comment[i + 6] == 'c')
129                                         && (comment[i + 7] == 'a')
130                                         && (comment[i + 8] == 't')
131                                         && (comment[i + 9] == 'e')
132                                         && (comment[i + 10] == 'd')) {
133                                         // ensure the tag is properly ended: either followed by a space, line end or asterisk.
134                                         int nextPos = i + 11;
135                                         deprecated = 
136                                                 (comment[nextPos] == ' ')
137                                                         || (comment[nextPos] == '\n')
138                                                         || (comment[nextPos] == '\r')
139                                                         || (comment[nextPos] == '*'); 
140                                         break found;
141                                 }
142                         }
143                 }
144         }
145         if (deprecated) {
146                 checkAndSetModifiers(AccDeprecated);
147         }
148         // modify the modifier source start to point at the first comment
149         if (lastAnnotationIndex >= 0) {
150                 declarationSourceStart = scanner.commentStarts[0];
151         }
152 }
153 /**
154  *
155  * INTERNAL USE-ONLY
156  */
157 protected void consumeClassBodyDeclaration() {
158         // ClassBodyDeclaration ::= Diet Block
159         //push an Initializer
160         //optimize the push/pop
161
162         super.consumeClassBodyDeclaration();
163         Initializer initializer = (Initializer) astStack[astPtr];
164         requestor.acceptInitializer(
165                 initializer.declarationSourceStart,
166                 initializer.declarationSourceEnd,
167                 intArrayStack[intArrayPtr--], 
168                 0,
169                 modifiersSourceStart, 
170                 initializer.block.sourceStart,
171                 initializer.block.sourceEnd);
172 }
173 /**
174  *
175  * INTERNAL USE-ONLY
176  */
177 protected void consumeClassDeclaration() {
178         super.consumeClassDeclaration();
179         // we know that we have a TypeDeclaration on the top of the astStack
180         if (isLocalDeclaration()) {
181                 // we ignore the local variable declarations
182                 return;
183         }
184         requestor.exitClass(endStatementPosition, // '}' is the end of the body 
185          ((TypeDeclaration) astStack[astPtr]).declarationSourceEnd);
186 }
187 /**
188  *
189  * INTERNAL USE-ONLY
190  */
191 protected void consumeClassHeader() {
192         //ClassHeader ::= $empty
193         super.consumeClassHeader();
194         if (isLocalDeclaration()) {
195                 // we ignore the local variable declarations
196                 intArrayPtr--;
197                 return;
198         }
199         TypeDeclaration typeDecl = (TypeDeclaration) astStack[astPtr];
200         TypeReference[] superInterfaces = typeDecl.superInterfaces;
201         char[][] interfaceNames = null;
202         int[] interfaceNameStarts = null;
203         int[] interfaceNameEnds = null;
204         if (superInterfaces != null) {
205                 int superInterfacesLength = superInterfaces.length;
206                 interfaceNames = new char[superInterfacesLength][];
207                 interfaceNameStarts = new int[superInterfacesLength];
208                 interfaceNameEnds = new int[superInterfacesLength];
209                 for (int i = 0; i < superInterfacesLength; i++) {
210                         TypeReference superInterface = superInterfaces[i];
211                         interfaceNames[i] = CharOperation.concatWith(superInterface.getTypeName(), '.'); 
212                         interfaceNameStarts[i] = superInterface.sourceStart;
213                         interfaceNameEnds[i] = superInterface.sourceEnd;
214                 }
215         }
216         // flush the comments related to the class header
217         scanner.commentPtr = -1;
218         TypeReference superclass = typeDecl.superclass;
219         if (superclass == null) {
220                 requestor.enterClass(
221                         typeDecl.declarationSourceStart, 
222                         intArrayStack[intArrayPtr--], 
223                         typeDecl.modifiers, 
224                         typeDecl.modifiersSourceStart, 
225                         typeStartPosition, 
226                         typeDecl.name, 
227                         typeDecl.sourceStart, 
228                         typeDecl.sourceEnd, 
229                         null, 
230                         -1, 
231                         -1, 
232                         interfaceNames, 
233                         interfaceNameStarts, 
234                         interfaceNameEnds, 
235                         scanner.currentPosition - 1); 
236         } else {
237                 requestor.enterClass(
238                         typeDecl.declarationSourceStart, 
239                         intArrayStack[intArrayPtr--], 
240                         typeDecl.modifiers, 
241                         typeDecl.modifiersSourceStart, 
242                         typeStartPosition, 
243                         typeDecl.name, 
244                         typeDecl.sourceStart, 
245                         typeDecl.sourceEnd, 
246                         CharOperation.concatWith(superclass.getTypeName(), '.'), 
247                         superclass.sourceStart, 
248                         superclass.sourceEnd, 
249                         interfaceNames, 
250                         interfaceNameStarts, 
251                         interfaceNameEnds, 
252                         scanner.currentPosition - 1); 
253
254         }
255 }
256 protected void consumeClassHeaderName() {
257         // ClassHeaderName ::= Modifiersopt 'class' 'Identifier'
258         TypeDeclaration typeDecl;
259         if (nestedMethod[nestedType] == 0) {
260                 if (nestedType != 0) {
261                         typeDecl = new MemberTypeDeclaration(this.compilationUnit.compilationResult);
262                 } else {
263                         typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
264                 }
265         } else {
266                 // Record that the block has a declaration for local types
267                 typeDecl = new LocalTypeDeclaration(this.compilationUnit.compilationResult);
268                 markCurrentMethodWithLocalType();
269                 blockReal();
270         }
271
272         //highlight the name of the type
273         long pos = identifierPositionStack[identifierPtr];
274         typeDecl.sourceEnd = (int) pos;
275         typeDecl.sourceStart = (int) (pos >>> 32);
276         typeDecl.name = identifierStack[identifierPtr--];
277         identifierLengthPtr--;
278
279         //compute the declaration source too
280         // 'class' and 'interface' push an int position
281         typeStartPosition = typeDecl.declarationSourceStart = intStack[intPtr--];
282         intPtr--;
283         int declarationSourceStart = intStack[intPtr--];
284         typeDecl.modifiersSourceStart = intStack[intPtr--];
285         typeDecl.modifiers = intStack[intPtr--];
286         if (typeDecl.declarationSourceStart > declarationSourceStart) {
287                 typeDecl.declarationSourceStart = declarationSourceStart;
288         }
289         typeDecl.bodyStart = typeDecl.sourceEnd + 1;
290         pushOnAstStack(typeDecl);
291 }
292 /**
293  *
294  * INTERNAL USE-ONLY
295  */
296 protected void consumeCompilationUnit() {
297         // CompilationUnit ::= EnterCompilationUnit PackageDeclarationopt ImportDeclarationsopt
298         requestor.exitCompilationUnit(scanner.source.length - 1);
299 }
300 /**
301  *
302  * INTERNAL USE-ONLY
303  */
304 protected void consumeConstructorDeclaration() {
305         // ConstructorDeclaration ::= ConstructorHeader ConstructorBody
306         super.consumeConstructorDeclaration();
307         if (isLocalDeclaration()) {
308                 // we ignore the local variable declarations
309                 return;
310         }
311         ConstructorDeclaration cd = (ConstructorDeclaration) astStack[astPtr];
312         requestor.exitConstructor(endStatementPosition, cd.declarationSourceEnd);
313 }
314 /**
315  *
316  * INTERNAL USE-ONLY
317  */
318 protected void consumeConstructorHeader() {
319         // ConstructorHeader ::= ConstructorHeaderName MethodHeaderParameters MethodHeaderThrowsClauseopt
320         super.consumeConstructorHeader();
321         if (isLocalDeclaration()) {
322                 // we ignore the local variable declarations
323                 intArrayPtr--;
324                 return;
325         }
326         ConstructorDeclaration cd = (ConstructorDeclaration) astStack[astPtr];
327         Argument[] arguments = cd.arguments;
328         char[][] argumentTypes = null;
329         char[][] argumentNames = null;
330         int[] argumentTypeStarts = null;
331         int[] argumentTypeEnds = null;
332         int[] argumentNameStarts = null;
333         int[] argumentNameEnds = null;
334         if (arguments != null) {
335                 int argumentLength = arguments.length;
336                 argumentTypes = new char[argumentLength][];
337                 argumentNames = new char[argumentLength][];
338                 argumentNameStarts = new int[argumentLength];
339                 argumentNameEnds = new int[argumentLength];
340                 argumentTypeStarts = new int[argumentLength];
341                 argumentTypeEnds = new int[argumentLength];
342                 for (int i = 0; i < argumentLength; i++) {
343                         Argument argument = arguments[i];
344                         TypeReference argumentType = argument.type;
345                         argumentTypes[i] = returnTypeName(argumentType);
346                         argumentNames[i] = argument.name;
347                         argumentNameStarts[i] = argument.sourceStart;
348                         argumentNameEnds[i] = argument.sourceEnd;
349                         argumentTypeStarts[i] = argumentType.sourceStart;
350                         argumentTypeEnds[i] = argumentType.sourceEnd;
351                 }
352         }
353         TypeReference[] thrownExceptions = cd.thrownExceptions;
354         char[][] exceptionTypes = null;
355         int[] exceptionTypeStarts = null;
356         int[] exceptionTypeEnds = null;
357         if (thrownExceptions != null) {
358                 int thrownExceptionLength = thrownExceptions.length;
359                 exceptionTypes = new char[thrownExceptionLength][];
360                 exceptionTypeStarts = new int[thrownExceptionLength];
361                 exceptionTypeEnds = new int[thrownExceptionLength];
362                 for (int i = 0; i < thrownExceptionLength; i++) {
363                         TypeReference exception = thrownExceptions[i];
364                         exceptionTypes[i] = CharOperation.concatWith(exception.getTypeName(), '.');
365                         exceptionTypeStarts[i] = exception.sourceStart;
366                         exceptionTypeEnds[i] = exception.sourceEnd;
367                 }
368         }
369         requestor
370                 .enterConstructor(
371                         cd.declarationSourceStart, 
372                         intArrayStack[intArrayPtr--], 
373                         cd.modifiers,
374                         cd.modifiersSourceStart, 
375                         cd.selector, 
376                         cd.sourceStart, 
377                         (int) (selectorSourcePositions & 0xFFFFFFFFL), 
378                         // retrieve the source end of the name
379                         argumentTypes, 
380                         argumentTypeStarts, 
381                         argumentTypeEnds, 
382                         argumentNames, 
383                         argumentNameStarts, 
384                         argumentNameEnds, 
385                         rParenPos, 
386                         // right parenthesis
387                         exceptionTypes, 
388                         exceptionTypeStarts, 
389                         exceptionTypeEnds, 
390                         scanner.currentPosition - 1); 
391 }
392 protected void consumeConstructorHeaderName() {
393         // ConstructorHeaderName ::=  Modifiersopt 'Identifier' '('
394         ConstructorDeclaration cd = new ConstructorDeclaration(this.compilationUnit.compilationResult);
395
396         //name -- this is not really revelant but we do .....
397         cd.selector = identifierStack[identifierPtr];
398         selectorSourcePositions = identifierPositionStack[identifierPtr--];
399         identifierLengthPtr--;
400
401         //modifiers
402         cd.declarationSourceStart = intStack[intPtr--];
403         cd.modifiersSourceStart = intStack[intPtr--];
404         cd.modifiers = intStack[intPtr--];
405
406         //highlight starts at the selector starts
407         cd.sourceStart = (int) (selectorSourcePositions >>> 32);
408         pushOnAstStack(cd);
409
410         cd.sourceEnd = lParenPos;
411         cd.bodyStart = lParenPos + 1;
412 }
413 protected void consumeDefaultModifiers() {
414         checkAnnotation(); // might update modifiers with AccDeprecated
415         pushOnIntStack(modifiers); // modifiers
416         pushOnIntStack(-1);
417         pushOnIntStack(
418                 declarationSourceStart >= 0 ? declarationSourceStart : scanner.startPosition); 
419         resetModifiers();
420 }
421 protected void consumeDiet() {
422         // Diet ::= $empty
423         super.consumeDiet();
424         /* persisting javadoc positions
425          * Will be consume in consumeClassBodyDeclaration
426          */
427         pushOnIntArrayStack(this.getJavaDocPositions());        
428 }
429 /**
430  *
431  * INTERNAL USE-ONLY
432  */
433 protected void consumeEnterCompilationUnit() {
434         // EnterCompilationUnit ::= $empty
435         requestor.enterCompilationUnit();
436 }
437 /**
438  *
439  * INTERNAL USE-ONLY
440  */
441 protected void consumeEnterVariable() {
442         // EnterVariable ::= $empty
443         boolean isLocalDeclaration = isLocalDeclaration();
444         if (!isLocalDeclaration && (variablesCounter[nestedType] != 0)) {
445                 requestor.exitField(lastFieldBodyEndPosition, lastFieldEndPosition);
446         }
447         char[] name = identifierStack[identifierPtr];
448         long namePosition = identifierPositionStack[identifierPtr--];
449         int extendedTypeDimension = intStack[intPtr--];
450
451         AbstractVariableDeclaration declaration;
452         if (nestedMethod[nestedType] != 0) {
453                 // create the local variable declarations
454                 declaration = 
455                         new LocalDeclaration(null, name, (int) (namePosition >>> 32), (int) namePosition); 
456         } else {
457                 // create the field declaration
458                 declaration = 
459                         new FieldDeclaration(null, name, (int) (namePosition >>> 32), (int) namePosition); 
460         }
461         identifierLengthPtr--;
462         TypeReference type;
463         int variableIndex = variablesCounter[nestedType];
464         int typeDim = 0;
465         if (variableIndex == 0) {
466                 // first variable of the declaration (FieldDeclaration or LocalDeclaration)
467                 if (nestedMethod[nestedType] != 0) {
468                         // local declaration
469                         declaration.declarationSourceStart = intStack[intPtr--];
470                         declaration.modifiersSourceStart = intStack[intPtr--];
471                         declaration.modifiers = intStack[intPtr--];
472                         type = getTypeReference(typeDim = intStack[intPtr--]); // type dimension
473                         pushOnAstStack(type);
474                 } else {
475                         // field declaration
476                         type = getTypeReference(typeDim = intStack[intPtr--]); // type dimension
477                         pushOnAstStack(type);
478                         declaration.declarationSourceStart = intStack[intPtr--];
479                         declaration.modifiersSourceStart = intStack[intPtr--];
480                         declaration.modifiers = intStack[intPtr--];
481                 }
482         } else {
483                 type = (TypeReference) astStack[astPtr - variableIndex];
484                 typeDim = type.dimensions();
485                 AbstractVariableDeclaration previousVariable = 
486                         (AbstractVariableDeclaration) astStack[astPtr]; 
487                 declaration.declarationSourceStart = previousVariable.declarationSourceStart;
488                 declaration.modifiers = previousVariable.modifiers;
489                 declaration.modifiersSourceStart = previousVariable.modifiersSourceStart;
490         }
491
492         localIntPtr = intPtr;
493
494         if (extendedTypeDimension == 0) {
495                 declaration.type = type;
496         } else {
497                 int dimension = typeDim + extendedTypeDimension;
498                 //on the identifierLengthStack there is the information about the type....
499                 int baseType;
500                 if ((baseType = identifierLengthStack[identifierLengthPtr + 1]) < 0) {
501                         //it was a baseType
502                         declaration.type = TypeReference.baseTypeReference(-baseType, dimension);
503                         declaration.type.sourceStart = type.sourceStart;
504                         declaration.type.sourceEnd = type.sourceEnd;
505                 } else {
506                         declaration.type = this.copyDims(type, dimension);
507                 }
508         }
509         variablesCounter[nestedType]++;
510         nestedMethod[nestedType]++;
511         pushOnAstStack(declaration);
512
513         int[] javadocPositions = intArrayStack[intArrayPtr];
514         if (!isLocalDeclaration) {
515                 requestor
516                         .enterField(
517                                 declaration.declarationSourceStart, 
518                                 javadocPositions, 
519                                 declaration.modifiers, 
520                                 declaration.modifiersSourceStart, 
521                                 returnTypeName(declaration.type), 
522                                 type.sourceStart, 
523                                 type.sourceEnd, 
524                                 typeDims, 
525                                 name, 
526                                 (int) (namePosition >>> 32), 
527                                 (int) namePosition, 
528                                 extendedTypeDimension, 
529                                 extendedTypeDimension == 0 ? -1 : endPosition); 
530         }
531 }
532 /**
533  *
534  * INTERNAL USE-ONLY
535  */
536 protected void consumeExitVariableWithInitialization() {
537         // ExitVariableWithInitialization ::= $empty
538         // the scanner is located after the comma or the semi-colon.
539         // we want to include the comma or the semi-colon
540         super.consumeExitVariableWithInitialization();
541         nestedMethod[nestedType]--;     
542         lastFieldEndPosition = scanner.currentPosition - 1;
543         lastFieldBodyEndPosition =      ((AbstractVariableDeclaration) astStack[astPtr]).initialization.sourceEnd;
544 }
545 protected void consumeExitVariableWithoutInitialization() {
546         // ExitVariableWithoutInitialization ::= $empty
547         // do nothing by default
548         super.consumeExitVariableWithoutInitialization();
549         nestedMethod[nestedType]--;     
550         lastFieldEndPosition = scanner.currentPosition - 1;
551         lastFieldBodyEndPosition = scanner.startPosition - 1;
552 }
553 /**
554  *
555  * INTERNAL USE-ONLY
556  */
557 protected void consumeFieldDeclaration() {
558         // See consumeLocalVariableDeclarationDefaultModifier() in case of change: duplicated code
559         // FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';'
560         // the super.consumeFieldDeclaration will reinitialize the variableCounter[nestedType]  
561         int variableIndex = variablesCounter[nestedType];
562         super.consumeFieldDeclaration();
563         intArrayPtr--;
564         if (isLocalDeclaration())
565                 return;
566         if (variableIndex != 0) {
567                 requestor.exitField(lastFieldBodyEndPosition, lastFieldEndPosition);
568         }
569 }
570 protected void consumeFormalParameter() {
571         // FormalParameter ::= Type VariableDeclaratorId ==> false
572         // FormalParameter ::= Modifiers Type VariableDeclaratorId ==> true
573         /*
574         astStack : 
575         identifierStack : type identifier
576         intStack : dim dim
577          ==>
578         astStack : Argument
579         identifierStack :  
580         intStack :  
581         */
582
583         identifierLengthPtr--;
584         char[] name = identifierStack[identifierPtr];
585         long namePositions = identifierPositionStack[identifierPtr--];
586         TypeReference type = getTypeReference(intStack[intPtr--] + intStack[intPtr--]);
587         intPtr -= 3;
588         Argument arg = 
589                 new Argument(
590                         name, 
591                         namePositions, 
592                         type, 
593                         intStack[intPtr + 1]); // modifiers
594         pushOnAstStack(arg);
595         intArrayPtr--;
596 }
597 /**
598  *
599  * INTERNAL USE-ONLY
600  */
601 protected void consumeInterfaceDeclaration() {
602         super.consumeInterfaceDeclaration();
603         // we know that we have a TypeDeclaration on the top of the astStack
604         if (isLocalDeclaration()) {
605                 // we ignore the local variable declarations
606                 return;
607         }
608         requestor.exitInterface(endStatementPosition, // the '}' is the end of the body
609          ((TypeDeclaration) astStack[astPtr]).declarationSourceEnd);
610 }
611 /**
612  *
613  * INTERNAL USE-ONLY
614  */
615 protected void consumeInterfaceHeader() {
616         //InterfaceHeader ::= $empty
617         super.consumeInterfaceHeader();
618         if (isLocalDeclaration()) {
619                 // we ignore the local variable declarations
620                 intArrayPtr--;
621                 return;
622         }
623         TypeDeclaration typeDecl = (TypeDeclaration) astStack[astPtr];
624         TypeReference[] superInterfaces = typeDecl.superInterfaces;
625         char[][] interfaceNames = null;
626         int[] interfaceNameStarts = null;
627         int[] interfacenameEnds = null;
628         int superInterfacesLength = 0;
629         if (superInterfaces != null) {
630                 superInterfacesLength = superInterfaces.length;
631                 interfaceNames = new char[superInterfacesLength][];
632                 interfaceNameStarts = new int[superInterfacesLength];
633                 interfacenameEnds = new int[superInterfacesLength];
634         }
635         if (superInterfaces != null) {
636                 for (int i = 0; i < superInterfacesLength; i++) {
637                         TypeReference superInterface = superInterfaces[i];
638                         interfaceNames[i] = CharOperation.concatWith(superInterface.getTypeName(), '.'); 
639                         interfaceNameStarts[i] = superInterface.sourceStart;
640                         interfacenameEnds[i] = superInterface.sourceEnd;
641                 }
642         }
643         // flush the comments related to the interface header
644         scanner.commentPtr = -1;
645         requestor.enterInterface(
646                 typeDecl.declarationSourceStart, 
647                 intArrayStack[intArrayPtr--], 
648                 typeDecl.modifiers, 
649                 typeDecl.modifiersSourceStart, 
650                 typeStartPosition, 
651                 typeDecl.name, 
652                 typeDecl.sourceStart, 
653                 typeDecl.sourceEnd, 
654                 interfaceNames, 
655                 interfaceNameStarts, 
656                 interfacenameEnds, 
657                 scanner.currentPosition - 1); 
658 }
659 protected void consumeInterfaceHeaderName() {
660         // InterfaceHeaderName ::= Modifiersopt 'interface' 'Identifier'
661         TypeDeclaration typeDecl;
662         if (nestedMethod[nestedType] == 0) {
663                 if (nestedType != 0) {
664                         typeDecl = new MemberTypeDeclaration(this.compilationUnit.compilationResult);
665                 } else {
666                         typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
667                 }
668         } else {
669                 // Record that the block has a declaration for local types
670                 typeDecl = new LocalTypeDeclaration(this.compilationUnit.compilationResult);
671                 markCurrentMethodWithLocalType();
672                 blockReal();
673         }
674
675         //highlight the name of the type
676         long pos = identifierPositionStack[identifierPtr];
677         typeDecl.sourceEnd = (int) pos;
678         typeDecl.sourceStart = (int) (pos >>> 32);
679         typeDecl.name = identifierStack[identifierPtr--];
680         identifierLengthPtr--;
681
682         //compute the declaration source too
683         // 'class' and 'interface' push an int position
684         typeStartPosition = typeDecl.declarationSourceStart = intStack[intPtr--];
685         intPtr--;
686         int declarationSourceStart = intStack[intPtr--];
687         typeDecl.modifiersSourceStart = intStack[intPtr--];
688         typeDecl.modifiers = intStack[intPtr--];
689         if (typeDecl.declarationSourceStart > declarationSourceStart) {
690                 typeDecl.declarationSourceStart = declarationSourceStart;
691         }
692         typeDecl.bodyStart = typeDecl.sourceEnd + 1;
693         pushOnAstStack(typeDecl);
694 }
695 /**
696  *
697  * INTERNAL USE-ONLY
698  */
699 protected void consumeLocalVariableDeclaration() {
700         // See consumeLocalVariableDeclarationDefaultModifier() in case of change: duplicated code
701         // FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';'
702
703         super.consumeLocalVariableDeclaration();
704         intArrayPtr--;
705 }
706 /**
707  *
708  * INTERNAL USE-ONLY
709  */
710 protected void consumeMethodDeclaration(boolean isNotAbstract) {
711         // MethodDeclaration ::= MethodHeader MethodBody
712         // AbstractMethodDeclaration ::= MethodHeader ';'
713         super.consumeMethodDeclaration(isNotAbstract);
714         if (isLocalDeclaration()) {
715                 // we ignore the local variable declarations
716                 return;
717         }
718         MethodDeclaration md = (MethodDeclaration) astStack[astPtr];
719         requestor.exitMethod(endStatementPosition, md.declarationSourceEnd);
720 }
721 /**
722  *
723  * INTERNAL USE-ONLY
724  */
725 protected void consumeMethodHeader() {
726         // MethodHeader ::= MethodHeaderName MethodHeaderParameters MethodHeaderExtendedDims ThrowsClauseopt
727         super.consumeMethodHeader();
728         if (isLocalDeclaration()) {
729                 // we ignore the local variable declarations
730                 intArrayPtr--;
731                 return;
732         }
733         MethodDeclaration md = (MethodDeclaration) astStack[astPtr];
734
735         TypeReference returnType = md.returnType;
736         char[] returnTypeName = returnTypeName(returnType);
737         Argument[] arguments = md.arguments;
738         char[][] argumentTypes = null;
739         char[][] argumentNames = null;
740         int[] argumentTypeStarts = null;
741         int[] argumentTypeEnds = null;
742         int[] argumentNameStarts = null;
743         int[] argumentNameEnds = null;
744         if (arguments != null) {
745                 int argumentLength = arguments.length;
746                 argumentTypes = new char[argumentLength][];
747                 argumentNames = new char[argumentLength][];
748                 argumentNameStarts = new int[argumentLength];
749                 argumentNameEnds = new int[argumentLength];
750                 argumentTypeStarts = new int[argumentLength];
751                 argumentTypeEnds = new int[argumentLength];
752                 for (int i = 0; i < argumentLength; i++) {
753                         Argument argument = arguments[i];
754                         TypeReference argumentType = argument.type;
755                         argumentTypes[i] = returnTypeName(argumentType);
756                         argumentNames[i] = argument.name;
757                         argumentNameStarts[i] = argument.sourceStart;
758                         argumentNameEnds[i] = argument.sourceEnd;
759                         argumentTypeStarts[i] = argumentType.sourceStart;
760                         argumentTypeEnds[i] = argumentType.sourceEnd;
761                 }
762         }
763         TypeReference[] thrownExceptions = md.thrownExceptions;
764         char[][] exceptionTypes = null;
765         int[] exceptionTypeStarts = null;
766         int[] exceptionTypeEnds = null;
767         if (thrownExceptions != null) {
768                 int thrownExceptionLength = thrownExceptions.length;
769                 exceptionTypeStarts = new int[thrownExceptionLength];
770                 exceptionTypeEnds = new int[thrownExceptionLength];
771                 exceptionTypes = new char[thrownExceptionLength][];
772                 for (int i = 0; i < thrownExceptionLength; i++) {
773                         TypeReference exception = thrownExceptions[i];
774                         exceptionTypes[i] = CharOperation.concatWith(exception.getTypeName(), '.');
775                         exceptionTypeStarts[i] = exception.sourceStart;
776                         exceptionTypeEnds[i] = exception.sourceEnd;
777                 }
778         }
779         requestor
780                 .enterMethod(
781                         md.declarationSourceStart, 
782                         intArrayStack[intArrayPtr--], 
783                         md.modifiers, 
784                         md.modifiersSourceStart, 
785                         returnTypeName, 
786                         returnType.sourceStart, 
787                         returnType.sourceEnd, 
788                         typeDims, 
789                         md.selector, 
790                         md.sourceStart, 
791                         (int) (selectorSourcePositions & 0xFFFFFFFFL), 
792                         argumentTypes, 
793                         argumentTypeStarts, 
794                         argumentTypeEnds, 
795                         argumentNames, 
796                         argumentNameStarts, 
797                         argumentNameEnds, 
798                         rParenPos, 
799                         extendsDim, 
800                         extendsDim == 0 ? -1 : endPosition, 
801                         exceptionTypes, 
802                         exceptionTypeStarts, 
803                         exceptionTypeEnds, 
804                         scanner.currentPosition - 1); 
805 }
806 protected void consumeMethodHeaderExtendedDims() {
807         // MethodHeaderExtendedDims ::= Dimsopt
808         // now we update the returnType of the method
809         MethodDeclaration md = (MethodDeclaration) astStack[astPtr];
810         int extendedDims = intStack[intPtr--];
811         extendsDim = extendedDims;
812         if (extendedDims != 0) {
813                 TypeReference returnType = md.returnType;
814                 md.sourceEnd = endPosition;
815                 int dims = returnType.dimensions() + extendedDims;
816                 int baseType;
817                 if ((baseType = identifierLengthStack[identifierLengthPtr + 1]) < 0) {
818                         //it was a baseType
819                         int sourceStart = returnType.sourceStart;
820                         int sourceEnd = returnType.sourceEnd;
821                         returnType = TypeReference.baseTypeReference(-baseType, dims);
822                         returnType.sourceStart = sourceStart;
823                         returnType.sourceEnd = sourceEnd;
824                         md.returnType = returnType;
825                 } else {
826                         md.returnType = this.copyDims(md.returnType, dims);
827                 }
828                 if (currentToken == TokenNameLBRACE) {
829                         md.bodyStart = endPosition + 1;
830                 }
831         }
832 }
833 protected void consumeMethodHeaderName() {
834         // MethodHeaderName ::= Modifiersopt Type 'Identifier' '('
835         MethodDeclaration md = new MethodDeclaration(this.compilationUnit.compilationResult);
836
837         //name
838         md.selector = identifierStack[identifierPtr];
839         selectorSourcePositions = identifierPositionStack[identifierPtr--];
840         identifierLengthPtr--;
841         //type
842         md.returnType = getTypeReference(typeDims = intStack[intPtr--]);
843         //modifiers
844         md.declarationSourceStart = intStack[intPtr--];
845         md.modifiersSourceStart = intStack[intPtr--];
846         md.modifiers = intStack[intPtr--];
847
848         //highlight starts at selector start
849         md.sourceStart = (int) (selectorSourcePositions >>> 32);
850         pushOnAstStack(md);
851         md.bodyStart = scanner.currentPosition-1;
852 }
853 protected void consumeModifiers() {
854         checkAnnotation(); // might update modifiers with AccDeprecated
855         pushOnIntStack(modifiers); // modifiers
856         pushOnIntStack(modifiersSourceStart);
857         pushOnIntStack(
858                 declarationSourceStart >= 0 ? declarationSourceStart : modifiersSourceStart); 
859         resetModifiers();
860 }
861 /**
862  *
863  * INTERNAL USE-ONLY
864  */
865 protected void consumePackageDeclarationName() {
866         /* persisting javadoc positions */
867         pushOnIntArrayStack(this.getJavaDocPositions());
868
869         super.consumePackageDeclarationName();
870         ImportReference importReference = compilationUnit.currentPackage;
871
872         requestor.acceptPackage(
873                 importReference.declarationSourceStart, 
874                 importReference.declarationSourceEnd, 
875                 intArrayStack[intArrayPtr--], 
876                 CharOperation.concatWith(importReference.getImportName(), '.'),
877                 importReference.sourceStart);
878 }
879 protected void consumePushModifiers() {
880         checkAnnotation(); // might update modifiers with AccDeprecated
881         pushOnIntStack(modifiers); // modifiers
882         if (modifiersSourceStart < 0) {
883                 pushOnIntStack(-1);
884                 pushOnIntStack(
885                         declarationSourceStart >= 0 ? declarationSourceStart : scanner.startPosition); 
886         } else {
887                 pushOnIntStack(modifiersSourceStart);
888                 pushOnIntStack(
889                         declarationSourceStart >= 0 ? declarationSourceStart : modifiersSourceStart); 
890         }
891         resetModifiers();
892 }
893 /**
894  *
895  * INTERNAL USE-ONLY
896  */
897 protected void consumeSingleTypeImportDeclarationName() {
898         // SingleTypeImportDeclarationName ::= 'import' Name
899
900         /* persisting javadoc positions */
901         pushOnIntArrayStack(this.getJavaDocPositions());
902
903         super.consumeSingleTypeImportDeclarationName();
904         ImportReference importReference = (ImportReference) astStack[astPtr];
905         requestor.acceptImport(
906                 importReference.declarationSourceStart, 
907                 importReference.declarationSourceEnd,
908                 intArrayStack[intArrayPtr--],
909                 CharOperation.concatWith(importReference.getImportName(), '.'),
910                 importReference.sourceStart,
911                 false);
912 }
913 /**
914  *
915  * INTERNAL USE-ONLY
916  */
917 protected void consumeStaticInitializer() {
918         // StaticInitializer ::=  StaticOnly Block
919         //push an Initializer
920         //optimize the push/pop
921         super.consumeStaticInitializer();
922         Initializer initializer = (Initializer) astStack[astPtr];
923         requestor.acceptInitializer(
924                 initializer.declarationSourceStart,
925                 initializer.declarationSourceEnd,
926                 intArrayStack[intArrayPtr--],
927                 AccStatic, 
928                 intStack[intPtr--], 
929                 initializer.block.sourceStart,
930                 initializer.declarationSourceEnd);
931 }
932 protected void consumeStaticOnly() {
933         // StaticOnly ::= 'static'
934         checkAnnotation(); // might update declaration source start
935         pushOnIntStack(modifiersSourceStart);
936         pushOnIntStack(
937                 declarationSourceStart >= 0 ? declarationSourceStart : modifiersSourceStart); 
938         jumpOverMethodBody();
939         nestedMethod[nestedType]++;
940         resetModifiers();
941 }
942 /**
943  *
944  * INTERNAL USE-ONLY
945  */
946 protected void consumeTypeImportOnDemandDeclarationName() {
947         // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
948
949         /* persisting javadoc positions */
950         pushOnIntArrayStack(this.getJavaDocPositions());
951
952         super.consumeTypeImportOnDemandDeclarationName();
953         ImportReference importReference = (ImportReference) astStack[astPtr];
954         requestor.acceptImport(
955                 importReference.declarationSourceStart, 
956                 importReference.declarationSourceEnd,
957                 intArrayStack[intArrayPtr--],
958                 CharOperation.concatWith(importReference.getImportName(), '.'), 
959                 importReference.sourceStart,
960                 true);
961 }
962 public CompilationUnitDeclaration endParse(int act) {
963         if (scanner.recordLineSeparator) {
964                 requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
965         }
966         return super.endParse(act);
967 }
968 /*
969  * Flush annotations defined prior to a given positions.
970  *
971  * Note: annotations are stacked in syntactical order
972  *
973  * Either answer given <position>, or the end position of a comment line 
974  * immediately following the <position> (same line)
975  *
976  * e.g.
977  * void foo(){
978  * } // end of method foo
979  */
980  
981 public int flushAnnotationsDefinedPriorTo(int position) {
982
983         return lastFieldEndPosition = super.flushAnnotationsDefinedPriorTo(position);
984 }
985 protected TypeReference getTypeReference(int dim) { /* build a Reference on a variable that may be qualified or not
986 This variable is a type reference and dim will be its dimensions*/
987
988         int length;
989         TypeReference ref;
990         if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
991                 // single variable reference
992                 if (dim == 0) {
993                         ref = 
994                                 new SingleTypeReference(
995                                         identifierStack[identifierPtr], 
996                                         identifierPositionStack[identifierPtr--]); 
997                 } else {
998                         ref = 
999                                 new ArrayTypeReference(
1000                                         identifierStack[identifierPtr], 
1001                                         dim, 
1002                                         identifierPositionStack[identifierPtr--]); 
1003                         ref.sourceEnd = endPosition;
1004                 }
1005         } else {
1006                 if (length < 0) { //flag for precompiled type reference on base types
1007                         ref = TypeReference.baseTypeReference(-length, dim);
1008                         ref.sourceStart = intStack[intPtr--];
1009                         if (dim == 0) {
1010                                 ref.sourceEnd = intStack[intPtr--];
1011                         } else {
1012                                 intPtr--;
1013                                 ref.sourceEnd = endPosition;
1014                         }
1015                 } else { //Qualified variable reference
1016                         char[][] tokens = new char[length][];
1017                         identifierPtr -= length;
1018                         long[] positions = new long[length];
1019                         System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
1020                         System.arraycopy(
1021                                 identifierPositionStack, 
1022                                 identifierPtr + 1, 
1023                                 positions, 
1024                                 0, 
1025                                 length); 
1026                         if (dim == 0) {
1027                                 ref = new QualifiedTypeReference(tokens, positions);
1028                         } else {
1029                                 ref = new ArrayQualifiedTypeReference(tokens, dim, positions);
1030                                 ref.sourceEnd = endPosition;
1031                         }
1032                 }
1033         };
1034         return ref;
1035 }
1036 public void initialize() {
1037         //positionning the parser for a new compilation unit
1038         //avoiding stack reallocation and all that....
1039         super.initialize();
1040         intArrayPtr = -1;
1041 }
1042 /**
1043  *
1044  * INTERNAL USE-ONLY
1045  */
1046 private boolean isLocalDeclaration() {
1047         int nestedDepth = nestedType;
1048         while (nestedDepth >= 0) {
1049                 if (nestedMethod[nestedDepth] != 0) {
1050                         return true;
1051                 }
1052                 nestedDepth--;
1053         }
1054         return false;
1055 }
1056 /*
1057  * Investigate one entire unit.
1058  */
1059 public void parseCompilationUnit(ICompilationUnit unit) {
1060         char[] regionSource = unit.getContents();
1061         try {
1062                 initialize();
1063                 goForCompilationUnit();
1064                 referenceContext =
1065                         compilationUnit = 
1066                                 compilationUnit = 
1067                                         new CompilationUnitDeclaration(
1068                                                 problemReporter(), 
1069                                                 new CompilationResult(unit, 0, 0, this.options.maxProblemsPerUnit), 
1070                                                 regionSource.length); 
1071                 scanner.resetTo(0, regionSource.length);
1072                 scanner.setSource(regionSource);
1073                 parse();
1074         } catch (AbortCompilation ex) {
1075         }
1076 }
1077 /*
1078  * Investigate one constructor declaration.
1079  */
1080 public void parseConstructor(char[] regionSource) {
1081         try {
1082                 initialize();
1083                 goForClassBodyDeclarations();
1084                 referenceContext = 
1085                         compilationUnit = 
1086                                 compilationUnit = 
1087                                         new CompilationUnitDeclaration(
1088                                                 problemReporter(), 
1089                                                 new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
1090                                                 regionSource.length); 
1091                 scanner.resetTo(0, regionSource.length);
1092                 scanner.setSource(regionSource);
1093                 parse();
1094         } catch (AbortCompilation ex) {
1095         }
1096 }
1097 /*
1098  * Investigate one field declaration statement (might have multiple declarations in it).
1099  */
1100 public void parseField(char[] regionSource) {
1101         try {
1102                 initialize();
1103                 goForFieldDeclaration();
1104                 referenceContext = 
1105                         compilationUnit = 
1106                                 compilationUnit = 
1107                                         new CompilationUnitDeclaration(
1108                                                 problemReporter(), 
1109                                                 new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
1110                                                 regionSource.length); 
1111                 scanner.resetTo(0, regionSource.length);
1112                 scanner.setSource(regionSource);
1113                 parse();
1114         } catch (AbortCompilation ex) {
1115         }
1116
1117 }
1118 /*
1119  * Investigate one import statement declaration.
1120  */
1121 public void parseImport(char[] regionSource) {
1122         try {
1123                 initialize();
1124                 goForImportDeclaration();
1125                 referenceContext = 
1126                         compilationUnit = 
1127                                 compilationUnit = 
1128                                         new CompilationUnitDeclaration(
1129                                                 problemReporter(), 
1130                                                 new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
1131                                                 regionSource.length); 
1132                 scanner.resetTo(0, regionSource.length);
1133                 scanner.setSource(regionSource);
1134                 parse();
1135         } catch (AbortCompilation ex) {
1136         }
1137
1138 }
1139 /*
1140  * Investigate one initializer declaration.
1141  * regionSource need to content exactly an initializer declaration.
1142  * e.g: static { i = 4; }
1143  * { name = "test"; }
1144  */
1145 public void parseInitializer(char[] regionSource) {
1146         try {
1147                 initialize();
1148                 goForInitializer();
1149                 referenceContext = 
1150                         compilationUnit = 
1151                                 compilationUnit = 
1152                                         new CompilationUnitDeclaration(
1153                                                 problemReporter(), 
1154                                                 new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
1155                                                 regionSource.length); 
1156                 scanner.resetTo(0, regionSource.length);
1157                 scanner.setSource(regionSource);
1158                 parse();
1159         } catch (AbortCompilation ex) {
1160         }
1161
1162 }
1163 /*
1164  * Investigate one method declaration.
1165  */
1166 public void parseMethod(char[] regionSource) {
1167         try {
1168                 initialize();
1169                 goForGenericMethodDeclaration();
1170                 referenceContext = 
1171                         compilationUnit = 
1172                                 compilationUnit = 
1173                                         new CompilationUnitDeclaration(
1174                                                 problemReporter(), 
1175                                                 new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
1176                                                 regionSource.length); 
1177                 scanner.resetTo(0, regionSource.length);
1178                 scanner.setSource(regionSource);
1179                 parse();
1180         } catch (AbortCompilation ex) {
1181         }
1182
1183 }
1184 /*
1185  * Investigate one package statement declaration.
1186  */
1187 public void parsePackage(char[] regionSource) {
1188         try {
1189                 initialize();
1190                 goForPackageDeclaration();
1191                 referenceContext = 
1192                         compilationUnit = 
1193                                 compilationUnit = 
1194                                         new CompilationUnitDeclaration(
1195                                                 problemReporter(), 
1196                                                 new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
1197                                                 regionSource.length); 
1198                 scanner.resetTo(0, regionSource.length);
1199                 scanner.setSource(regionSource);
1200                 parse();
1201         } catch (AbortCompilation ex) {
1202         }
1203
1204 }
1205 /*
1206  * Investigate one type declaration, its fields, methods and member types.
1207  */
1208 public void parseType(char[] regionSource) {
1209         try {
1210                 initialize();
1211                 goForTypeDeclaration();
1212                 referenceContext = 
1213                         compilationUnit = 
1214                                 compilationUnit = 
1215                                         new CompilationUnitDeclaration(
1216                                                 problemReporter(), 
1217                                                 new CompilationResult(regionSource, 0, 0, this.options.maxProblemsPerUnit), 
1218                                                 regionSource.length); 
1219                 scanner.resetTo(0, regionSource.length);
1220                 scanner.setSource(regionSource);
1221                 parse();
1222         } catch (AbortCompilation ex) {
1223         }
1224
1225 }
1226 /**
1227  * Returns this parser's problem reporter initialized with its reference context.
1228  * Also it is assumed that a problem is going to be reported, so initializes
1229  * the compilation result's line positions.
1230  */
1231 public ProblemReporter problemReporter() {
1232         problemReporter.referenceContext = referenceContext;
1233         return problemReporter;
1234 }
1235 protected void pushOnIntArrayStack(int[] positions) {
1236
1237         try {
1238                 intArrayStack[++intArrayPtr] = positions;
1239         } catch (IndexOutOfBoundsException e) {
1240                 //intPtr is correct 
1241                 int oldStackLength = intArrayStack.length;
1242                 int oldStack[][] = intArrayStack;
1243                 intArrayStack = new int[oldStackLength + StackIncrement][];
1244                 System.arraycopy(oldStack, 0, intArrayStack, 0, oldStackLength);
1245                 intArrayStack[intArrayPtr] = positions;
1246         }
1247 }
1248 protected void resetModifiers() {
1249         super.resetModifiers();
1250         declarationSourceStart = -1;
1251 }
1252 /*
1253  * Syntax error was detected. Will attempt to perform some recovery action in order
1254  * to resume to the regular parse loop.
1255  */
1256 protected boolean resumeOnSyntaxError() {
1257         return false;
1258 }
1259 /*
1260  * Answer a char array representation of the type name formatted like:
1261  * - type name + dimensions
1262  * Example:
1263  * "A[][]".toCharArray()
1264  * "java.lang.String".toCharArray()
1265  */
1266 private char[] returnTypeName(TypeReference type) {
1267         int dimension = type.dimensions();
1268         if (dimension != 0) {
1269                 char[] dimensionsArray = new char[dimension * 2];
1270                 for (int i = 0; i < dimension; i++) {
1271                         dimensionsArray[i*2] = '[';
1272                         dimensionsArray[(i*2) + 1] = ']';
1273                 }
1274                 return CharOperation.concat(
1275                         CharOperation.concatWith(type.getTypeName(), '.'), 
1276                         dimensionsArray); 
1277         }
1278         return CharOperation.concatWith(type.getTypeName(), '.');
1279 }
1280 public String toString() {
1281         StringBuffer buffer = new StringBuffer();
1282         buffer.append("intArrayPtr = " + intArrayPtr + "\n"); //$NON-NLS-1$ //$NON-NLS-2$
1283         buffer.append(super.toString());
1284         return buffer.toString();
1285 }
1286 /**
1287  * INTERNAL USE ONLY
1288  */
1289 protected TypeReference typeReference(
1290         int dim,
1291         int localIdentifierPtr, 
1292         int localIdentifierLengthPtr) {
1293         /* build a Reference on a variable that may be qualified or not
1294          * This variable is a type reference and dim will be its dimensions.
1295          * We don't have any side effect on the stacks' pointers.
1296          */
1297
1298         int length;
1299         TypeReference ref;
1300         if ((length = identifierLengthStack[localIdentifierLengthPtr]) == 1) {
1301                 // single variable reference
1302                 if (dim == 0) {
1303                         ref = 
1304                                 new SingleTypeReference(
1305                                         identifierStack[localIdentifierPtr], 
1306                                         identifierPositionStack[localIdentifierPtr--]); 
1307                 } else {
1308                         ref = 
1309                                 new ArrayTypeReference(
1310                                         identifierStack[localIdentifierPtr], 
1311                                         dim, 
1312                                         identifierPositionStack[localIdentifierPtr--]); 
1313                         ref.sourceEnd = endPosition;                            
1314                 }
1315         } else {
1316                 if (length < 0) { //flag for precompiled type reference on base types
1317                         ref = TypeReference.baseTypeReference(-length, dim);
1318                         ref.sourceStart = intStack[localIntPtr--];
1319                         if (dim == 0) {
1320                                 ref.sourceEnd = intStack[localIntPtr--];
1321                         } else {
1322                                 localIntPtr--;
1323                                 ref.sourceEnd = endPosition;
1324                         }
1325                 } else { //Qualified variable reference
1326                         char[][] tokens = new char[length][];
1327                         localIdentifierPtr -= length;
1328                         long[] positions = new long[length];
1329                         System.arraycopy(identifierStack, localIdentifierPtr + 1, tokens, 0, length);
1330                         System.arraycopy(
1331                                 identifierPositionStack, 
1332                                 localIdentifierPtr + 1, 
1333                                 positions, 
1334                                 0, 
1335                                 length); 
1336                         if (dim == 0)
1337                                 ref = new QualifiedTypeReference(tokens, positions);
1338                         else
1339                                 ref = new ArrayQualifiedTypeReference(tokens, dim, positions);
1340                 }
1341         };
1342         return ref;
1343 }
1344 }