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.phpdt.internal.core.BasicCompilationUnit;
  11 import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration;
  12 import net.sourceforge.phpeclipse.internal.compiler.ast.ConstructorDeclaration;
  13 import net.sourceforge.phpeclipse.internal.compiler.ast.FieldDeclaration;
  14 import net.sourceforge.phpeclipse.internal.compiler.ast.Initializer;
  15 import net.sourceforge.phpeclipse.internal.compiler.ast.MethodDeclaration;
  16 import net.sourceforge.phpeclipse.internal.compiler.ast.TypeDeclaration;
  17
  18 import org.eclipse.core.resources.IMarker;
  19 import org.eclipse.core.resources.IResource;
  20 import org.eclipse.core.runtime.CoreException;
  21
  22 /**
  23  * @author jsurfer
  24  *
  25  *
  26  */
  27 public class UnitParser extends Parser {
  28
  29   public UnitParser(ProblemReporter problemReporter) { //, boolean optimizeStringLiterals, boolean assertMode) {
  30     super();
  31     nestedMethod = new int[30];
  32     this.problemReporter = problemReporter;
  33     //          this.optimizeStringLiterals = optimizeStringLiterals;
  34     //          this.assertMode = assertMode;
  35     //          this.initializeScanner();
  36     astLengthStack = new int[50];
  37     //          expressionLengthStack = new int[30];
  38     //          intStack = new int[50];
  39     //          identifierStack = new char[30][];
  40     //          identifierLengthStack = new int[30];
  41     //          nestedMethod = new int[30];
  42     //          realBlockStack = new int[30];
  43     //          identifierPositionStack = new long[30];
  44     //          variablesCounter = new int[30];
  45   }
  46
  47   public void goForConstructorBody() {
  48     //tells the scanner to go for compilation unit parsing
  49
  50     firstToken = TokenNameEQUAL_EQUAL;
  51     scanner.recordLineSeparator = false;
  52   }
  53   public void goForExpression() {
  54     //tells the scanner to go for an expression parsing
  55
  56     firstToken = TokenNameREMAINDER;
  57     scanner.recordLineSeparator = false;
  58   }
  59   public void goForCompilationUnit() {
  60     //tells the scanner to go for compilation unit parsing
  61
  62     firstToken = TokenNamePLUS_PLUS;
  63     scanner.linePtr = -1;
  64     scanner.foundTaskCount = 0;
  65     scanner.recordLineSeparator = true;
  66     //          scanner.currentLine= null;
  67   }
  68   public void goForInitializer() {
  69     //tells the scanner to go for initializer parsing
  70
  71     firstToken = TokenNameRIGHT_SHIFT;
  72     scanner.recordLineSeparator = false;
  73   }
  74   public void goForMethodBody() {
  75     //tells the scanner to go for method body parsing
  76
  77     firstToken = TokenNameMINUS_MINUS;
  78     scanner.recordLineSeparator = false;
  79   }
  80   public void initialize() {
  81     super.initialize();
  82     //positionning the parser for a new compilation unit
  83     //avoiding stack reallocation and all that....
  84     //          astPtr = -1;
  85     //          astLengthPtr = -1;
  86     //          expressionPtr = -1;
  87     //          expressionLengthPtr = -1;
  88     //          identifierPtr = -1;
  89     //          identifierLengthPtr     = -1;
  90     //          intPtr = -1;
  91     //          nestedMethod[nestedType = 0] = 0; // need to reset for further reuse
  92     //          variablesCounter[nestedType] = 0;
  93     //          dimensions = 0 ;
  94     //          realBlockPtr = -1;
  95     //          endStatementPosition = 0;
  96
  97     //remove objects from stack too, while the same parser/compiler couple is
  98     //re-used between two compilations ....
  99
 100     //          int astLength = astStack.length;
 101     //          if (noAstNodes.length < astLength){
 102     //                  noAstNodes = new AstNode[astLength];
 103     //                  //System.out.println("Resized AST stacks : "+ astLength);
 104     //
 105     //          }
 106     //          System.arraycopy(noAstNodes, 0, astStack, 0, astLength);
 107     //
 108     //          int expressionLength = expressionStack.length;
 109     //          if (noExpressions.length < expressionLength){
 110     //                  noExpressions = new Expression[expressionLength];
 111     //                  //System.out.println("Resized EXPR stacks : "+ expressionLength);
 112     //          }
 113     //          System.arraycopy(noExpressions, 0, expressionStack, 0, expressionLength);
 114
 115     // reset scanner state
 116     scanner.commentPtr = -1;
 117     scanner.foundTaskCount = 0;
 118     scanner.eofPosition = Integer.MAX_VALUE;
 119
 120     //          resetModifiers();
 121     //
 122     //          // recovery
 123     //          lastCheckPoint = -1;
 124     //          currentElement = null;
 125     //          restartRecovery = false;
 126     //          hasReportedError = false;
 127     //          recoveredStaticInitializerStart = 0;
 128     //          lastIgnoredToken = -1;
 129     //          lastErrorEndPosition = -1;
 130     //          listLength = 0;
 131   }
 132
 133   // A P I
 134
 135   public CompilationUnitDeclaration parse(ICompilationUnit sourceUnit, CompilationResult compilationResult) {
 136     // parses a compilation unit and manages error handling (even bugs....)
 137
 138     CompilationUnitDeclaration unit;
 139     try {
 140       /* automaton initialization */
 141       initialize();
 142       goForCompilationUnit();
 143
 144       /* scanner initialization */
 145       scanner.setSource(sourceUnit.getContents());
 146
 147       /* unit creation */
 148       referenceContext =
 149         compilationUnit = new CompilationUnitDeclaration(problemReporter, compilationResult, scanner.source.length);
 150       // TODO TypeDeclaration test
 151       //      TypeDeclaration typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
 152       //      typeDecl.sourceStart = 0;
 153       //      typeDecl.sourceEnd = 10;
 154       //      typeDecl.name = new char[]{'t', 'e','s','t'};
 155       //      this.compilationUnit.types = new ArrayList();
 156       //      this.compilationUnit.types.add(typeDecl);
 157       /* run automaton */
 158       super.parse();
 159 //      //              TODO jsurfer start
 160 //      if (sourceUnit instanceof BasicCompilationUnit) {
 161 //        storeProblemsFor(((BasicCompilationUnit)sourceUnit).getResource(), compilationResult.getAllProblems());
 162 //      }
 163 //      // jsurfer end
 164     } catch (CoreException e) {
 165       e.printStackTrace();
 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();
 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     } catch (CoreException e) {
 269       // TODO Auto-generated catch block
 270       e.printStackTrace();
 271     } finally {
 272       nestedMethod[nestedType]--;
 273     }
 274
 275     if (lastAct == ERROR_ACTION) {
 276       initialize();
 277       return;
 278     }
 279
 280     //statements
 281     //  cd.explicitDeclarations = realBlockStack[realBlockPtr--];
 282     //  int length;
 283     //  if ((length = astLengthStack[astLengthPtr--]) != 0) {
 284     //          astPtr -= length;
 285     //          if (astStack[astPtr + 1] instanceof ExplicitConstructorCall)
 286     //                  //avoid a isSomeThing that would only be used here BUT what is faster between two alternatives ?
 287     //                  {
 288     //                  System.arraycopy(
 289     //                          astStack,
 290     //                          astPtr + 2,
 291     //                          cd.statements = new Statement[length - 1],
 292     //                          0,
 293     //                          length - 1);
 294     //                  cd.constructorCall = (ExplicitConstructorCall) astStack[astPtr + 1];
 295     //          } else { //need to add explicitly the super();
 296     //                  System.arraycopy(
 297     //                          astStack,
 298     //                          astPtr + 1,
 299     //                          cd.statements = new Statement[length],
 300     //                          0,
 301     //                          length);
 302     //                  cd.constructorCall = SuperReference.implicitSuperConstructorCall();
 303     //          }
 304     //  } else {
 305     //          cd.constructorCall = SuperReference.implicitSuperConstructorCall();
 306     //  }
 307     //
 308     //  if (cd.constructorCall.sourceEnd == 0) {
 309     //          cd.constructorCall.sourceEnd = cd.sourceEnd;
 310     //          cd.constructorCall.sourceStart = cd.sourceStart;
 311     //  }
 312   }
 313   // A P I
 314
 315   public void parse(FieldDeclaration field, TypeDeclaration type, CompilationUnitDeclaration unit, char[] initializationSource) {
 316     //only parse the initializationSource of the given field
 317
 318     //convert bugs into parse error
 319
 320     initialize();
 321     goForExpression();
 322     nestedMethod[nestedType]++;
 323
 324     referenceContext = type;
 325     compilationUnit = unit;
 326
 327     scanner.setSource(initializationSource);
 328     scanner.resetTo(0, initializationSource.length - 1);
 329     try {
 330       parse();
 331     } catch (AbortCompilation ex) {
 332       lastAct = ERROR_ACTION;
 333     } catch (CoreException e) {
 334       // TODO Auto-generated catch block
 335       e.printStackTrace();
 336     } finally {
 337       nestedMethod[nestedType]--;
 338     }
 339
 340     //  if (lastAct == ERROR_ACTION) {
 341     //          return;
 342     //  }
 343     //
 344     //  field.initialization = expressionStack[expressionPtr];
 345     //
 346     //  // mark field with local type if one was found during parsing
 347     //  if ((type.bits & AstNode.HasLocalTypeMASK) != 0) {
 348     //          field.bits |= AstNode.HasLocalTypeMASK;
 349     //  }
 350   }
 351   // A P I
 352
 353   public void parse(Initializer ini, TypeDeclaration type, CompilationUnitDeclaration unit) {
 354     //only parse the method body of md
 355     //fill out method statements
 356
 357     //convert bugs into parse error
 358
 359     initialize();
 360     goForInitializer();
 361     nestedMethod[nestedType]++;
 362
 363     referenceContext = type;
 364     compilationUnit = unit;
 365
 366     scanner.resetTo(ini.sourceStart, ini.sourceEnd); // just on the beginning {
 367     try {
 368       parse();
 369     } catch (AbortCompilation ex) {
 370       lastAct = ERROR_ACTION;
 371     } catch (CoreException e) {
 372       // TODO Auto-generated catch block
 373       e.printStackTrace();
 374     } finally {
 375       nestedMethod[nestedType]--;
 376     }
 377
 378     //  if (lastAct == ERROR_ACTION) {
 379     //          return;
 380     //  }
 381     //
 382     //  ini.block = ((Initializer) astStack[astPtr]).block;
 383     //
 384     //  // mark initializer with local type if one was found during parsing
 385     //  if ((type.bits & AstNode.HasLocalTypeMASK) != 0) {
 386     //          ini.bits |= AstNode.HasLocalTypeMASK;
 387     //  }
 388   }
 389   // A P I
 390
 391   public void parse(MethodDeclaration md, CompilationUnitDeclaration unit) {
 392     //only parse the method body of md
 393     //fill out method statements
 394
 395     //convert bugs into parse error
 396
 397     if (md.isAbstract())
 398       return;
 399     //  if (md.isNative())
 400     //          return;
 401     //  if ((md.modifiers & AccSemicolonBody) != 0)
 402     //          return;
 403
 404     initialize();
 405     goForMethodBody();
 406     nestedMethod[nestedType]++;
 407
 408     referenceContext = md;
 409     compilationUnit = unit;
 410
 411     scanner.resetTo(md.sourceEnd + 1, md.declarationSourceEnd);
 412     // reset the scanner to parser from { down to }
 413     try {
 414       parse();
 415     } catch (AbortCompilation ex) {
 416       lastAct = ERROR_ACTION;
 417     } catch (CoreException e) {
 418       // TODO Auto-generated catch block
 419       e.printStackTrace();
 420     } finally {
 421       nestedMethod[nestedType]--;
 422     }
 423
 424     //  if (lastAct == ERROR_ACTION) {
 425     //          return;
 426     //  }
 427     //
 428     //  //refill statements
 429     //  md.explicitDeclarations = realBlockStack[realBlockPtr--];
 430     //  int length;
 431     //  if ((length = astLengthStack[astLengthPtr--]) != 0)
 432     //          System.arraycopy(
 433     //                  astStack,
 434     //                  (astPtr -= length) + 1,
 435     //                  md.statements = new Statement[length],
 436     //                  0,
 437     //                  length);
 438   }
 439
 440   // A P I
 441
 442   public CompilationUnitDeclaration parse(ICompilationUnit sourceUnit, CompilationResult compilationResult, int start, int end) {
 443     // parses a compilation unit and manages error handling (even bugs....)
 444
 445     CompilationUnitDeclaration unit;
 446     try {
 447       /* automaton initialization */
 448       initialize();
 449       goForCompilationUnit();
 450
 451       /* scanner initialization */
 452       scanner.setSource(sourceUnit.getContents());
 453       scanner.resetTo(start, end);
 454       /* unit creation */
 455       referenceContext =
 456         compilationUnit = new CompilationUnitDeclaration(problemReporter, compilationResult, scanner.source.length);
 457       /* run automaton */
 458       parse();
 459     } catch (CoreException e) {
 460       // TODO Auto-generated catch block
 461       e.printStackTrace();
 462     } catch (SyntaxError syntaxError) {
 463       //
 464     } finally {
 465       unit = compilationUnit;
 466       compilationUnit = null; // reset parser
 467     }
 468     return unit;
 469   }
 470
 471   public CompilationUnitDeclaration dietParse(ICompilationUnit sourceUnit, CompilationResult compilationResult) {
 472
 473     CompilationUnitDeclaration parsedUnit;
 474     boolean old = diet;
 475     try {
 476       diet = true;
 477       parsedUnit = parse(sourceUnit, compilationResult);
 478     } finally {
 479       diet = old;
 480     }
 481     return parsedUnit;
 482   }
 483 }