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