net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/parser/UnitParser.java

   1 package net.sourceforge.phpdt.internal.compiler.parser;
   2
   3 import java.util.Stack;
   4
   5 import net.sourceforge.phpdt.core.IJavaModelMarker;
   6 import net.sourceforge.phpdt.core.compiler.IProblem;
   7 import net.sourceforge.phpdt.internal.compiler.CompilationResult;
   8 import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit;
   9 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
  10 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
  11 import net.sourceforge.phpdt.internal.compiler.util.Util;
  12 import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration;
  13 import net.sourceforge.phpeclipse.internal.compiler.ast.ConstructorDeclaration;
  14 import net.sourceforge.phpeclipse.internal.compiler.ast.FieldDeclaration;
  15 import net.sourceforge.phpeclipse.internal.compiler.ast.Initializer;
  16 import net.sourceforge.phpeclipse.internal.compiler.ast.MethodDeclaration;
  17 import net.sourceforge.phpeclipse.internal.compiler.ast.TypeDeclaration;
  18
  19 import org.eclipse.core.resources.IMarker;
  20 import org.eclipse.core.resources.IResource;
  21 import org.eclipse.core.runtime.CoreException;
  22
  23 /**
  24  * @author jsurfer
  25  *
  26  *
  27  */
  28 public class UnitParser extends Parser {
  29
  30   public UnitParser(ProblemReporter problemReporter) { //, boolean optimizeStringLiterals, boolean assertMode) {
  31     super();
  32     nestedMethod = new int[30];
  33     this.problemReporter = problemReporter;
  34     //          this.optimizeStringLiterals = optimizeStringLiterals;
  35     //          this.assertMode = assertMode;
  36     //          this.initializeScanner();
  37     astLengthStack = new int[50];
  38     //          expressionLengthStack = new int[30];
  39     //          intStack = new int[50];
  40     //          identifierStack = new char[30][];
  41     //          identifierLengthStack = new int[30];
  42     //          nestedMethod = new int[30];
  43     //          realBlockStack = new int[30];
  44     //          identifierPositionStack = new long[30];
  45     //          variablesCounter = new int[30];
  46   }
  47
  48   public void goForConstructorBody() {
  49     //tells the scanner to go for compilation unit parsing
  50
  51     firstToken = TokenNameEQUAL_EQUAL;
  52     scanner.recordLineSeparator = false;
  53   }
  54   public void goForExpression() {
  55     //tells the scanner to go for an expression parsing
  56
  57     firstToken = TokenNameREMAINDER;
  58     scanner.recordLineSeparator = false;
  59   }
  60   public void goForCompilationUnit() {
  61     //tells the scanner to go for compilation unit parsing
  62
  63     firstToken = TokenNamePLUS_PLUS;
  64     scanner.linePtr = -1;
  65     scanner.foundTaskCount = 0;
  66     scanner.recordLineSeparator = true;
  67     //          scanner.currentLine= null;
  68   }
  69   public void goForInitializer() {
  70     //tells the scanner to go for initializer parsing
  71
  72     firstToken = TokenNameRIGHT_SHIFT;
  73     scanner.recordLineSeparator = false;
  74   }
  75   public void goForMethodBody() {
  76     //tells the scanner to go for method body parsing
  77
  78     firstToken = TokenNameMINUS_MINUS;
  79     scanner.recordLineSeparator = false;
  80   }
  81   public void initialize(boolean phpMode) {
  82     super.initialize(phpMode);
  83     //positionning the parser for a new compilation unit
  84     //avoiding stack reallocation and all that....
  85     //          astPtr = -1;
  86     //          astLengthPtr = -1;
  87     //          expressionPtr = -1;
  88     //          expressionLengthPtr = -1;
  89     //          identifierPtr = -1;
  90     //          identifierLengthPtr     = -1;
  91     //          intPtr = -1;
  92     //          nestedMethod[nestedType = 0] = 0; // need to reset for further reuse
  93     //          variablesCounter[nestedType] = 0;
  94     //          dimensions = 0 ;
  95     //          realBlockPtr = -1;
  96     //          endStatementPosition = 0;
  97
  98     //remove objects from stack too, while the same parser/compiler couple is
  99     //re-used between two compilations ....
 100
 101     //          int astLength = astStack.length;
 102     //          if (noAstNodes.length < astLength){
 103     //                  noAstNodes = new AstNode[astLength];
 104     //                  //System.out.println("Resized AST stacks : "+ astLength);
 105     //
 106     //          }
 107     //          System.arraycopy(noAstNodes, 0, astStack, 0, astLength);
 108     //
 109     //          int expressionLength = expressionStack.length;
 110     //          if (noExpressions.length < expressionLength){
 111     //                  noExpressions = new Expression[expressionLength];
 112     //                  //System.out.println("Resized EXPR stacks : "+ expressionLength);
 113     //          }
 114     //          System.arraycopy(noExpressions, 0, expressionStack, 0, expressionLength);
 115
 116     // reset scanner state
 117     scanner.commentPtr = -1;
 118     scanner.foundTaskCount = 0;
 119     scanner.eofPosition = Integer.MAX_VALUE;
 120
 121     //          resetModifiers();
 122     //
 123     //          // recovery
 124     //          lastCheckPoint = -1;
 125     //          currentElement = null;
 126     //          restartRecovery = false;
 127     //          hasReportedError = false;
 128     //          recoveredStaticInitializerStart = 0;
 129     //          lastIgnoredToken = -1;
 130     //          lastErrorEndPosition = -1;
 131     //          listLength = 0;
 132   }
 133
 134   // A P I
 135
 136   public CompilationUnitDeclaration parse(ICompilationUnit sourceUnit, CompilationResult compilationResult, boolean phpMode) {
 137     // parses a compilation unit and manages error handling (even bugs....)
 138
 139     CompilationUnitDeclaration unit;
 140     try {
 141       /* automaton initialization */
 142       initialize(phpMode);
 143       goForCompilationUnit();
 144
 145       /* scanner initialization */
 146       scanner.setSource(sourceUnit.getContents());
 147
 148       /* unit creation */
 149       referenceContext =
 150         compilationUnit = new CompilationUnitDeclaration(problemReporter, compilationResult, scanner.source.length);
 151       // TODO TypeDeclaration test
 152       //      TypeDeclaration typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
 153       //      typeDecl.sourceStart = 0;
 154       //      typeDecl.sourceEnd = 10;
 155       //      typeDecl.name = new char[]{'t', 'e','s','t'};
 156       //      this.compilationUnit.types = new ArrayList();
 157       //      this.compilationUnit.types.add(typeDecl);
 158       /* run automaton */
 159       super.parse();
 160 //      //              TODO jsurfer start
 161 //      if (sourceUnit instanceof BasicCompilationUnit) {
 162 //        storeProblemsFor(((BasicCompilationUnit)sourceUnit).getResource(), compilationResult.getAllProblems());
 163 //      }
 164 //      // jsurfer end
 165
 166     } finally {
 167       unit = compilationUnit;
 168       compilationUnit = null; // reset parser
 169     }
 170     return unit;
 171   }
 172   /**
 173                  * Creates a marker from each problem and adds it to the resource.
 174                  * The marker is as follows:
 175                  *   - its type is T_PROBLEM
 176                  *   - its plugin ID is the JavaBuilder's plugin ID
 177                  *       - its message is the problem's message
 178                  *       - its priority reflects the severity of the problem
 179                  *       - its range is the problem's range
 180                  *       - it has an extra attribute "ID" which holds the problem's id
 181                  */
 182   protected void storeProblemsFor(IResource resource, IProblem[] problems) throws CoreException {
 183     if (resource == null || problems == null || problems.length == 0)
 184       return;
 185
 186     for (int i = 0, l = problems.length; i < l; i++) {
 187       IProblem problem = problems[i];
 188       int id = problem.getID();
 189       if (id != IProblem.Task) {
 190         IMarker marker = resource.createMarker(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER);
 191         marker.setAttributes(
 192           new String[] {
 193             IMarker.MESSAGE,
 194             IMarker.SEVERITY,
 195             IJavaModelMarker.ID,
 196             IMarker.CHAR_START,
 197             IMarker.CHAR_END,
 198             IMarker.LINE_NUMBER,
 199             IJavaModelMarker.ARGUMENTS },
 200           new Object[] {
 201             problem.getMessage(),
 202             new Integer(problem.isError() ? IMarker.SEVERITY_ERROR : IMarker.SEVERITY_WARNING),
 203             new Integer(id),
 204             new Integer(problem.getSourceStart()),
 205             new Integer(problem.getSourceEnd() + 1),
 206             new Integer(problem.getSourceLineNumber()),
 207             net.sourceforge.phpdt.internal.core.Util.getProblemArgumentsForMarker(problem.getArguments())});
 208       }
 209
 210     }
 211   }
 212   protected CompilationUnitDeclaration endParse(int act) {
 213
 214     this.lastAct = act;
 215
 216     if (currentElement != null) {
 217       currentElement.topElement().updateParseTree();
 218       if (VERBOSE_RECOVERY) {
 219         System.out.print(Util.bind("parser.syntaxRecovery")); //$NON-NLS-1$
 220         System.out.println("--------------------------"); //$NON-NLS-1$
 221         System.out.println(compilationUnit);
 222         System.out.println("----------------------------------"); //$NON-NLS-1$
 223       }
 224     } else {
 225       if (diet & VERBOSE_RECOVERY) {
 226         System.out.print(Util.bind("parser.regularParse")); //$NON-NLS-1$
 227         System.out.println("--------------------------"); //$NON-NLS-1$
 228         System.out.println(compilationUnit);
 229         System.out.println("----------------------------------"); //$NON-NLS-1$
 230       }
 231     }
 232     if (scanner.recordLineSeparator) {
 233       compilationUnit.compilationResult.lineSeparatorPositions = scanner.getLineEnds();
 234     }
 235     if (scanner.taskTags != null) {
 236       for (int i = 0; i < scanner.foundTaskCount; i++) {
 237         problemReporter().task(
 238           new String(scanner.foundTaskTags[i]),
 239           new String(scanner.foundTaskMessages[i]),
 240           scanner.foundTaskPriorities[i] == null ? null : new String(scanner.foundTaskPriorities[i]),
 241           scanner.foundTaskPositions[i][0],
 242           scanner.foundTaskPositions[i][1]);
 243       }
 244     }
 245     return compilationUnit;
 246   }
 247
 248   // A P I
 249
 250   public void parse(ConstructorDeclaration cd, CompilationUnitDeclaration unit) {
 251     //only parse the method body of cd
 252     //fill out its statements
 253
 254     //convert bugs into parse error
 255
 256     initialize(false);
 257     goForConstructorBody();
 258     nestedMethod[nestedType]++;
 259
 260     referenceContext = cd;
 261     compilationUnit = unit;
 262
 263     scanner.resetTo(cd.sourceEnd + 1, cd.declarationSourceEnd);
 264     try {
 265       parse();
 266     } catch (AbortCompilation ex) {
 267       lastAct = ERROR_ACTION;
 268
 269     } finally {
 270       nestedMethod[nestedType]--;
 271     }
 272
 273     if (lastAct == ERROR_ACTION) {
 274       initialize(false);
 275       return;
 276     }
 277
 278     //statements
 279     //  cd.explicitDeclarations = realBlockStack[realBlockPtr--];
 280     //  int length;
 281     //  if ((length = astLengthStack[astLengthPtr--]) != 0) {
 282     //          astPtr -= length;
 283     //          if (astStack[astPtr + 1] instanceof ExplicitConstructorCall)
 284     //                  //avoid a isSomeThing that would only be used here BUT what is faster between two alternatives ?
 285     //                  {
 286     //                  System.arraycopy(
 287     //                          astStack,
 288     //                          astPtr + 2,
 289     //                          cd.statements = new Statement[length - 1],
 290     //                          0,
 291     //                          length - 1);
 292     //                  cd.constructorCall = (ExplicitConstructorCall) astStack[astPtr + 1];
 293     //          } else { //need to add explicitly the super();
 294     //                  System.arraycopy(
 295     //                          astStack,
 296     //                          astPtr + 1,
 297     //                          cd.statements = new Statement[length],
 298     //                          0,
 299     //                          length);
 300     //                  cd.constructorCall = SuperReference.implicitSuperConstructorCall();
 301     //          }
 302     //  } else {
 303     //          cd.constructorCall = SuperReference.implicitSuperConstructorCall();
 304     //  }
 305     //
 306     //  if (cd.constructorCall.sourceEnd == 0) {
 307     //          cd.constructorCall.sourceEnd = cd.sourceEnd;
 308     //          cd.constructorCall.sourceStart = cd.sourceStart;
 309     //  }
 310   }
 311   // A P I
 312
 313   public void parse(FieldDeclaration field, TypeDeclaration type, CompilationUnitDeclaration unit, char[] initializationSource) {
 314     //only parse the initializationSource of the given field
 315
 316     //convert bugs into parse error
 317
 318     initialize(false);
 319     goForExpression();
 320     nestedMethod[nestedType]++;
 321
 322     referenceContext = type;
 323     compilationUnit = unit;
 324
 325     scanner.setSource(initializationSource);
 326     scanner.resetTo(0, initializationSource.length - 1);
 327     try {
 328       parse();
 329     } catch (AbortCompilation ex) {
 330       lastAct = ERROR_ACTION;
 331     } finally {
 332       nestedMethod[nestedType]--;
 333     }
 334
 335     //  if (lastAct == ERROR_ACTION) {
 336     //          return;
 337     //  }
 338     //
 339     //  field.initialization = expressionStack[expressionPtr];
 340     //
 341     //  // mark field with local type if one was found during parsing
 342     //  if ((type.bits & AstNode.HasLocalTypeMASK) != 0) {
 343     //          field.bits |= AstNode.HasLocalTypeMASK;
 344     //  }
 345   }
 346   // A P I
 347
 348   public void parse(Initializer ini, TypeDeclaration type, CompilationUnitDeclaration unit) {
 349     //only parse the method body of md
 350     //fill out method statements
 351
 352     //convert bugs into parse error
 353
 354     initialize(false);
 355     goForInitializer();
 356     nestedMethod[nestedType]++;
 357
 358     referenceContext = type;
 359     compilationUnit = unit;
 360
 361     scanner.resetTo(ini.sourceStart, ini.sourceEnd); // just on the beginning {
 362     try {
 363       parse();
 364     } catch (AbortCompilation ex) {
 365       lastAct = ERROR_ACTION;
 366     } finally {
 367       nestedMethod[nestedType]--;
 368     }
 369
 370     //  if (lastAct == ERROR_ACTION) {
 371     //          return;
 372     //  }
 373     //
 374     //  ini.block = ((Initializer) astStack[astPtr]).block;
 375     //
 376     //  // mark initializer with local type if one was found during parsing
 377     //  if ((type.bits & AstNode.HasLocalTypeMASK) != 0) {
 378     //          ini.bits |= AstNode.HasLocalTypeMASK;
 379     //  }
 380   }
 381   // A P I
 382
 383   public void parse(MethodDeclaration md, CompilationUnitDeclaration unit) {
 384 //  TODO jsurfer - make the parse process work on methods ?
 385     return;
 386
 387 //    //only parse the method body of md
 388 //    //fill out method statements
 389 //
 390 //    //convert bugs into parse error
 391 //
 392 //    if (md.isAbstract())
 393 //      return;
 394 //    //        if (md.isNative())
 395 //    //                return;
 396 //    //        if ((md.modifiers & AccSemicolonBody) != 0)
 397 //    //                return;
 398 //
 399 //    initialize(false);
 400 //    goForMethodBody();
 401 //    nestedMethod[nestedType]++;
 402 //
 403 //    referenceContext = md;
 404 //    compilationUnit = unit;
 405 //
 406 //    scanner.resetTo(md.sourceEnd + 1, md.declarationSourceEnd);
 407 //
 408 //    // reset the scanner to parser from { down to }
 409 //    try {
 410 //      parse();
 411 //    } catch (AbortCompilation ex) {
 412 //      lastAct = ERROR_ACTION;
 413 //    } finally {
 414 //      nestedMethod[nestedType]--;
 415 //    }
 416 //
 417 //    //        if (lastAct == ERROR_ACTION) {
 418 //    //                return;
 419 //    //        }
 420 //    //
 421 //    //        //refill statements
 422 //    //        md.explicitDeclarations = realBlockStack[realBlockPtr--];
 423 //    //        int length;
 424 //    //        if ((length = astLengthStack[astLengthPtr--]) != 0)
 425 //    //                System.arraycopy(
 426 //    //                        astStack,
 427 //    //                        (astPtr -= length) + 1,
 428 //    //                        md.statements = new Statement[length],
 429 //    //                        0,
 430 //    //                        length);
 431   }
 432
 433   // A P I
 434
 435   public CompilationUnitDeclaration parse(ICompilationUnit sourceUnit, CompilationResult compilationResult, int start, int end) {
 436     // parses a compilation unit and manages error handling (even bugs....)
 437
 438     CompilationUnitDeclaration unit;
 439     try {
 440       /* automaton initialization */
 441       initialize(false);
 442       goForCompilationUnit();
 443
 444       /* scanner initialization */
 445       scanner.setSource(sourceUnit.getContents());
 446       scanner.resetTo(start, end);
 447       /* unit creation */
 448       referenceContext =
 449         compilationUnit = new CompilationUnitDeclaration(problemReporter, compilationResult, scanner.source.length);
 450       /* run automaton */
 451       parse();
 452     } catch (SyntaxError syntaxError) {
 453       //
 454     } finally {
 455       unit = compilationUnit;
 456       compilationUnit = null; // reset parser
 457     }
 458     return unit;
 459   }
 460
 461   public CompilationUnitDeclaration dietParse(ICompilationUnit sourceUnit, CompilationResult compilationResult) {
 462         return dietParse(sourceUnit, compilationResult, false);
 463   }
 464   public CompilationUnitDeclaration dietParse(ICompilationUnit sourceUnit, CompilationResult compilationResult, boolean phpMode) {
 465
 466     CompilationUnitDeclaration parsedUnit;
 467     boolean old = diet;
 468     try {
 469       diet = true;
 470       parsedUnit = parse(sourceUnit, compilationResult, phpMode);
 471     } finally {
 472       diet = old;
 473     }
 474     return parsedUnit;
 475   }
 476 }