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