net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/DocumentElementParser.java

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