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