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