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