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

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