net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/SourceElementParser.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 java.util.ArrayList;
  14
  15 import net.sourceforge.phpdt.core.compiler.CharOperation;
  16 import net.sourceforge.phpdt.core.compiler.IProblem;
  17 import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit;
  18 import net.sourceforge.phpdt.internal.compiler.env.ISourceType;
  19 import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
  20 import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext;
  21 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
  22 import net.sourceforge.phpdt.internal.compiler.lookup.ClassScope;
  23 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
  24 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
  25 import net.sourceforge.phpdt.internal.core.util.CommentRecorderParser;
  26 import net.sourceforge.phpeclipse.internal.compiler.ast.AbstractMethodDeclaration;
  27 import net.sourceforge.phpeclipse.internal.compiler.ast.AnonymousLocalTypeDeclaration;
  28 import net.sourceforge.phpeclipse.internal.compiler.ast.Argument;
  29 import net.sourceforge.phpeclipse.internal.compiler.ast.AstNode;
  30 import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration;
  31 import net.sourceforge.phpeclipse.internal.compiler.ast.ConstructorDeclaration;
  32 import net.sourceforge.phpeclipse.internal.compiler.ast.ExplicitConstructorCall;
  33 import net.sourceforge.phpeclipse.internal.compiler.ast.FieldDeclaration;
  34 import net.sourceforge.phpeclipse.internal.compiler.ast.ImportReference;
  35 import net.sourceforge.phpeclipse.internal.compiler.ast.LocalTypeDeclaration;
  36 import net.sourceforge.phpeclipse.internal.compiler.ast.MemberTypeDeclaration;
  37 import net.sourceforge.phpeclipse.internal.compiler.ast.MethodDeclaration;
  38 import net.sourceforge.phpeclipse.internal.compiler.ast.NameReference;
  39 import net.sourceforge.phpeclipse.internal.compiler.ast.QualifiedAllocationExpression;
  40 import net.sourceforge.phpeclipse.internal.compiler.ast.TypeDeclaration;
  41 import net.sourceforge.phpeclipse.internal.compiler.ast.TypeReference;
  42
  43 /**
  44  * A source element parser extracts structural and reference information
  45  * from a piece of source.
  46  *
  47  * also see @ISourceElementRequestor
  48  *
  49  * The structural investigation includes:
  50  * - the package statement
  51  * - import statements
  52  * - top-level types: package member, member types (member types of member types...)
  53  * - fields
  54  * - methods
  55  *
  56  * If reference information is requested, then all source constructs are
  57  * investigated and type, field & method references are provided as well.
  58  *
  59  * Any (parsing) problem encountered is also provided.
  60  */
  61
  62 public class SourceElementParser extends CommentRecorderParser {//extends
  63                                                                 // UnitParser {
  64
  65   ISourceElementRequestor requestor;
  66   int fieldCount;
  67   int localIntPtr;
  68   int lastFieldEndPosition;
  69   ISourceType sourceType;
  70   boolean reportReferenceInfo;
  71   char[][] typeNames;
  72   char[][] superTypeNames;
  73   int nestedTypeIndex;
  74   static final char[] JAVA_LANG_OBJECT = "java.lang.Object".toCharArray(); //$NON-NLS-1$
  75   NameReference[] unknownRefs;
  76   int unknownRefsCounter;
  77   LocalDeclarationVisitor localDeclarationVisitor = null;
  78   //    CompilerOptions options;
  79
  80   /**
  81    * An ast visitor that visits local type declarations.
  82    */
  83   public class LocalDeclarationVisitor extends AbstractSyntaxTreeVisitorAdapter {
  84     //  public boolean visit(
  85     //                  AnonymousLocalTypeDeclaration anonymousTypeDeclaration,
  86     //                  BlockScope scope) {
  87     //          notifySourceElementRequestor(anonymousTypeDeclaration, sourceType ==
  88     // null);
  89     //          return false; // don't visit members as this was done during
  90     // notifySourceElementRequestor(...)
  91     //  }
  92     public boolean visit(LocalTypeDeclaration typeDeclaration, BlockScope scope) {
  93       notifySourceElementRequestor(typeDeclaration, sourceType == null);
  94       return false; // don't visit members as this was done during
  95                     // notifySourceElementRequestor(...)
  96     }
  97     public boolean visit(MemberTypeDeclaration typeDeclaration, ClassScope scope) {
  98       notifySourceElementRequestor(typeDeclaration, sourceType == null);
  99       return false; // don't visit members as this was done during
 100                     // notifySourceElementRequestor(...)
 101     }
 102
 103   }
 104
 105   public SourceElementParser(final ISourceElementRequestor requestor, IProblemFactory problemFactory, CompilerOptions options) {
 106     // we want to notify all syntax error with the acceptProblem API
 107     // To do so, we define the record method of the ProblemReporter
 108     super(new ProblemReporter(DefaultErrorHandlingPolicies.exitAfterAllProblems(), options, problemFactory) {
 109       public void record(IProblem problem, CompilationResult unitResult, ReferenceContext referenceContext) {
 110         unitResult.record(problem, referenceContext);
 111         requestor.acceptProblem(problem);
 112       }
 113     });
 114     //  true);
 115     //  options.sourceLevel >= CompilerOptions.JDK1_4);
 116     this.requestor = requestor;
 117     typeNames = new char[4][];
 118     superTypeNames = new char[4][];
 119     nestedTypeIndex = 0;
 120     this.options = options;
 121   }
 122
 123   /**
 124    * @deprecated use SourceElementParser(ISourceElementRequestor,
 125    *             IProblemFactory, CompilerOptions)
 126    */
 127   //public SourceElementParser(
 128   //    final ISourceElementRequestor requestor,
 129   //    IProblemFactory problemFactory) {
 130   //            this(requestor, problemFactory, new CompilerOptions());
 131   //}
 132   //public SourceElementParser(
 133   //    final ISourceElementRequestor requestor,
 134   //    IProblemFactory problemFactory,
 135   //    CompilerOptions options,
 136   //    boolean reportLocalDeclarations) {
 137   //            this(requestor, problemFactory, options);
 138   //            if (reportLocalDeclarations) {
 139   //                    this.localDeclarationVisitor = new LocalDeclarationVisitor();
 140   //            }
 141   //}
 142   //public void checkAnnotation() {
 143   //    int firstCommentIndex = scanner.commentPtr;
 144   //
 145   //    super.checkAnnotation();
 146   //
 147   //    // modify the modifier source start to point at the first comment
 148   //    if (firstCommentIndex >= 0) {
 149   //            modifiersSourceStart = scanner.commentStarts[0];
 150   //    }
 151   //}
 152   //protected void classInstanceCreation(boolean alwaysQualified) {
 153   //
 154   //    boolean previousFlag = reportReferenceInfo;
 155   //    reportReferenceInfo = false; // not to see the type reference reported in
 156   // super call to getTypeReference(...)
 157   //    super.classInstanceCreation(alwaysQualified);
 158   //    reportReferenceInfo = previousFlag;
 159   //    if (reportReferenceInfo){
 160   //            AllocationExpression alloc =
 161   // (AllocationExpression)expressionStack[expressionPtr];
 162   //            TypeReference typeRef = alloc.type;
 163   //            requestor.acceptConstructorReference(
 164   //                    typeRef instanceof SingleTypeReference
 165   //                            ? ((SingleTypeReference) typeRef).token
 166   //                            : CharOperation.concatWith(alloc.type.getTypeName(), '.'),
 167   //                    alloc.arguments == null ? 0 : alloc.arguments.length,
 168   //                    alloc.sourceStart);
 169   //    }
 170   //}
 171   //protected void consumeConstructorHeaderName() {
 172   //    // ConstructorHeaderName ::= Modifiersopt 'Identifier' '('
 173   //
 174   //    /* recovering - might be an empty message send */
 175   //    if (currentElement != null){
 176   //            if (lastIgnoredToken == TokenNamenew){ // was an allocation expression
 177   //                    lastCheckPoint = scanner.startPosition; // force to restart at this exact
 178   // position
 179   //                    restartRecovery = true;
 180   //                    return;
 181   //            }
 182   //    }
 183   //    SourceConstructorDeclaration cd = new
 184   // SourceConstructorDeclaration(this.compilationUnit.compilationResult);
 185   //
 186   //    //name -- this is not really revelant but we do .....
 187   //    cd.selector = identifierStack[identifierPtr];
 188   //    long selectorSourcePositions = identifierPositionStack[identifierPtr--];
 189   //    identifierLengthPtr--;
 190   //
 191   //    //modifiers
 192   //    cd.declarationSourceStart = intStack[intPtr--];
 193   //    cd.modifiers = intStack[intPtr--];
 194   //
 195   //    //highlight starts at the selector starts
 196   //    cd.sourceStart = (int) (selectorSourcePositions >>> 32);
 197   //    cd.selectorSourceEnd = (int) selectorSourcePositions;
 198   //    pushOnAstStack(cd);
 199   //
 200   //    cd.sourceEnd = lParenPos;
 201   //    cd.bodyStart = lParenPos+1;
 202   //    listLength = 0; // initialize listLength before reading parameters/throws
 203   //
 204   //    // recovery
 205   //    if (currentElement != null){
 206   //            lastCheckPoint = cd.bodyStart;
 207   //            if ((currentElement instanceof RecoveredType && lastIgnoredToken !=
 208   // TokenNameDOT)
 209   //                    || cd.modifiers != 0){
 210   //                    currentElement = currentElement.add(cd, 0);
 211   //                    lastIgnoredToken = -1;
 212   //            }
 213   //    }
 214   //}
 215   ///**
 216   // *
 217   // * INTERNAL USE-ONLY
 218   // */
 219   //protected void consumeExitVariableWithInitialization() {
 220   //    // ExitVariableWithInitialization ::= $empty
 221   //    // the scanner is located after the comma or the semi-colon.
 222   //    // we want to include the comma or the semi-colon
 223   //    super.consumeExitVariableWithInitialization();
 224   //    if (isLocalDeclaration() || ((currentToken != TokenNameCOMMA) &&
 225   // (currentToken != TokenNameSEMICOLON)))
 226   //            return;
 227   //    ((SourceFieldDeclaration) astStack[astPtr]).fieldEndPosition =
 228   // scanner.currentPosition - 1;
 229   //}
 230   //protected void consumeExitVariableWithoutInitialization() {
 231   //    // ExitVariableWithoutInitialization ::= $empty
 232   //    // do nothing by default
 233   //    super.consumeExitVariableWithoutInitialization();
 234   //    if (isLocalDeclaration() || ((currentToken != TokenNameCOMMA) &&
 235   // (currentToken != TokenNameSEMICOLON)))
 236   //            return;
 237   //    ((SourceFieldDeclaration) astStack[astPtr]).fieldEndPosition =
 238   // scanner.currentPosition - 1;
 239   //}
 240   ///**
 241   // *
 242   // * INTERNAL USE-ONLY
 243   // */
 244   //protected void consumeFieldAccess(boolean isSuperAccess) {
 245   //    // FieldAccess ::= Primary '.' 'Identifier'
 246   //    // FieldAccess ::= 'super' '.' 'Identifier'
 247   //    super.consumeFieldAccess(isSuperAccess);
 248   //    FieldReference fr = (FieldReference) expressionStack[expressionPtr];
 249   //    if (reportReferenceInfo) {
 250   //            requestor.acceptFieldReference(fr.token, fr.sourceStart);
 251   //    }
 252   //}
 253   //protected void consumeMethodHeaderName() {
 254   //    // MethodHeaderName ::= Modifiersopt Type 'Identifier' '('
 255   //    SourceMethodDeclaration md = new
 256   // SourceMethodDeclaration(this.compilationUnit.compilationResult);
 257   //
 258   //    //name
 259   //    md.selector = identifierStack[identifierPtr];
 260   //    long selectorSourcePositions = identifierPositionStack[identifierPtr--];
 261   //    identifierLengthPtr--;
 262   //    //type
 263   //    md.returnType = getTypeReference(intStack[intPtr--]);
 264   //    //modifiers
 265   //    md.declarationSourceStart = intStack[intPtr--];
 266   //    md.modifiers = intStack[intPtr--];
 267   //
 268   //    //highlight starts at selector start
 269   //    md.sourceStart = (int) (selectorSourcePositions >>> 32);
 270   //    md.selectorSourceEnd = (int) selectorSourcePositions;
 271   //    pushOnAstStack(md);
 272   //    md.sourceEnd = lParenPos;
 273   //    md.bodyStart = lParenPos+1;
 274   //    listLength = 0; // initialize listLength before reading parameters/throws
 275   //
 276   //    // recovery
 277   //    if (currentElement != null){
 278   //            if (currentElement instanceof RecoveredType
 279   //                    //|| md.modifiers != 0
 280   //                    || (scanner.getLineNumber(md.returnType.sourceStart)
 281   //                                    == scanner.getLineNumber(md.sourceStart))){
 282   //                    lastCheckPoint = md.bodyStart;
 283   //                    currentElement = currentElement.add(md, 0);
 284   //                    lastIgnoredToken = -1;
 285   //            } else {
 286   //                    lastCheckPoint = md.sourceStart;
 287   //                    restartRecovery = true;
 288   //            }
 289   //    }
 290   //}
 291   ///**
 292   // *
 293   // * INTERNAL USE-ONLY
 294   // */
 295   //protected void consumeMethodInvocationName() {
 296   //    // MethodInvocation ::= Name '(' ArgumentListopt ')'
 297   //
 298   //    // when the name is only an identifier...we have a message send to "this"
 299   // (implicit)
 300   //    super.consumeMethodInvocationName();
 301   //    MessageSend messageSend = (MessageSend) expressionStack[expressionPtr];
 302   //    Expression[] args = messageSend.arguments;
 303   //    if (reportReferenceInfo) {
 304   //            requestor.acceptMethodReference(
 305   //                    messageSend.selector,
 306   //                    args == null ? 0 : args.length,
 307   //                    (int)(messageSend.nameSourcePosition >>> 32));
 308   //    }
 309   //}
 310   ///**
 311   // *
 312   // * INTERNAL USE-ONLY
 313   // */
 314   //protected void consumeMethodInvocationPrimary() {
 315   //    super.consumeMethodInvocationPrimary();
 316   //    MessageSend messageSend = (MessageSend) expressionStack[expressionPtr];
 317   //    Expression[] args = messageSend.arguments;
 318   //    if (reportReferenceInfo) {
 319   //            requestor.acceptMethodReference(
 320   //                    messageSend.selector,
 321   //                    args == null ? 0 : args.length,
 322   //                    (int)(messageSend.nameSourcePosition >>> 32));
 323   //    }
 324   //}
 325   ///**
 326   // *
 327   // * INTERNAL USE-ONLY
 328   // */
 329   //protected void consumeMethodInvocationSuper() {
 330   //    // MethodInvocation ::= 'super' '.' 'Identifier' '(' ArgumentListopt ')'
 331   //    super.consumeMethodInvocationSuper();
 332   //    MessageSend messageSend = (MessageSend) expressionStack[expressionPtr];
 333   //    Expression[] args = messageSend.arguments;
 334   //    if (reportReferenceInfo) {
 335   //            requestor.acceptMethodReference(
 336   //                    messageSend.selector,
 337   //                    args == null ? 0 : args.length,
 338   //                    (int)(messageSend.nameSourcePosition >>> 32));
 339   //    }
 340   //}
 341   //protected void consumeSingleTypeImportDeclarationName() {
 342   //    // SingleTypeImportDeclarationName ::= 'import' Name
 343   //    /* push an ImportRef build from the last name
 344   //    stored in the identifier stack. */
 345   //
 346   //    super.consumeSingleTypeImportDeclarationName();
 347   //    ImportReference impt = (ImportReference)astStack[astPtr];
 348   //    if (reportReferenceInfo) {
 349   //            requestor.acceptTypeReference(impt.tokens, impt.sourceStart,
 350   // impt.sourceEnd);
 351   //    }
 352   //}
 353   //protected void consumeTypeImportOnDemandDeclarationName() {
 354   //    // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
 355   //    /* push an ImportRef build from the last name
 356   //    stored in the identifier stack. */
 357   //
 358   //    super.consumeTypeImportOnDemandDeclarationName();
 359   //    ImportReference impt = (ImportReference)astStack[astPtr];
 360   //    if (reportReferenceInfo) {
 361   //            requestor.acceptUnknownReference(impt.tokens, impt.sourceStart,
 362   // impt.sourceEnd);
 363   //    }
 364   //}
 365   //protected FieldDeclaration createFieldDeclaration(Expression
 366   // initialization, char[] name, int sourceStart, int sourceEnd) {
 367   //    return new SourceFieldDeclaration(null, name, sourceStart, sourceEnd);
 368   //}
 369   //protected CompilationUnitDeclaration endParse(int act) {
 370   //    if (sourceType != null) {
 371   //            if (sourceType.isInterface()) {
 372   //                    consumeInterfaceDeclaration();
 373   //            } else {
 374   //                    consumeClassDeclaration();
 375   //            }
 376   //    }
 377   //    if (compilationUnit != null) {
 378   //            CompilationUnitDeclaration result = super.endParse(act);
 379   //            return result;
 380   //    } else {
 381   //            return null;
 382   //    }
 383   //}
 384   /*
 385    * Flush annotations defined prior to a given positions.
 386    *
 387    * Note: annotations are stacked in syntactical order
 388    *
 389    * Either answer given <position>, or the end position of a comment line
 390    * immediately following the <position> (same line)
 391    *
 392    * e.g. void foo(){ } // end of method foo
 393    */
 394   //
 395   //public int flushAnnotationsDefinedPriorTo(int position) {
 396   //
 397   //    return lastFieldEndPosition =
 398   // super.flushAnnotationsDefinedPriorTo(position);
 399   //}
 400   //public TypeReference getTypeReference(int dim) {
 401   //    /* build a Reference on a variable that may be qualified or not
 402   //     * This variable is a type reference and dim will be its dimensions
 403   //     */
 404   //    int length;
 405   //    if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
 406   //            // single variable reference
 407   //            if (dim == 0) {
 408   //                    SingleTypeReference ref =
 409   //                            new SingleTypeReference(
 410   //                                    identifierStack[identifierPtr],
 411   //                                    identifierPositionStack[identifierPtr--]);
 412   //                    if (reportReferenceInfo) {
 413   //                            requestor.acceptTypeReference(ref.token, ref.sourceStart);
 414   //                    }
 415   //                    return ref;
 416   //            } else {
 417   //                    ArrayTypeReference ref =
 418   //                            new ArrayTypeReference(
 419   //                                    identifierStack[identifierPtr],
 420   //                                    dim,
 421   //                                    identifierPositionStack[identifierPtr--]);
 422   //                    ref.sourceEnd = endPosition;
 423   //                    if (reportReferenceInfo) {
 424   //                            requestor.acceptTypeReference(ref.token, ref.sourceStart);
 425   //                    }
 426   //                    return ref;
 427   //            }
 428   //    } else {
 429   //            if (length < 0) { //flag for precompiled type reference on base types
 430   //                    TypeReference ref = TypeReference.baseTypeReference(-length, dim);
 431   //                    ref.sourceStart = intStack[intPtr--];
 432   //                    if (dim == 0) {
 433   //                            ref.sourceEnd = intStack[intPtr--];
 434   //                    } else {
 435   //                            intPtr--; // no need to use this position as it is an array
 436   //                            ref.sourceEnd = endPosition;
 437   //                    }
 438   //                    if (reportReferenceInfo){
 439   //                                    requestor.acceptTypeReference(ref.getTypeName(), ref.sourceStart,
 440   // ref.sourceEnd);
 441   //                    }
 442   //                    return ref;
 443   //            } else { //Qualified variable reference
 444   //                    char[][] tokens = new char[length][];
 445   //                    identifierPtr -= length;
 446   //                    long[] positions = new long[length];
 447   //                    System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
 448   //                    System.arraycopy(
 449   //                            identifierPositionStack,
 450   //                            identifierPtr + 1,
 451   //                            positions,
 452   //                            0,
 453   //                            length);
 454   //                    if (dim == 0) {
 455   //                            QualifiedTypeReference ref = new QualifiedTypeReference(tokens, positions);
 456   //                            if (reportReferenceInfo) {
 457   //                                    requestor.acceptTypeReference(ref.tokens, ref.sourceStart, ref.sourceEnd);
 458   //                            }
 459   //                            return ref;
 460   //                    } else {
 461   //                            ArrayQualifiedTypeReference ref =
 462   //                                    new ArrayQualifiedTypeReference(tokens, dim, positions);
 463   //                            ref.sourceEnd = endPosition;
 464   //                            if (reportReferenceInfo) {
 465   //                                    requestor.acceptTypeReference(ref.tokens, ref.sourceStart, ref.sourceEnd);
 466   //                            }
 467   //                            return ref;
 468   //                    }
 469   //            }
 470   //    }
 471   //}
 472   //public NameReference getUnspecifiedReference() {
 473   //    /* build a (unspecified) NameReference which may be qualified*/
 474   //
 475   //    int length;
 476   //    if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
 477   //            // single variable reference
 478   //            SingleNameReference ref =
 479   //                    new SingleNameReference(
 480   //                            identifierStack[identifierPtr],
 481   //                            identifierPositionStack[identifierPtr--]);
 482   //            if (reportReferenceInfo) {
 483   //                    this.addUnknownRef(ref);
 484   //            }
 485   //            return ref;
 486   //    } else {
 487   //            //Qualified variable reference
 488   //            char[][] tokens = new char[length][];
 489   //            identifierPtr -= length;
 490   //            System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
 491   //            QualifiedNameReference ref =
 492   //                    new QualifiedNameReference(
 493   //                            tokens,
 494   //                            (int) (identifierPositionStack[identifierPtr + 1] >> 32), // sourceStart
 495   //                            (int) identifierPositionStack[identifierPtr + length]); // sourceEnd
 496   //            if (reportReferenceInfo) {
 497   //                    this.addUnknownRef(ref);
 498   //            }
 499   //            return ref;
 500   //    }
 501   //}
 502   //public NameReference getUnspecifiedReferenceOptimized() {
 503   //    /* build a (unspecified) NameReference which may be qualified
 504   //    The optimization occurs for qualified reference while we are
 505   //    certain in this case the last item of the qualified name is
 506   //    a field access. This optimization is IMPORTANT while it results
 507   //    that when a NameReference is build, the type checker should always
 508   //    look for that it is not a type reference */
 509   //
 510   //    int length;
 511   //    if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
 512   //            // single variable reference
 513   //            SingleNameReference ref =
 514   //                    new SingleNameReference(
 515   //                            identifierStack[identifierPtr],
 516   //                            identifierPositionStack[identifierPtr--]);
 517   //            ref.bits &= ~AstNode.RestrictiveFlagMASK;
 518   //            ref.bits |= LOCAL | FIELD;
 519   //            if (reportReferenceInfo) {
 520   //                    this.addUnknownRef(ref);
 521   //            }
 522   //            return ref;
 523   //    }
 524   //
 525   //    //Qualified-variable-reference
 526   //    //In fact it is variable-reference DOT field-ref , but it would result in a
 527   // type
 528   //    //conflict tha can be only reduce by making a superclass (or inetrface )
 529   // between
 530   //    //nameReference and FiledReference or putting FieldReference under
 531   // NameReference
 532   //    //or else..........This optimisation is not really relevant so just leave
 533   // as it is
 534   //
 535   //    char[][] tokens = new char[length][];
 536   //    identifierPtr -= length;
 537   //    System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
 538   //    QualifiedNameReference ref =
 539   //            new QualifiedNameReference(
 540   //                    tokens,
 541   //                    (int) (identifierPositionStack[identifierPtr + 1] >> 32),
 542   //    // sourceStart
 543   //     (int) identifierPositionStack[identifierPtr + length]); // sourceEnd
 544   //    ref.bits &= ~AstNode.RestrictiveFlagMASK;
 545   //    ref.bits |= LOCAL | FIELD;
 546   //    if (reportReferenceInfo) {
 547   //            this.addUnknownRef(ref);
 548   //    }
 549   //    return ref;
 550   //}
 551   ///**
 552   // *
 553   // * INTERNAL USE-ONLY
 554   // */
 555   //private boolean isLocalDeclaration() {
 556   //    int nestedDepth = nestedType;
 557   //    while (nestedDepth >= 0) {
 558   //            if (nestedMethod[nestedDepth] != 0) {
 559   //                    return true;
 560   //            }
 561   //            nestedDepth--;
 562   //    }
 563   //    return false;
 564   //}
 565   /*
 566    * Update the bodyStart of the corresponding parse node
 567    */
 568   public void notifySourceElementRequestor(CompilationUnitDeclaration parsedUnit) {
 569     if (parsedUnit == null) {
 570       // when we parse a single type member declaration the compilation unit is
 571       // null, but we still
 572       // want to be able to notify the requestor on the created ast node
 573       if (astStack[0] instanceof AbstractMethodDeclaration) {
 574         notifySourceElementRequestor((AbstractMethodDeclaration) astStack[0]);
 575         return;
 576       }
 577       return;
 578     }
 579     // range check
 580     boolean isInRange = scanner.initialPosition <= parsedUnit.sourceStart && scanner.eofPosition >= parsedUnit.sourceEnd;
 581
 582     //  if (reportReferenceInfo) {
 583     //          notifyAllUnknownReferences();
 584     //  }
 585     // collect the top level ast nodes
 586     int length = 0;
 587     AstNode[] nodes = null;
 588     if (sourceType == null) {
 589       if (isInRange) {
 590         requestor.enterCompilationUnit();
 591       }
 592       //                ImportReference currentPackage = parsedUnit.currentPackage;
 593       ImportReference[] imports = parsedUnit.imports;
 594       //                TypeDeclaration[] types = parsedUnit.types;
 595       ArrayList types = parsedUnit.types;
 596       if (types != null) {
 597         //              length =
 598         //                      (currentPackage == null ? 0 : 1)
 599         //                      + (imports == null ? 0 : imports.length)
 600         //                      + (types == null ? 0 : types.length);
 601         //              nodes = new AstNode[length];
 602         length = (imports == null ? 0 : imports.length) + types.size();
 603         nodes = new AstNode[length];
 604         int index = 0;
 605         //              if (currentPackage != null) {
 606         //                      nodes[index++] = currentPackage;
 607         //              }
 608         if (imports != null) {
 609           for (int i = 0, max = imports.length; i < max; i++) {
 610             nodes[index++] = imports[i];
 611           }
 612         }
 613
 614         for (int i = 0, max = types.size(); i < max; i++) {
 615           nodes[index++] = (AstNode) types.get(i);
 616         }
 617       }
 618     } else {
 619       //                TypeDeclaration[] types = parsedUnit.types;
 620       ArrayList types = parsedUnit.types;
 621       if (types != null) {
 622         length = types.size();
 623         nodes = new AstNode[length];
 624         for (int i = 0, max = types.size(); i < max; i++) {
 625           nodes[i] = (AstNode) types.get(i);
 626         }
 627       }
 628     }
 629
 630     // notify the nodes in the syntactical order
 631     if (nodes != null && length > 0) {
 632       quickSort(nodes, 0, length - 1);
 633       for (int i = 0; i < length; i++) {
 634         AstNode node = nodes[i];
 635                                 if (node instanceof ImportReference) {
 636                                         ImportReference importRef = (ImportReference)node;
 637 //                                      if (node == parsedUnit.currentPackage) {
 638 //                                              notifySourceElementRequestor(importRef, true);
 639 //                                      } else {
 640                                                 notifySourceElementRequestor(importRef, false);
 641 //                                      }
 642                         } //else { instanceof TypeDeclaration
 643         if (node instanceof TypeDeclaration) {
 644           notifySourceElementRequestor((TypeDeclaration) node, sourceType == null);
 645           //                            notifySourceElementRequestor((CompilationUnitDeclaration)node,
 646           // sourceType == null);
 647         }
 648         // jsurfer - INSERT start
 649         if (node instanceof AbstractMethodDeclaration) {
 650           notifySourceElementRequestor((AbstractMethodDeclaration) node);
 651         }
 652         //              jsurfer - INSERT end
 653       }
 654     }
 655
 656     if (sourceType == null) {
 657       if (isInRange) {
 658         requestor.exitCompilationUnit(parsedUnit.sourceEnd);
 659       }
 660     }
 661   }
 662
 663   //private void notifyAllUnknownReferences() {
 664   //    for (int i = 0, max = this.unknownRefsCounter; i < max; i++) {
 665   //            NameReference nameRef = this.unknownRefs[i];
 666   //            if ((nameRef.bits & BindingIds.VARIABLE) != 0) {
 667   //                    if ((nameRef.bits & BindingIds.TYPE) == 0) {
 668   //                            // variable but not type
 669   //                            if (nameRef instanceof SingleNameReference) {
 670   //                                    // local var or field
 671   //                                    requestor.acceptUnknownReference(((SingleNameReference) nameRef).token,
 672   // nameRef.sourceStart);
 673   //                            } else {
 674   //                                    // QualifiedNameReference
 675   //                                    // The last token is a field reference and the previous tokens are a
 676   // type/variable references
 677   //                                    char[][] tokens = ((QualifiedNameReference) nameRef).tokens;
 678   //                                    int tokensLength = tokens.length;
 679   //                                    requestor.acceptFieldReference(tokens[tokensLength - 1], nameRef.sourceEnd
 680   // - tokens[tokensLength - 1].length + 1);
 681   //                                    char[][] typeRef = new char[tokensLength - 1][];
 682   //                                    System.arraycopy(tokens, 0, typeRef, 0, tokensLength - 1);
 683   //                                    requestor.acceptUnknownReference(typeRef, nameRef.sourceStart,
 684   // nameRef.sourceEnd - tokens[tokensLength - 1].length);
 685   //                            }
 686   //                    } else {
 687   //                            // variable or type
 688   //                            if (nameRef instanceof SingleNameReference) {
 689   //                                    requestor.acceptUnknownReference(((SingleNameReference) nameRef).token,
 690   // nameRef.sourceStart);
 691   //                            } else {
 692   //                                    //QualifiedNameReference
 693   //                                    requestor.acceptUnknownReference(((QualifiedNameReference) nameRef).tokens,
 694   // nameRef.sourceStart, nameRef.sourceEnd);
 695   //                            }
 696   //                    }
 697   //            } else if ((nameRef.bits & BindingIds.TYPE) != 0) {
 698   //                    if (nameRef instanceof SingleNameReference) {
 699   //                            requestor.acceptTypeReference(((SingleNameReference) nameRef).token,
 700   // nameRef.sourceStart);
 701   //                    } else {
 702   //                            // it is a QualifiedNameReference
 703   //                            requestor.acceptTypeReference(((QualifiedNameReference) nameRef).tokens,
 704   // nameRef.sourceStart, nameRef.sourceEnd);
 705   //                    }
 706   //            }
 707   //    }
 708   //}
 709   /*
 710    * Update the bodyStart of the corresponding parse node
 711    */
 712   public void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration) {
 713
 714     // range check
 715     boolean isInRange = scanner.initialPosition <= methodDeclaration.declarationSourceStart
 716         && scanner.eofPosition >= methodDeclaration.declarationSourceEnd;
 717
 718     if (methodDeclaration.isClinit()) {
 719       this.visitIfNeeded(methodDeclaration);
 720       return;
 721     }
 722
 723     if (methodDeclaration.isDefaultConstructor()) {
 724       if (reportReferenceInfo) {
 725         ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) methodDeclaration;
 726         ExplicitConstructorCall constructorCall = constructorDeclaration.constructorCall;
 727         if (constructorCall != null) {
 728           switch (constructorCall.accessMode) {
 729             case ExplicitConstructorCall.This :
 730               requestor.acceptConstructorReference(typeNames[nestedTypeIndex - 1], constructorCall.arguments == null
 731                   ? 0
 732                   : constructorCall.arguments.length, constructorCall.sourceStart);
 733               break;
 734             case ExplicitConstructorCall.Super :
 735             case ExplicitConstructorCall.ImplicitSuper :
 736               requestor.acceptConstructorReference(superTypeNames[nestedTypeIndex - 1], constructorCall.arguments == null
 737                   ? 0
 738                   : constructorCall.arguments.length, constructorCall.sourceStart);
 739               break;
 740           }
 741         }
 742       }
 743       return;
 744     }
 745     char[][] argumentTypes = null;
 746     char[][] argumentNames = null;
 747     Argument[] arguments = methodDeclaration.arguments;
 748     if (arguments != null) {
 749       int argumentLength = arguments.length;
 750       argumentTypes = new char[argumentLength][];
 751       argumentNames = new char[argumentLength][];
 752       for (int i = 0; i < argumentLength; i++) {
 753         argumentTypes[i] = returnTypeName(arguments[i].type);
 754         argumentNames[i] = arguments[i].name;
 755       }
 756     }
 757     char[][] thrownExceptionTypes = null;
 758     TypeReference[] thrownExceptions = methodDeclaration.thrownExceptions;
 759     if (thrownExceptions != null) {
 760       int thrownExceptionLength = thrownExceptions.length;
 761       thrownExceptionTypes = new char[thrownExceptionLength][];
 762       for (int i = 0; i < thrownExceptionLength; i++) {
 763         thrownExceptionTypes[i] = CharOperation.concatWith(thrownExceptions[i].getTypeName(), '.');
 764       }
 765     }
 766     // by default no selector end position
 767     int selectorSourceEnd = -1;
 768     if (methodDeclaration.isConstructor()) {
 769       //                if (methodDeclaration instanceof SourceConstructorDeclaration) {
 770       //                        selectorSourceEnd =
 771       //                                ((SourceConstructorDeclaration) methodDeclaration).selectorSourceEnd;
 772       //                }
 773       if (isInRange) {
 774         requestor.enterConstructor(methodDeclaration.declarationSourceStart, methodDeclaration.modifiers,
 775             methodDeclaration.selector, methodDeclaration.sourceStart, selectorSourceEnd, argumentTypes, argumentNames,
 776             thrownExceptionTypes);
 777       }
 778       if (reportReferenceInfo) {
 779         ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) methodDeclaration;
 780         ExplicitConstructorCall constructorCall = constructorDeclaration.constructorCall;
 781         if (constructorCall != null) {
 782           switch (constructorCall.accessMode) {
 783             case ExplicitConstructorCall.This :
 784               requestor.acceptConstructorReference(typeNames[nestedTypeIndex - 1], constructorCall.arguments == null
 785                   ? 0
 786                   : constructorCall.arguments.length, constructorCall.sourceStart);
 787               break;
 788             case ExplicitConstructorCall.Super :
 789             case ExplicitConstructorCall.ImplicitSuper :
 790               requestor.acceptConstructorReference(superTypeNames[nestedTypeIndex - 1], constructorCall.arguments == null
 791                   ? 0
 792                   : constructorCall.arguments.length, constructorCall.sourceStart);
 793               break;
 794           }
 795         }
 796       }
 797       this.visitIfNeeded(methodDeclaration);
 798       if (isInRange) {
 799         requestor.exitConstructor(methodDeclaration.declarationSourceEnd);
 800       }
 801       return;
 802     }
 803     //  if (methodDeclaration instanceof SourceMethodDeclaration) {
 804     //          selectorSourceEnd =
 805     //                  ((SourceMethodDeclaration) methodDeclaration).selectorSourceEnd;
 806     //  }
 807     if (isInRange) {
 808       int modifiers = methodDeclaration.modifiers;
 809       //                boolean deprecated = (modifiers & AccDeprecated) != 0; // remember
 810       // deprecation so as to not lose it below
 811       requestor.enterMethod(methodDeclaration.declarationSourceStart, modifiers, // deprecated
 812                                                                                  // ?
 813                                                                                  // (modifiers
 814                                                                                  // &
 815                                                                                  // AccJustFlag)
 816                                                                                  // |
 817                                                                                  // AccDeprecated
 818                                                                                  // :
 819                                                                                  // modifiers
 820                                                                                  // &
 821                                                                                  // AccJustFlag,
 822           returnTypeName(((MethodDeclaration) methodDeclaration).returnType), methodDeclaration.selector,
 823           methodDeclaration.sourceStart, selectorSourceEnd, argumentTypes, argumentNames, thrownExceptionTypes);
 824     }
 825     this.visitIfNeeded(methodDeclaration);
 826
 827     if (isInRange) {
 828       requestor.exitMethod(methodDeclaration.declarationSourceEnd);
 829     }
 830   }
 831   /*
 832    * Update the bodyStart of the corresponding parse node
 833    */
 834   public void notifySourceElementRequestor(FieldDeclaration fieldDeclaration) {
 835
 836     // range check
 837     boolean isInRange = scanner.initialPosition <= fieldDeclaration.declarationSourceStart
 838         && scanner.eofPosition >= fieldDeclaration.declarationSourceEnd;
 839
 840     if (fieldDeclaration.isField()) {
 841       int fieldEndPosition = fieldDeclaration.declarationSourceEnd;
 842       //                if (fieldDeclaration instanceof SourceFieldDeclaration) {
 843       //                        fieldEndPosition = ((SourceFieldDeclaration)
 844       // fieldDeclaration).fieldEndPosition;
 845       //                        if (fieldEndPosition == 0) {
 846       //                                // use the declaration source end by default
 847       //                                fieldEndPosition = fieldDeclaration.declarationSourceEnd;
 848       //                        }
 849       //                }
 850       if (isInRange) {
 851         int modifiers = fieldDeclaration.modifiers;
 852         boolean deprecated = (modifiers & AccDeprecated) != 0; // remember
 853                                                                // deprecation so
 854                                                                // as to not lose
 855                                                                // it below
 856         requestor.enterField(fieldDeclaration.declarationSourceStart, deprecated
 857             ? (modifiers & AccJustFlag) | AccDeprecated
 858             : modifiers & AccJustFlag, returnTypeName(fieldDeclaration.type), fieldDeclaration.name, fieldDeclaration.sourceStart,
 859             fieldDeclaration.sourceEnd);
 860       }
 861       //                this.visitIfNeeded(fieldDeclaration);
 862       if (isInRange) {
 863         //                      requestor.exitField(
 864         //                              // filter out initializations that are not a constant (simple check)
 865         //                              (fieldDeclaration.initialization == null
 866         //                                              || fieldDeclaration.initialization instanceof ArrayInitializer
 867         //                                              || fieldDeclaration.initialization instanceof AllocationExpression
 868         //                                              || fieldDeclaration.initialization instanceof
 869         // ArrayAllocationExpression
 870         //                                              || fieldDeclaration.initialization instanceof Assignment
 871         //                                              || fieldDeclaration.initialization instanceof ClassLiteralAccess
 872         //                                              || fieldDeclaration.initialization instanceof MessageSend
 873         //                                              || fieldDeclaration.initialization instanceof ArrayReference
 874         //                                              || fieldDeclaration.initialization instanceof ThisReference) ?
 875         //                                      -1 :
 876         //                                      fieldDeclaration.initialization.sourceStart,
 877         //                              fieldEndPosition,
 878         //                              fieldDeclaration.declarationSourceEnd);
 879         requestor.exitField(
 880         // filter out initializations that are not a constant (simple check)
 881             -1, fieldEndPosition, fieldDeclaration.declarationSourceEnd);
 882       }
 883
 884     } else {
 885       //                if (isInRange){
 886       //                        requestor.enterInitializer(
 887       //                                fieldDeclaration.declarationSourceStart,
 888       //                                fieldDeclaration.modifiers);
 889       //                }
 890       //                this.visitIfNeeded((Initializer)fieldDeclaration);
 891       //                if (isInRange){
 892       //                        requestor.exitInitializer(fieldDeclaration.declarationSourceEnd);
 893       //                }
 894     }
 895   }
 896   public void notifySourceElementRequestor(
 897         ImportReference importReference,
 898         boolean isPackage) {
 899 //      if (isPackage) {
 900 //              requestor.acceptPackage(
 901 //                      importReference.declarationSourceStart,
 902 //                      importReference.declarationSourceEnd,
 903 //                      CharOperation.concatWith(importReference.getImportName(), '.'));
 904 //      } else {
 905                 requestor.acceptImport(
 906                         importReference.declarationSourceStart,
 907                         importReference.declarationSourceEnd,
 908                         importReference.getIncludeName(), //CharOperation.concatWith(importReference.getImportName(), '.'),
 909                         importReference.onDemand);
 910 //      }
 911   }
 912   public void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence) {
 913     //// public void notifySourceElementRequestor(AstNode typeDeclaration,
 914     // boolean notifyTypePresence) {
 915
 916     // range check
 917     boolean isInRange = scanner.initialPosition <= typeDeclaration.declarationSourceStart
 918         && scanner.eofPosition >= typeDeclaration.declarationSourceEnd;
 919
 920     FieldDeclaration[] fields = typeDeclaration.fields;
 921     AbstractMethodDeclaration[] methods = typeDeclaration.methods;
 922     MemberTypeDeclaration[] memberTypes = typeDeclaration.memberTypes;
 923     int fieldCount = fields == null ? 0 : fields.length;
 924     int methodCount = methods == null ? 0 : methods.length;
 925     int memberTypeCount = memberTypes == null ? 0 : memberTypes.length;
 926     int fieldIndex = 0;
 927     int methodIndex = 0;
 928     int memberTypeIndex = 0;
 929     boolean isInterface = typeDeclaration.isInterface();
 930
 931     if (notifyTypePresence) {
 932       char[][] interfaceNames = null;
 933       int superInterfacesLength = 0;
 934       TypeReference[] superInterfaces = typeDeclaration.superInterfaces;
 935       if (superInterfaces != null) {
 936         superInterfacesLength = superInterfaces.length;
 937         interfaceNames = new char[superInterfacesLength][];
 938       } else {
 939         if (typeDeclaration instanceof AnonymousLocalTypeDeclaration) {
 940           // see PR 3442
 941           QualifiedAllocationExpression alloc = ((AnonymousLocalTypeDeclaration) typeDeclaration).allocation;
 942           if (alloc != null && alloc.type != null) {
 943             superInterfaces = new TypeReference[]{((AnonymousLocalTypeDeclaration) typeDeclaration).allocation.type};
 944             superInterfacesLength = 1;
 945             interfaceNames = new char[1][];
 946           }
 947         }
 948       }
 949       if (superInterfaces != null) {
 950         for (int i = 0; i < superInterfacesLength; i++) {
 951           interfaceNames[i] = CharOperation.concatWith(superInterfaces[i].getTypeName(), '.');
 952         }
 953       }
 954       if (isInterface) {
 955         if (isInRange) {
 956           int modifiers = typeDeclaration.modifiers;
 957           boolean deprecated = false; //(modifiers & AccDeprecated) != 0; //
 958                                       // remember deprecation so as to not lose
 959                                       // it below
 960           requestor.enterInterface(typeDeclaration.declarationSourceStart, modifiers, //deprecated
 961                                                                                       // ?
 962                                                                                       // (modifiers
 963                                                                                       // &
 964                                                                                       // AccJustFlag)
 965                                                                                       // |
 966                                                                                       // AccDeprecated
 967                                                                                       // :
 968                                                                                       // modifiers
 969                                                                                       // &
 970                                                                                       // AccJustFlag,
 971               typeDeclaration.name, typeDeclaration.sourceStart, typeDeclaration.sourceEnd, interfaceNames);
 972         }
 973         if (nestedTypeIndex == typeNames.length) {
 974           // need a resize
 975           System.arraycopy(typeNames, 0, (typeNames = new char[nestedTypeIndex * 2][]), 0, nestedTypeIndex);
 976           System.arraycopy(superTypeNames, 0, (superTypeNames = new char[nestedTypeIndex * 2][]), 0, nestedTypeIndex);
 977         }
 978         typeNames[nestedTypeIndex] = typeDeclaration.name;
 979         superTypeNames[nestedTypeIndex++] = JAVA_LANG_OBJECT;
 980       } else {
 981         TypeReference superclass = typeDeclaration.superclass;
 982         if (superclass == null) {
 983           if (isInRange) {
 984             requestor.enterClass(typeDeclaration.declarationSourceStart, typeDeclaration.modifiers, typeDeclaration.name,
 985                 typeDeclaration.sourceStart, typeDeclaration.sourceEnd, null, interfaceNames);
 986           }
 987         } else {
 988           if (isInRange) {
 989             requestor.enterClass(typeDeclaration.declarationSourceStart, typeDeclaration.modifiers, typeDeclaration.name,
 990                 typeDeclaration.sourceStart, typeDeclaration.sourceEnd, CharOperation.concatWith(superclass.getTypeName(), '.'),
 991                 interfaceNames);
 992           }
 993         }
 994         if (nestedTypeIndex == typeNames.length) {
 995           // need a resize
 996           System.arraycopy(typeNames, 0, (typeNames = new char[nestedTypeIndex * 2][]), 0, nestedTypeIndex);
 997           System.arraycopy(superTypeNames, 0, (superTypeNames = new char[nestedTypeIndex * 2][]), 0, nestedTypeIndex);
 998         }
 999         typeNames[nestedTypeIndex] = typeDeclaration.name;
1000         superTypeNames[nestedTypeIndex++] = superclass == null ? JAVA_LANG_OBJECT : CharOperation.concatWith(superclass
1001             .getTypeName(), '.');
1002       }
1003     }
1004     while ((fieldIndex < fieldCount) || (memberTypeIndex < memberTypeCount) || (methodIndex < methodCount)) {
1005       FieldDeclaration nextFieldDeclaration = null;
1006       AbstractMethodDeclaration nextMethodDeclaration = null;
1007       TypeDeclaration nextMemberDeclaration = null;
1008
1009       int position = Integer.MAX_VALUE;
1010       int nextDeclarationType = -1;
1011       if (fieldIndex < fieldCount) {
1012         nextFieldDeclaration = fields[fieldIndex];
1013         if (nextFieldDeclaration.declarationSourceStart < position) {
1014           position = nextFieldDeclaration.declarationSourceStart;
1015           nextDeclarationType = 0; // FIELD
1016         }
1017       }
1018       if (methodIndex < methodCount) {
1019         nextMethodDeclaration = methods[methodIndex];
1020         if (nextMethodDeclaration.declarationSourceStart < position) {
1021           position = nextMethodDeclaration.declarationSourceStart;
1022           nextDeclarationType = 1; // METHOD
1023         }
1024       }
1025       if (memberTypeIndex < memberTypeCount) {
1026         nextMemberDeclaration = memberTypes[memberTypeIndex];
1027         if (nextMemberDeclaration.declarationSourceStart < position) {
1028           position = nextMemberDeclaration.declarationSourceStart;
1029           nextDeclarationType = 2; // MEMBER
1030         }
1031       }
1032       switch (nextDeclarationType) {
1033         case 0 :
1034           fieldIndex++;
1035           notifySourceElementRequestor(nextFieldDeclaration);
1036           break;
1037         case 1 :
1038           methodIndex++;
1039           notifySourceElementRequestor(nextMethodDeclaration);
1040           break;
1041         case 2 :
1042           memberTypeIndex++;
1043           notifySourceElementRequestor(nextMemberDeclaration, true);
1044       }
1045     }
1046     if (notifyTypePresence) {
1047       if (isInRange) {
1048         if (isInterface) {
1049           requestor.exitInterface(typeDeclaration.declarationSourceEnd);
1050         } else {
1051           requestor.exitClass(typeDeclaration.declarationSourceEnd);
1052         }
1053       }
1054       nestedTypeIndex--;
1055     }
1056   }
1057   public void parseCompilationUnit(ICompilationUnit unit, int start, int end) {
1058     //  boolean needReferenceInfo) {
1059
1060     //  reportReferenceInfo = needReferenceInfo;
1061     //  boolean old = diet;
1062     //  if (needReferenceInfo) {
1063     //          unknownRefs = new NameReference[10];
1064     //          unknownRefsCounter = 0;
1065     //  }
1066
1067     try {
1068       //                diet = true;
1069       CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, 10); //this.options.maxProblemsPerUnit);
1070       CompilationUnitDeclaration parsedUnit = parse(unit, compilationUnitResult, start, end);
1071       //                if (scanner.recordLineSeparator) {
1072       //                        requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
1073       //                }
1074       //                if (this.localDeclarationVisitor != null || needReferenceInfo){
1075       //                        diet = false;
1076       //                        this.getMethodBodies(parsedUnit);
1077       //                }
1078       //                this.scanner.resetTo(start, end);
1079       //                notifySourceElementRequestor(parsedUnit);
1080     } catch (AbortCompilation e) {
1081     } finally {
1082       //                diet = old;
1083     }
1084   }
1085   public CompilationUnitDeclaration parseCompilationUnit(ICompilationUnit unit, boolean fullParse) {
1086
1087     //          boolean old = diet;
1088     //          if (fullParse) {
1089     //                  unknownRefs = new NameReference[10];
1090     //                  unknownRefsCounter = 0;
1091     //          }
1092
1093     try {
1094       //                        diet = true;
1095       this.reportReferenceInfo = fullParse;
1096       CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, this.options.maxProblemsPerUnit);
1097       CompilationUnitDeclaration parsedUnit = parse(unit, compilationUnitResult, false);
1098       if (scanner.recordLineSeparator) {
1099         requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
1100       }
1101       int initialStart = this.scanner.initialPosition;
1102       int initialEnd = this.scanner.eofPosition;
1103       //                        if (this.localDeclarationVisitor != null || fullParse){
1104       //                                diet = false;
1105       //                                this.getMethodBodies(parsedUnit);
1106       //                        }
1107       this.scanner.resetTo(initialStart, initialEnd);
1108       notifySourceElementRequestor(parsedUnit);
1109       return parsedUnit;
1110     } catch (AbortCompilation e) {
1111       // ignore this exception
1112     } finally {
1113       //                        diet = old;
1114     }
1115     return null;
1116   }
1117
1118   //public void parseTypeMemberDeclarations(
1119   //    ISourceType sourceType,
1120   //    ICompilationUnit sourceUnit,
1121   //    int start,
1122   //    int end,
1123   //    boolean needReferenceInfo) {
1124   //    boolean old = diet;
1125   //    if (needReferenceInfo) {
1126   //            unknownRefs = new NameReference[10];
1127   //            unknownRefsCounter = 0;
1128   //    }
1129   //
1130   //    try {
1131   //            diet = !needReferenceInfo;
1132   //            reportReferenceInfo = needReferenceInfo;
1133   //            CompilationResult compilationUnitResult =
1134   //                    new CompilationResult(sourceUnit, 0, 0, this.options.maxProblemsPerUnit);
1135   //            CompilationUnitDeclaration unit =
1136   //                    SourceTypeConverter.buildCompilationUnit(
1137   //                            new ISourceType[]{sourceType},
1138   //                            false, // no need for field and methods
1139   //                            false, // no need for member types
1140   //                            false, // no need for field initialization
1141   //                            problemReporter(),
1142   //                            compilationUnitResult);
1143   //            if ((unit == null) || (unit.types == null) || (unit.types.length != 1))
1144   //                    return;
1145   //            this.sourceType = sourceType;
1146   //            try {
1147   //                    /* automaton initialization */
1148   //                    initialize();
1149   //                    goForClassBodyDeclarations();
1150   //                    /* scanner initialization */
1151   //                    scanner.setSource(sourceUnit.getContents());
1152   //                    scanner.resetTo(start, end);
1153   //                    /* unit creation */
1154   //                    referenceContext = compilationUnit = unit;
1155   //                    /* initialize the astStacl */
1156   //                    // the compilationUnitDeclaration should contain exactly one type
1157   //                    pushOnAstStack(unit.types[0]);
1158   //                    /* run automaton */
1159   //                    parse();
1160   //                    notifySourceElementRequestor(unit);
1161   //            } finally {
1162   //                    unit = compilationUnit;
1163   //                    compilationUnit = null; // reset parser
1164   //            }
1165   //    } catch (AbortCompilation e) {
1166   //    } finally {
1167   //            if (scanner.recordLineSeparator) {
1168   //                    requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
1169   //            }
1170   //            diet = old;
1171   //    }
1172   //}
1173   //
1174   //public void parseTypeMemberDeclarations(
1175   //    char[] contents,
1176   //    int start,
1177   //    int end) {
1178   //
1179   //    boolean old = diet;
1180   //
1181   //    try {
1182   //            diet = true;
1183   //
1184   //            /* automaton initialization */
1185   //            initialize();
1186   //            goForClassBodyDeclarations();
1187   //            /* scanner initialization */
1188   //            scanner.setSource(contents);
1189   //            scanner.recordLineSeparator = false;
1190   //            scanner.taskTags = null;
1191   //            scanner.taskPriorities = null;
1192   //            scanner.resetTo(start, end);
1193   //
1194   //            /* unit creation */
1195   //            referenceContext = null;
1196   //
1197   //            /* initialize the astStacl */
1198   //            // the compilationUnitDeclaration should contain exactly one type
1199   //            /* run automaton */
1200   //            parse();
1201   //            notifySourceElementRequestor((CompilationUnitDeclaration)null);
1202   //    } catch (AbortCompilation e) {
1203   //    } finally {
1204   //            diet = old;
1205   //    }
1206   //}
1207   /**
1208    * Sort the given ast nodes by their positions.
1209    */
1210   private static void quickSort(AstNode[] sortedCollection, int left, int right) {
1211     int original_left = left;
1212     int original_right = right;
1213     AstNode mid = sortedCollection[(left + right) / 2];
1214     do {
1215       while (sortedCollection[left].sourceStart < mid.sourceStart) {
1216         left++;
1217       }
1218       while (mid.sourceStart < sortedCollection[right].sourceStart) {
1219         right--;
1220       }
1221       if (left <= right) {
1222         AstNode tmp = sortedCollection[left];
1223         sortedCollection[left] = sortedCollection[right];
1224         sortedCollection[right] = tmp;
1225         left++;
1226         right--;
1227       }
1228     } while (left <= right);
1229     if (original_left < right) {
1230       quickSort(sortedCollection, original_left, right);
1231     }
1232     if (left < original_right) {
1233       quickSort(sortedCollection, left, original_right);
1234     }
1235   }
1236   /*
1237    * Answer a char array representation of the type name formatted like: - type
1238    * name + dimensions Example: "A[][]".toCharArray()
1239    * "java.lang.String".toCharArray()
1240    */
1241   private char[] returnTypeName(TypeReference type) {
1242     if (type == null)
1243       return null;
1244     int dimension = type.dimensions();
1245     if (dimension != 0) {
1246       char[] dimensionsArray = new char[dimension * 2];
1247       for (int i = 0; i < dimension; i++) {
1248         dimensionsArray[i * 2] = '[';
1249         dimensionsArray[(i * 2) + 1] = ']';
1250       }
1251       return CharOperation.concat(CharOperation.concatWith(type.getTypeName(), '.'), dimensionsArray);
1252     }
1253     return CharOperation.concatWith(type.getTypeName(), '.');
1254   }
1255
1256   public void addUnknownRef(NameReference nameRef) {
1257     if (this.unknownRefs.length == this.unknownRefsCounter) {
1258       // resize
1259       System.arraycopy(this.unknownRefs, 0, (this.unknownRefs = new NameReference[this.unknownRefsCounter * 2]), 0,
1260           this.unknownRefsCounter);
1261     }
1262     this.unknownRefs[this.unknownRefsCounter++] = nameRef;
1263   }
1264
1265   private void visitIfNeeded(AbstractMethodDeclaration method) {
1266     if (this.localDeclarationVisitor != null && (method.bits & AstNode.HasLocalTypeMASK) != 0) {
1267       if (method.statements != null) {
1268         int statementsLength = method.statements.length;
1269         for (int i = 0; i < statementsLength; i++)
1270           method.statements[i].traverse(this.localDeclarationVisitor, method.scope);
1271       }
1272     }
1273   }
1274
1275   //private void visitIfNeeded(FieldDeclaration field) {
1276   //    if (this.localDeclarationVisitor != null
1277   //            && (field.bits & AstNode.HasLocalTypeMASK) != 0) {
1278   //                    if (field.initialization != null) {
1279   //                            field.initialization.traverse(this.localDeclarationVisitor, null);
1280   //                    }
1281   //    }
1282   //}
1283   //
1284   //private void visitIfNeeded(Initializer initializer) {
1285   //    if (this.localDeclarationVisitor != null
1286   //            && (initializer.bits & AstNode.HasLocalTypeMASK) != 0) {
1287   //                    if (initializer.block != null) {
1288   //                            initializer.block.traverse(this.localDeclarationVisitor, null);
1289   //                    }
1290   //    }
1291   //}
1292   //
1293   //protected void reportSyntaxError(int act, int currentKind, int
1294   // stateStackTop) {
1295   //    if (compilationUnit == null) return;
1296   //    super.reportSyntaxError(act, currentKind,stateStackTop);
1297   //}
1298   protected CompilationUnitDeclaration endParse(int act) {
1299     //  if (sourceType != null) {
1300     //          if (sourceType.isInterface()) {
1301     //                  consumeInterfaceDeclaration();
1302     //          } else {
1303     //                  consumeClassDeclaration();
1304     //          }
1305     //  }
1306     if (compilationUnit != null) {
1307       CompilationUnitDeclaration result = super.endParse(act);
1308       return result;
1309     } else {
1310       return null;
1311     }
1312   }
1313 }