1 /***********************************************************************************************************************************
2 * Copyright (c) 2002 www.phpeclipse.de All rights reserved. This program and the accompanying material are made available under the
3 * 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
6 * Contributors: www.phpeclipse.de
7 **********************************************************************************************************************************/
8 package net.sourceforge.phpdt.internal.compiler.parser;
10 import java.util.ArrayList;
11 import java.util.HashMap;
12 import java.util.HashSet;
14 import net.sourceforge.phpdt.core.compiler.CharOperation;
15 import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
16 import net.sourceforge.phpdt.core.compiler.InvalidInputException;
17 import net.sourceforge.phpdt.internal.compiler.ast.AND_AND_Expression;
18 import net.sourceforge.phpdt.internal.compiler.ast.ASTNode;
19 import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration;
20 import net.sourceforge.phpdt.internal.compiler.ast.BinaryExpression;
21 import net.sourceforge.phpdt.internal.compiler.ast.Block;
22 import net.sourceforge.phpdt.internal.compiler.ast.BreakStatement;
23 import net.sourceforge.phpdt.internal.compiler.ast.CompilationUnitDeclaration;
24 import net.sourceforge.phpdt.internal.compiler.ast.ConditionalExpression;
25 import net.sourceforge.phpdt.internal.compiler.ast.ContinueStatement;
26 import net.sourceforge.phpdt.internal.compiler.ast.EqualExpression;
27 import net.sourceforge.phpdt.internal.compiler.ast.Expression;
28 import net.sourceforge.phpdt.internal.compiler.ast.FieldDeclaration;
29 import net.sourceforge.phpdt.internal.compiler.ast.FieldReference;
30 import net.sourceforge.phpdt.internal.compiler.ast.IfStatement;
31 import net.sourceforge.phpdt.internal.compiler.ast.ImportReference;
32 import net.sourceforge.phpdt.internal.compiler.ast.InstanceOfExpression;
33 import net.sourceforge.phpdt.internal.compiler.ast.MethodDeclaration;
34 import net.sourceforge.phpdt.internal.compiler.ast.OR_OR_Expression;
35 import net.sourceforge.phpdt.internal.compiler.ast.OperatorIds;
36 import net.sourceforge.phpdt.internal.compiler.ast.ReturnStatement;
37 import net.sourceforge.phpdt.internal.compiler.ast.SingleTypeReference;
38 import net.sourceforge.phpdt.internal.compiler.ast.Statement;
39 import net.sourceforge.phpdt.internal.compiler.ast.StringLiteral;
40 import net.sourceforge.phpdt.internal.compiler.ast.StringLiteralDQ;
41 import net.sourceforge.phpdt.internal.compiler.ast.StringLiteralSQ;
42 import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
43 import net.sourceforge.phpdt.internal.compiler.ast.TypeReference;
44 import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
45 import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext;
46 import net.sourceforge.phpdt.internal.compiler.lookup.CompilerModifiers;
47 import net.sourceforge.phpdt.internal.compiler.lookup.TypeConstants;
48 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
49 import net.sourceforge.phpdt.internal.compiler.problem.ProblemSeverities;
50 import net.sourceforge.phpdt.internal.compiler.util.Util;
51 import net.sourceforge.phpdt.internal.ui.util.PHPFileUtil;
52 import net.sourceforge.phpeclipse.builder.IdentifierIndexManager;
53 import net.sourceforge.phpeclipse.ui.overlaypages.ProjectPrefUtil;
55 import org.eclipse.core.resources.IFile;
56 import org.eclipse.core.resources.IProject;
57 import org.eclipse.core.resources.IResource;
58 import org.eclipse.core.runtime.IPath;
60 public class Parser implements ITerminalSymbols, CompilerModifiers, ParserBasicInformation {
61 protected final static int StackIncrement = 255;
63 protected int stateStackTop;
65 // protected int[] stack = new int[StackIncrement];
67 public int firstToken; // handle for multiple parsing goals
69 public int lastAct; // handle for multiple parsing goals
71 // protected RecoveredElement currentElement;
73 public static boolean VERBOSE_RECOVERY = false;
75 protected boolean diet = false; // tells the scanner to jump over some
78 * the PHP token scanner
80 public Scanner scanner;
84 protected int modifiers;
86 protected int modifiersSourceStart;
88 protected Parser(ProblemReporter problemReporter) {
89 this.problemReporter = problemReporter;
90 this.options = problemReporter.options;
91 this.token = TokenNameEOF;
92 this.initializeScanner();
95 public void setFileToParse(IFile fileToParse) {
96 this.token = TokenNameEOF;
97 this.initializeScanner();
101 * ClassDeclaration Constructor.
105 * Description of Parameter
108 public Parser(IFile fileToParse) {
109 // if (keywordMap == null) {
110 // keywordMap = new HashMap();
111 // for (int i = 0; i < PHP_KEYWORS.length; i++) {
112 // keywordMap.put(PHP_KEYWORS[i], new Integer(PHP_KEYWORD_TOKEN[i]));
115 // this.currentPHPString = 0;
116 // PHPParserSuperclass.fileToParse = fileToParse;
117 // this.phpList = null;
118 this.includesList = null;
120 this.token = TokenNameEOF;
122 // this.rowCount = 1;
123 // this.columnCount = 0;
124 // this.phpEnd = false;
126 this.initializeScanner();
129 public void initializeScanner() {
130 this.scanner = new Scanner(false /* comment */, false /* whitespace */, this.options
131 .getSeverity(CompilerOptions.NonExternalizedString) != ProblemSeverities.Ignore /* nls */, false, false,
132 this.options.taskTags/* taskTags */, this.options.taskPriorites/* taskPriorities */, true/* isTaskCaseSensitive */);
136 * Create marker for the parse error
138 // private void setMarker(String message, int charStart, int charEnd, int
140 // setMarker(fileToParse, message, charStart, charEnd, errorLevel);
143 * This method will throw the SyntaxError. It will add the good lines and
144 * columns to the Error
148 * @throws SyntaxError
151 private void throwSyntaxError(String error) {
152 int problemStartPosition = scanner.getCurrentTokenStartPosition();
153 int problemEndPosition = scanner.getCurrentTokenEndPosition() + 1;
154 if (scanner.source.length <= problemEndPosition && problemEndPosition > 0) {
155 problemEndPosition = scanner.source.length - 1;
156 if (problemStartPosition > 0 && problemStartPosition >= problemEndPosition && problemEndPosition > 0) {
157 problemStartPosition = problemEndPosition - 1;
160 throwSyntaxError(error, problemStartPosition, problemEndPosition);
164 * This method will throw the SyntaxError. It will add the good lines and
165 * columns to the Error
169 * @throws SyntaxError
172 // private void throwSyntaxError(String error, int startRow) {
173 // throw new SyntaxError(startRow, 0, " ", error);
175 private void throwSyntaxError(String error, int problemStartPosition, int problemEndPosition) {
176 if (referenceContext != null) {
177 problemReporter.phpParsingError(new String[] { error }, problemStartPosition, problemEndPosition, referenceContext,
178 compilationUnit.compilationResult);
180 throw new SyntaxError(1, 0, " ", error);
183 private void reportSyntaxError(String error) {
184 int problemStartPosition = scanner.getCurrentTokenStartPosition();
185 int problemEndPosition = scanner.getCurrentTokenEndPosition();
186 reportSyntaxError(error, problemStartPosition, problemEndPosition + 1);
189 private void reportSyntaxError(String error, int problemStartPosition, int problemEndPosition) {
190 if (referenceContext != null) {
191 problemReporter.phpParsingError(new String[] { error }, problemStartPosition, problemEndPosition, referenceContext,
192 compilationUnit.compilationResult);
196 // private void reportSyntaxWarning(String error, int problemStartPosition,
197 // int problemEndPosition) {
198 // if (referenceContext != null) {
199 // problemReporter.phpParsingWarning(new String[] { error },
200 // problemStartPosition, problemEndPosition, referenceContext,
201 // compilationUnit.compilationResult);
206 * gets the next token from input
208 private void getNextToken() {
210 token = scanner.getNextToken();
212 int currentEndPosition = scanner.getCurrentTokenEndPosition();
213 int currentStartPosition = scanner.getCurrentTokenStartPosition();
214 System.out.print(currentStartPosition + "," + currentEndPosition + ": ");
215 System.out.println(scanner.toStringAction(token));
217 } catch (InvalidInputException e) {
218 token = TokenNameERROR;
219 String detailedMessage = e.getMessage();
221 if (detailedMessage == Scanner.UNTERMINATED_STRING) {
222 throwSyntaxError("Unterminated string.");
223 } else if (detailedMessage == Scanner.UNTERMINATED_COMMENT) {
224 throwSyntaxError("Unterminated commment.");
230 public void init(String s) {
232 this.token = TokenNameEOF;
233 this.includesList = new ArrayList();
235 // this.rowCount = 1;
236 // this.columnCount = 0;
237 // this.phpEnd = false;
238 // this.phpMode = false;
239 /* scanner initialization */
240 scanner.setSource(s.toCharArray());
241 scanner.setPHPMode(false);
245 protected void initialize(boolean phpMode) {
246 initialize(phpMode, null);
249 protected void initialize(boolean phpMode, IdentifierIndexManager indexManager) {
250 compilationUnit = null;
251 referenceContext = null;
252 this.includesList = new ArrayList();
253 // this.indexManager = indexManager;
255 this.token = TokenNameEOF;
257 // this.rowCount = 1;
258 // this.columnCount = 0;
259 // this.phpEnd = false;
260 // this.phpMode = phpMode;
261 scanner.setPHPMode(phpMode);
266 * Parses a string with php tags i.e. '<body> <?php phpinfo() ?>
269 public void parse(String s) {
274 * Parses a string with php tags i.e. '<body> <?php phpinfo() ?>
277 public void parse(String s, HashMap variables) {
278 fMethodVariables = variables;
279 fStackUnassigned = new ArrayList();
285 * Parses a string with php tags i.e. '<body> <?php phpinfo() ?>
288 protected void parse() {
289 if (scanner.compilationUnit != null) {
290 IResource resource = scanner.compilationUnit.getResource();
291 if (resource != null && resource instanceof IFile) {
292 // set the package name
293 consumePackageDeclarationName((IFile) resource);
299 if (token != TokenNameEOF && token != TokenNameERROR) {
302 if (token != TokenNameEOF) {
303 if (token == TokenNameERROR) {
304 throwSyntaxError("Scanner error (Found unknown token: " + scanner.toStringAction(token) + ")");
306 if (token == TokenNameRPAREN) {
307 throwSyntaxError("Too many closing ')'; end-of-file not reached.");
309 if (token == TokenNameRBRACE) {
310 throwSyntaxError("Too many closing '}'; end-of-file not reached.");
312 if (token == TokenNameRBRACKET) {
313 throwSyntaxError("Too many closing ']'; end-of-file not reached.");
315 if (token == TokenNameLPAREN) {
316 throwSyntaxError("Read character '('; end-of-file not reached.");
318 if (token == TokenNameLBRACE) {
319 throwSyntaxError("Read character '{'; end-of-file not reached.");
321 if (token == TokenNameLBRACKET) {
322 throwSyntaxError("Read character '['; end-of-file not reached.");
324 throwSyntaxError("End-of-file not reached.");
327 } catch (SyntaxError syntaxError) {
328 // syntaxError.printStackTrace();
337 * Parses a string with php tags i.e. '<body> <?php phpinfo() ?>
340 public void parseFunction(String s, HashMap variables) {
342 scanner.phpMode = true;
343 parseFunction(variables);
347 * Parses a string with php tags i.e. '<body> <?php phpinfo() ?>
350 protected void parseFunction(HashMap variables) {
352 boolean hasModifiers = member_modifiers();
353 if (token == TokenNamefunction) {
355 checkAndSetModifiers(AccPublic);
357 this.fMethodVariables = variables;
359 MethodDeclaration methodDecl = new MethodDeclaration(null);
360 methodDecl.declarationSourceStart = scanner.getCurrentTokenStartPosition();
361 methodDecl.modifiers = this.modifiers;
362 methodDecl.type = MethodDeclaration.METHOD_DEFINITION;
365 functionDefinition(methodDecl);
366 } catch (SyntaxError sytaxErr1) {
369 int sourceEnd = methodDecl.sourceEnd;
370 if (sourceEnd <= 0 || methodDecl.declarationSourceStart > sourceEnd) {
371 sourceEnd = methodDecl.declarationSourceStart + 1;
373 methodDecl.sourceEnd = sourceEnd;
374 methodDecl.declarationSourceEnd = sourceEnd;
379 protected CompilationUnitDeclaration endParse(int act) {
383 // if (currentElement != null) {
384 // currentElement.topElement().updateParseTree();
385 // if (VERBOSE_RECOVERY) {
386 // System.out.print(Util.bind("parser.syntaxRecovery")); //$NON-NLS-1$
387 // System.out.println("--------------------------"); //$NON-NLS-1$
388 // System.out.println(compilationUnit);
389 // System.out.println("----------------------------------"); //$NON-NLS-1$
392 if (diet & VERBOSE_RECOVERY) {
393 System.out.print(Util.bind("parser.regularParse")); //$NON-NLS-1$
394 System.out.println("--------------------------"); //$NON-NLS-1$
395 System.out.println(compilationUnit);
396 System.out.println("----------------------------------"); //$NON-NLS-1$
399 if (scanner.recordLineSeparator) {
400 compilationUnit.compilationResult.lineSeparatorPositions = scanner.getLineEnds();
402 if (scanner.taskTags != null) {
403 for (int i = 0; i < scanner.foundTaskCount; i++) {
404 problemReporter().task(new String(scanner.foundTaskTags[i]), new String(scanner.foundTaskMessages[i]),
405 scanner.foundTaskPriorities[i] == null ? null : new String(scanner.foundTaskPriorities[i]),
406 scanner.foundTaskPositions[i][0], scanner.foundTaskPositions[i][1]);
409 compilationUnit.imports = new ImportReference[includesList.size()];
410 for (int i = 0; i < includesList.size(); i++) {
411 compilationUnit.imports[i] = (ImportReference) includesList.get(i);
413 return compilationUnit;
416 private Block statementList() {
417 boolean branchStatement = false;
419 int blockStart = scanner.getCurrentTokenStartPosition();
420 ArrayList blockStatements = new ArrayList();
423 statement = statement();
424 blockStatements.add(statement);
425 if (token == TokenNameEOF) {
428 if (branchStatement && statement != null) {
429 // reportSyntaxError("Unreachable code", statement.sourceStart,
430 // statement.sourceEnd);
431 problemReporter.unreachableCode(new String(scanner.getCurrentIdentifierSource()), statement.sourceStart,
432 statement.sourceEnd, referenceContext, compilationUnit.compilationResult);
434 if ((token == TokenNameRBRACE) || (token == TokenNamecase) || (token == TokenNamedefault) || (token == TokenNameelse)
435 || (token == TokenNameelseif) || (token == TokenNameendif) || (token == TokenNameendfor)
436 || (token == TokenNameendforeach) || (token == TokenNameendwhile) || (token == TokenNameendswitch)
437 || (token == TokenNameenddeclare) || (token == TokenNameEOF) || (token == TokenNameERROR)) {
438 return createBlock(blockStart, blockStatements);
440 branchStatement = checkUnreachableStatements(statement);
441 } catch (SyntaxError sytaxErr1) {
442 // if an error occured,
443 // try to find keywords
444 // to parse the rest of the string
445 boolean tokenize = scanner.tokenizeStrings;
447 scanner.tokenizeStrings = true;
450 while (token != TokenNameEOF) {
451 if ((token == TokenNameRBRACE) || (token == TokenNamecase) || (token == TokenNamedefault) || (token == TokenNameelse)
452 || (token == TokenNameelseif) || (token == TokenNameendif) || (token == TokenNameendfor)
453 || (token == TokenNameendforeach) || (token == TokenNameendwhile) || (token == TokenNameendswitch)
454 || (token == TokenNameenddeclare) || (token == TokenNameEOF) || (token == TokenNameERROR)) {
455 return createBlock(blockStart, blockStatements);
457 if (token == TokenNameif || token == TokenNameswitch || token == TokenNamefor || token == TokenNamewhile
458 || token == TokenNamedo || token == TokenNameforeach || token == TokenNamecontinue || token == TokenNamebreak
459 || token == TokenNamereturn || token == TokenNameexit || token == TokenNameecho || token == TokenNameglobal
460 || token == TokenNamestatic || token == TokenNameunset || token == TokenNamefunction || token == TokenNamedeclare
461 || token == TokenNametry || token == TokenNamecatch || token == TokenNamethrow || token == TokenNamefinal
462 || token == TokenNameabstract || token == TokenNameclass || token == TokenNameinterface) {
465 // System.out.println(scanner.toStringAction(token));
467 // System.out.println(scanner.toStringAction(token));
469 if (token == TokenNameEOF) {
473 scanner.tokenizeStrings = tokenize;
483 private boolean checkUnreachableStatements(Statement statement) {
484 if (statement instanceof ReturnStatement || statement instanceof ContinueStatement || statement instanceof BreakStatement) {
486 } else if (statement instanceof IfStatement && ((IfStatement) statement).checkUnreachable) {
494 * @param blockStatements
497 private Block createBlock(int blockStart, ArrayList blockStatements) {
498 int blockEnd = scanner.getCurrentTokenEndPosition();
499 Block b = Block.EmptyWith(blockStart, blockEnd);
500 b.statements = new Statement[blockStatements.size()];
501 blockStatements.toArray(b.statements);
505 private void functionBody(MethodDeclaration methodDecl) {
506 // '{' [statement-list] '}'
507 if (token == TokenNameLBRACE) {
510 methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
511 throwSyntaxError("'{' expected in compound-statement.");
513 if (token != TokenNameRBRACE) {
516 if (token == TokenNameRBRACE) {
517 methodDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
520 methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
521 throwSyntaxError("'}' expected in compound-statement.");
525 private Statement statement() {
526 Statement statement = null;
527 Expression expression;
528 int sourceStart = scanner.getCurrentTokenStartPosition();
530 if (token == TokenNameif) {
531 // T_IF '(' expr ')' statement elseif_list else_single
532 // T_IF '(' expr ')' ':' inner_statement_list new_elseif_list
533 // new_else_single T_ENDIF ';'
535 if (token == TokenNameLPAREN) {
538 throwSyntaxError("'(' expected after 'if' keyword.");
541 if (token == TokenNameRPAREN) {
544 throwSyntaxError("')' expected after 'if' condition.");
546 // create basic IfStatement
547 IfStatement ifStatement = new IfStatement(expression, null, null, sourceStart, -1);
548 if (token == TokenNameCOLON) {
550 ifStatementColon(ifStatement);
552 ifStatement(ifStatement);
555 } else if (token == TokenNameswitch) {
557 if (token == TokenNameLPAREN) {
560 throwSyntaxError("'(' expected after 'switch' keyword.");
563 if (token == TokenNameRPAREN) {
566 throwSyntaxError("')' expected after 'switch' condition.");
570 } else if (token == TokenNamefor) {
572 if (token == TokenNameLPAREN) {
575 throwSyntaxError("'(' expected after 'for' keyword.");
577 if (token == TokenNameSEMICOLON) {
581 if (token == TokenNameSEMICOLON) {
584 throwSyntaxError("';' expected after 'for'.");
587 if (token == TokenNameSEMICOLON) {
591 if (token == TokenNameSEMICOLON) {
594 throwSyntaxError("';' expected after 'for'.");
597 if (token == TokenNameRPAREN) {
601 if (token == TokenNameRPAREN) {
604 throwSyntaxError("')' expected after 'for'.");
609 } else if (token == TokenNamewhile) {
611 if (token == TokenNameLPAREN) {
614 throwSyntaxError("'(' expected after 'while' keyword.");
617 if (token == TokenNameRPAREN) {
620 throwSyntaxError("')' expected after 'while' condition.");
624 } else if (token == TokenNamedo) {
626 if (token == TokenNameLBRACE) {
628 if (token != TokenNameRBRACE) {
631 if (token == TokenNameRBRACE) {
634 throwSyntaxError("'}' expected after 'do' keyword.");
639 if (token == TokenNamewhile) {
641 if (token == TokenNameLPAREN) {
644 throwSyntaxError("'(' expected after 'while' keyword.");
647 if (token == TokenNameRPAREN) {
650 throwSyntaxError("')' expected after 'while' condition.");
653 throwSyntaxError("'while' expected after 'do' keyword.");
655 if (token == TokenNameSEMICOLON) {
658 if (token != TokenNameINLINE_HTML) {
659 throwSyntaxError("';' expected after do-while statement.");
664 } else if (token == TokenNameforeach) {
666 if (token == TokenNameLPAREN) {
669 throwSyntaxError("'(' expected after 'foreach' keyword.");
672 if (token == TokenNameas) {
675 throwSyntaxError("'as' expected after 'foreach' exxpression.");
679 foreach_optional_arg();
680 if (token == TokenNameEQUAL_GREATER) {
682 variable(false, false);
684 if (token == TokenNameRPAREN) {
687 throwSyntaxError("')' expected after 'foreach' expression.");
691 } else if (token == TokenNamebreak) {
694 if (token != TokenNameSEMICOLON) {
697 if (token == TokenNameSEMICOLON) {
698 sourceEnd = scanner.getCurrentTokenEndPosition();
701 if (token != TokenNameINLINE_HTML) {
702 throwSyntaxError("';' expected after 'break'.");
704 sourceEnd = scanner.getCurrentTokenEndPosition();
707 return new BreakStatement(null, sourceStart, sourceEnd);
708 } else if (token == TokenNamecontinue) {
711 if (token != TokenNameSEMICOLON) {
714 if (token == TokenNameSEMICOLON) {
715 sourceEnd = scanner.getCurrentTokenEndPosition();
718 if (token != TokenNameINLINE_HTML) {
719 throwSyntaxError("';' expected after 'continue'.");
721 sourceEnd = scanner.getCurrentTokenEndPosition();
724 return new ContinueStatement(null, sourceStart, sourceEnd);
725 } else if (token == TokenNamereturn) {
728 if (token != TokenNameSEMICOLON) {
731 if (token == TokenNameSEMICOLON) {
732 sourceEnd = scanner.getCurrentTokenEndPosition();
735 if (token != TokenNameINLINE_HTML) {
736 throwSyntaxError("';' expected after 'return'.");
738 sourceEnd = scanner.getCurrentTokenEndPosition();
741 return new ReturnStatement(expression, sourceStart, sourceEnd);
742 } else if (token == TokenNameecho) {
745 if (token == TokenNameSEMICOLON) {
748 if (token != TokenNameINLINE_HTML) {
749 throwSyntaxError("';' expected after 'echo' statement.");
754 } else if (token == TokenNameINLINE_HTML) {
755 if (scanner.phpExpressionTag) {
756 // start of <?= ... ?> block
759 if (token == TokenNameSEMICOLON) {
762 if (token != TokenNameINLINE_HTML) {
763 throwSyntaxError("Missing '?>' for open PHP expression block ('<?=').");
769 // } else if (token == TokenNameprint) {
772 // if (token == TokenNameSEMICOLON) {
775 // if (token != TokenNameStopPHP) {
776 // throwSyntaxError("';' expected after 'print' statement.");
781 } else if (token == TokenNameglobal) {
784 if (token == TokenNameSEMICOLON) {
787 if (token != TokenNameINLINE_HTML) {
788 throwSyntaxError("';' expected after 'global' statement.");
793 } else if (token == TokenNamestatic) {
796 if (token == TokenNameSEMICOLON) {
799 if (token != TokenNameINLINE_HTML) {
800 throwSyntaxError("';' expected after 'static' statement.");
805 } else if (token == TokenNameunset) {
807 if (token == TokenNameLPAREN) {
810 throwSyntaxError("'(' expected after 'unset' statement.");
813 if (token == TokenNameRPAREN) {
816 throwSyntaxError("')' expected after 'unset' statement.");
818 if (token == TokenNameSEMICOLON) {
821 if (token != TokenNameINLINE_HTML) {
822 throwSyntaxError("';' expected after 'unset' statement.");
827 } else if (token == TokenNamefunction) {
828 MethodDeclaration methodDecl = new MethodDeclaration(this.compilationUnit.compilationResult);
829 methodDecl.declarationSourceStart = scanner.getCurrentTokenStartPosition();
830 methodDecl.modifiers = AccDefault;
831 methodDecl.type = MethodDeclaration.FUNCTION_DEFINITION;
834 functionDefinition(methodDecl);
836 sourceEnd = methodDecl.sourceEnd;
837 if (sourceEnd <= 0 || methodDecl.declarationSourceStart > sourceEnd) {
838 sourceEnd = methodDecl.declarationSourceStart + 1;
840 methodDecl.declarationSourceEnd = sourceEnd;
841 methodDecl.sourceEnd = sourceEnd;
844 } else if (token == TokenNamedeclare) {
845 // T_DECLARE '(' declare_list ')' declare_statement
847 if (token != TokenNameLPAREN) {
848 throwSyntaxError("'(' expected in 'declare' statement.");
852 if (token != TokenNameRPAREN) {
853 throwSyntaxError("')' expected in 'declare' statement.");
858 } else if (token == TokenNametry) {
860 if (token != TokenNameLBRACE) {
861 throwSyntaxError("'{' expected in 'try' statement.");
865 if (token != TokenNameRBRACE) {
866 throwSyntaxError("'}' expected in 'try' statement.");
870 } else if (token == TokenNamecatch) {
872 if (token != TokenNameLPAREN) {
873 throwSyntaxError("'(' expected in 'catch' statement.");
876 fully_qualified_class_name();
877 if (token != TokenNameVariable) {
878 throwSyntaxError("Variable expected in 'catch' statement.");
882 if (token != TokenNameRPAREN) {
883 throwSyntaxError("')' expected in 'catch' statement.");
886 if (token != TokenNameLBRACE) {
887 throwSyntaxError("'{' expected in 'catch' statement.");
890 if (token != TokenNameRBRACE) {
892 if (token != TokenNameRBRACE) {
893 throwSyntaxError("'}' expected in 'catch' statement.");
897 additional_catches();
899 } else if (token == TokenNamethrow) {
902 if (token == TokenNameSEMICOLON) {
905 throwSyntaxError("';' expected after 'throw' exxpression.");
908 } else if (token == TokenNamefinal || token == TokenNameabstract || token == TokenNameclass || token == TokenNameinterface) {
910 TypeDeclaration typeDecl = new TypeDeclaration(this.compilationUnit.compilationResult);
911 typeDecl.declarationSourceStart = scanner.getCurrentTokenStartPosition();
912 typeDecl.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
913 typeDecl.name = new char[] { ' ' };
914 // default super class
915 typeDecl.superclass = new SingleTypeReference(TypeConstants.OBJECT, 0);
916 compilationUnit.types.add(typeDecl);
917 pushOnAstStack(typeDecl);
918 unticked_class_declaration_statement(typeDecl);
926 // throwSyntaxError("Unexpected keyword '" + keyword + "'");
927 } else if (token == TokenNameLBRACE) {
929 if (token != TokenNameRBRACE) {
930 statement = statementList();
932 if (token == TokenNameRBRACE) {
936 throwSyntaxError("'}' expected.");
939 if (token != TokenNameSEMICOLON) {
942 if (token == TokenNameSEMICOLON) {
946 if (token == TokenNameRBRACE) {
947 reportSyntaxError("';' expected after expression (Found token: " + scanner.toStringAction(token) + ")");
949 if (token != TokenNameINLINE_HTML && token != TokenNameEOF) {
950 throwSyntaxError("';' expected after expression (Found token: " + scanner.toStringAction(token) + ")");
960 private void declare_statement() {
962 // | ':' inner_statement_list T_ENDDECLARE ';'
964 if (token == TokenNameCOLON) {
966 // TODO: implement inner_statement_list();
968 if (token != TokenNameenddeclare) {
969 throwSyntaxError("'enddeclare' expected in 'declare' statement.");
972 if (token != TokenNameSEMICOLON) {
973 throwSyntaxError("';' expected after 'enddeclare' keyword.");
981 private void declare_list() {
982 // T_STRING '=' static_scalar
983 // | declare_list ',' T_STRING '=' static_scalar
985 if (token != TokenNameIdentifier) {
986 throwSyntaxError("Identifier expected in 'declare' list.");
989 if (token != TokenNameEQUAL) {
990 throwSyntaxError("'=' expected in 'declare' list.");
994 if (token != TokenNameCOMMA) {
1001 private void additional_catches() {
1002 while (token == TokenNamecatch) {
1004 if (token != TokenNameLPAREN) {
1005 throwSyntaxError("'(' expected in 'catch' statement.");
1008 fully_qualified_class_name();
1009 if (token != TokenNameVariable) {
1010 throwSyntaxError("Variable expected in 'catch' statement.");
1014 if (token != TokenNameRPAREN) {
1015 throwSyntaxError("')' expected in 'catch' statement.");
1018 if (token != TokenNameLBRACE) {
1019 throwSyntaxError("'{' expected in 'catch' statement.");
1022 if (token != TokenNameRBRACE) {
1025 if (token != TokenNameRBRACE) {
1026 throwSyntaxError("'}' expected in 'catch' statement.");
1032 private void foreach_variable() {
1035 if (token == TokenNameAND) {
1041 private void foreach_optional_arg() {
1043 // | T_DOUBLE_ARROW foreach_variable
1044 if (token == TokenNameEQUAL_GREATER) {
1050 private void global_var_list() {
1052 // global_var_list ',' global_var
1054 HashSet set = peekVariableSet();
1057 if (token != TokenNameCOMMA) {
1064 private void global_var(HashSet set) {
1068 // | '$' '{' expr '}'
1069 if (token == TokenNameVariable) {
1070 if (fMethodVariables != null) {
1071 VariableInfo info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_GLOBAL_VAR);
1072 fMethodVariables.put(new String(scanner.getCurrentIdentifierSource()), info);
1074 addVariableSet(set);
1076 } else if (token == TokenNameDOLLAR) {
1078 if (token == TokenNameLBRACE) {
1081 if (token != TokenNameRBRACE) {
1082 throwSyntaxError("'}' expected in global variable.");
1091 private void static_var_list() {
1093 // static_var_list ',' T_VARIABLE
1094 // | static_var_list ',' T_VARIABLE '=' static_scalar
1096 // | T_VARIABLE '=' static_scalar,
1097 HashSet set = peekVariableSet();
1099 if (token == TokenNameVariable) {
1100 if (fMethodVariables != null) {
1101 VariableInfo info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_STATIC_VAR);
1102 fMethodVariables.put(new String(scanner.getCurrentIdentifierSource()), info);
1104 addVariableSet(set);
1106 if (token == TokenNameEQUAL) {
1110 if (token != TokenNameCOMMA) {
1120 private void unset_variables() {
1123 // | unset_variables ',' unset_variable
1127 variable(false, false);
1128 if (token != TokenNameCOMMA) {
1135 private final void initializeModifiers() {
1137 this.modifiersSourceStart = -1;
1140 private final void checkAndSetModifiers(int flag) {
1141 this.modifiers |= flag;
1142 if (this.modifiersSourceStart < 0)
1143 this.modifiersSourceStart = this.scanner.startPosition;
1146 private void unticked_class_declaration_statement(TypeDeclaration typeDecl) {
1147 initializeModifiers();
1148 if (token == TokenNameinterface) {
1149 // interface_entry T_STRING
1150 // interface_extends_list
1151 // '{' class_statement_list '}'
1152 checkAndSetModifiers(AccInterface);
1154 typeDecl.modifiers = this.modifiers;
1155 typeDecl.sourceStart = scanner.getCurrentTokenStartPosition();
1156 typeDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
1157 if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
1158 typeDecl.name = scanner.getCurrentIdentifierSource();
1159 if (token > TokenNameKEYWORD) {
1160 problemReporter.phpKeywordWarning(new String[] { scanner.toStringAction(token) }, scanner.getCurrentTokenStartPosition(),
1161 scanner.getCurrentTokenEndPosition(), referenceContext, compilationUnit.compilationResult);
1162 // throwSyntaxError("Don't use a keyword for interface declaration ["
1163 // + scanner.toStringAction(token) + "].",
1164 // typeDecl.sourceStart, typeDecl.sourceEnd);
1167 interface_extends_list(typeDecl);
1169 typeDecl.name = new char[] { ' ' };
1170 throwSyntaxError("Interface name expected after keyword 'interface'.", typeDecl.sourceStart, typeDecl.sourceEnd);
1174 // class_entry_type T_STRING extends_from
1176 // '{' class_statement_list'}'
1178 typeDecl.modifiers = this.modifiers;
1179 typeDecl.sourceStart = scanner.getCurrentTokenStartPosition();
1180 typeDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
1182 // identifier 'extends' identifier
1183 if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
1184 typeDecl.name = scanner.getCurrentIdentifierSource();
1185 if (token > TokenNameKEYWORD) {
1186 problemReporter.phpKeywordWarning(new String[] { scanner.toStringAction(token) }, scanner.getCurrentTokenStartPosition(),
1187 scanner.getCurrentTokenEndPosition(), referenceContext, compilationUnit.compilationResult);
1188 // throwSyntaxError("Don't use a keyword for class declaration [" +
1189 // scanner.toStringAction(token) + "].",
1190 // typeDecl.sourceStart, typeDecl.sourceEnd);
1195 // | T_EXTENDS fully_qualified_class_name
1196 if (token == TokenNameextends) {
1197 interface_extends_list(typeDecl);
1199 // if (token != TokenNameIdentifier) {
1200 // throwSyntaxError("Class name expected after keyword
1202 // scanner.getCurrentTokenStartPosition(), scanner
1203 // .getCurrentTokenEndPosition());
1206 implements_list(typeDecl);
1208 typeDecl.name = new char[] { ' ' };
1209 throwSyntaxError("Class name expected after keyword 'class'.", typeDecl.sourceStart, typeDecl.sourceEnd);
1213 // '{' class_statement_list '}'
1214 if (token == TokenNameLBRACE) {
1216 if (token != TokenNameRBRACE) {
1217 ArrayList list = new ArrayList();
1218 class_statement_list(list);
1219 typeDecl.fields = new FieldDeclaration[list.size()];
1220 for (int i = 0; i < list.size(); i++) {
1221 typeDecl.fields[i] = (FieldDeclaration) list.get(i);
1224 if (token == TokenNameRBRACE) {
1225 typeDecl.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
1228 throwSyntaxError("'}' expected at end of class body.");
1231 throwSyntaxError("'{' expected at start of class body.");
1235 private void class_entry_type() {
1237 // | T_ABSTRACT T_CLASS
1238 // | T_FINAL T_CLASS
1239 if (token == TokenNameclass) {
1241 } else if (token == TokenNameabstract) {
1242 checkAndSetModifiers(AccAbstract);
1244 if (token != TokenNameclass) {
1245 throwSyntaxError("Keyword 'class' expected after keyword 'abstract'.");
1248 } else if (token == TokenNamefinal) {
1249 checkAndSetModifiers(AccFinal);
1251 if (token != TokenNameclass) {
1252 throwSyntaxError("Keyword 'class' expected after keyword 'final'.");
1256 throwSyntaxError("Keyword 'class' 'final' or 'abstract' expected");
1260 // private void class_extends(TypeDeclaration typeDecl) {
1262 // // | T_EXTENDS interface_list
1263 // if (token == TokenNameextends) {
1266 // if (token == TokenNameIdentifier) {
1269 // throwSyntaxError("Class name expected after keyword 'extends'.");
1274 private void interface_extends_list(TypeDeclaration typeDecl) {
1276 // | T_EXTENDS interface_list
1277 if (token == TokenNameextends) {
1283 private void implements_list(TypeDeclaration typeDecl) {
1285 // | T_IMPLEMENTS interface_list
1286 if (token == TokenNameimplements) {
1292 private void interface_list() {
1294 // fully_qualified_class_name
1295 // | interface_list ',' fully_qualified_class_name
1297 if (token == TokenNameIdentifier) {
1300 throwSyntaxError("Interface name expected after keyword 'implements'.");
1302 if (token != TokenNameCOMMA) {
1309 // private void classBody(TypeDeclaration typeDecl) {
1310 // //'{' [class-element-list] '}'
1311 // if (token == TokenNameLBRACE) {
1313 // if (token != TokenNameRBRACE) {
1314 // class_statement_list();
1316 // if (token == TokenNameRBRACE) {
1317 // typeDecl.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
1320 // throwSyntaxError("'}' expected at end of class body.");
1323 // throwSyntaxError("'{' expected at start of class body.");
1326 private void class_statement_list(ArrayList list) {
1329 class_statement(list);
1330 if (token == TokenNamepublic || token == TokenNameprotected || token == TokenNameprivate || token == TokenNamestatic
1331 || token == TokenNameabstract || token == TokenNamefinal || token == TokenNamefunction || token == TokenNamevar
1332 || token == TokenNameconst) {
1335 if (token == TokenNameRBRACE) {
1338 throwSyntaxError("'}' at end of class statement.");
1339 } catch (SyntaxError sytaxErr1) {
1340 boolean tokenize = scanner.tokenizeStrings;
1342 scanner.tokenizeStrings = true;
1345 // if an error occured,
1346 // try to find keywords
1347 // to parse the rest of the string
1348 while (token != TokenNameEOF) {
1349 if (token == TokenNamepublic || token == TokenNameprotected || token == TokenNameprivate || token == TokenNamestatic
1350 || token == TokenNameabstract || token == TokenNamefinal || token == TokenNamefunction || token == TokenNamevar
1351 || token == TokenNameconst) {
1354 // System.out.println(scanner.toStringAction(token));
1357 if (token == TokenNameEOF) {
1361 scanner.tokenizeStrings = tokenize;
1367 private void class_statement(ArrayList list) {
1369 // variable_modifiers class_variable_declaration ';'
1370 // | class_constant_declaration ';'
1371 // | method_modifiers T_FUNCTION is_reference T_STRING
1372 // '(' parameter_list ')' method_body
1373 initializeModifiers();
1374 int declarationSourceStart = scanner.getCurrentTokenStartPosition();
1376 if (token == TokenNamevar) {
1377 checkAndSetModifiers(AccPublic);
1378 problemReporter.phpVarDeprecatedWarning(scanner.getCurrentTokenStartPosition(), scanner.getCurrentTokenEndPosition(),
1379 referenceContext, compilationUnit.compilationResult);
1381 class_variable_declaration(declarationSourceStart, list);
1382 } else if (token == TokenNameconst) {
1383 checkAndSetModifiers(AccFinal | AccPublic);
1384 class_constant_declaration(declarationSourceStart, list);
1385 if (token != TokenNameSEMICOLON) {
1386 throwSyntaxError("';' expected after class const declaration.");
1390 boolean hasModifiers = member_modifiers();
1391 if (token == TokenNamefunction) {
1392 if (!hasModifiers) {
1393 checkAndSetModifiers(AccPublic);
1395 MethodDeclaration methodDecl = new MethodDeclaration(this.compilationUnit.compilationResult);
1396 methodDecl.declarationSourceStart = scanner.getCurrentTokenStartPosition();
1397 methodDecl.modifiers = this.modifiers;
1398 methodDecl.type = MethodDeclaration.METHOD_DEFINITION;
1401 functionDefinition(methodDecl);
1403 int sourceEnd = methodDecl.sourceEnd;
1404 if (sourceEnd <= 0 || methodDecl.declarationSourceStart > sourceEnd) {
1405 sourceEnd = methodDecl.declarationSourceStart + 1;
1407 methodDecl.declarationSourceEnd = sourceEnd;
1408 methodDecl.sourceEnd = sourceEnd;
1411 if (!hasModifiers) {
1412 throwSyntaxError("'public' 'private' or 'protected' modifier expected for field declarations.");
1414 class_variable_declaration(declarationSourceStart, list);
1419 private void class_constant_declaration(int declarationSourceStart, ArrayList list) {
1420 // class_constant_declaration ',' T_STRING '=' static_scalar
1421 // | T_CONST T_STRING '=' static_scalar
1422 if (token != TokenNameconst) {
1423 throwSyntaxError("'const' keyword expected in class declaration.");
1428 if (token != TokenNameIdentifier) {
1429 throwSyntaxError("Identifier expected in class const declaration.");
1431 FieldDeclaration fieldDeclaration = new FieldDeclaration(scanner.getCurrentIdentifierSource(), scanner
1432 .getCurrentTokenStartPosition(), scanner.getCurrentTokenEndPosition());
1433 fieldDeclaration.modifiers = this.modifiers;
1434 fieldDeclaration.declarationSourceStart = declarationSourceStart;
1435 fieldDeclaration.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
1436 fieldDeclaration.modifiersSourceStart = declarationSourceStart;
1437 // fieldDeclaration.type
1438 list.add(fieldDeclaration);
1440 if (token != TokenNameEQUAL) {
1441 throwSyntaxError("'=' expected in class const declaration.");
1445 if (token != TokenNameCOMMA) {
1446 break; // while(true)-loop
1452 // private void variable_modifiers() {
1453 // // variable_modifiers:
1454 // // non_empty_member_modifiers
1456 // initializeModifiers();
1457 // if (token == TokenNamevar) {
1458 // checkAndSetModifiers(AccPublic);
1459 // reportSyntaxError(
1460 // "Keyword 'var' is deprecated. Please use 'public' 'private' or
1462 // modifier for field declarations.",
1463 // scanner.getCurrentTokenStartPosition(), scanner
1464 // .getCurrentTokenEndPosition());
1467 // if (!member_modifiers()) {
1468 // throwSyntaxError("'public' 'private' or 'protected' modifier expected for
1469 // field declarations.");
1473 // private void method_modifiers() {
1474 // //method_modifiers:
1476 // //| non_empty_member_modifiers
1477 // initializeModifiers();
1478 // if (!member_modifiers()) {
1479 // checkAndSetModifiers(AccPublic);
1482 private boolean member_modifiers() {
1489 boolean foundToken = false;
1491 if (token == TokenNamepublic) {
1492 checkAndSetModifiers(AccPublic);
1495 } else if (token == TokenNameprotected) {
1496 checkAndSetModifiers(AccProtected);
1499 } else if (token == TokenNameprivate) {
1500 checkAndSetModifiers(AccPrivate);
1503 } else if (token == TokenNamestatic) {
1504 checkAndSetModifiers(AccStatic);
1507 } else if (token == TokenNameabstract) {
1508 checkAndSetModifiers(AccAbstract);
1511 } else if (token == TokenNamefinal) {
1512 checkAndSetModifiers(AccFinal);
1522 private void class_variable_declaration(int declarationSourceStart, ArrayList list) {
1523 // class_variable_declaration:
1524 // class_variable_declaration ',' T_VARIABLE
1525 // | class_variable_declaration ',' T_VARIABLE '=' static_scalar
1527 // | T_VARIABLE '=' static_scalar
1528 char[] classVariable;
1530 if (token == TokenNameVariable) {
1531 classVariable = scanner.getCurrentIdentifierSource();
1532 // indexManager.addIdentifierInformation('v', classVariable, buf, -1,
1534 FieldDeclaration fieldDeclaration = new FieldDeclaration(classVariable, scanner.getCurrentTokenStartPosition(), scanner
1535 .getCurrentTokenEndPosition());
1536 fieldDeclaration.modifiers = this.modifiers;
1537 fieldDeclaration.declarationSourceStart = declarationSourceStart;
1538 fieldDeclaration.declarationSourceEnd = scanner.getCurrentTokenEndPosition();
1539 fieldDeclaration.modifiersSourceStart = declarationSourceStart;
1540 list.add(fieldDeclaration);
1541 if (fTypeVariables != null) {
1542 VariableInfo info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_CLASS_UNIT);
1543 fTypeVariables.put(new String(scanner.getCurrentIdentifierSource()), info);
1546 if (token == TokenNameEQUAL) {
1551 // if (token == TokenNamethis) {
1552 // throwSyntaxError("'$this' not allowed after keyword 'public'
1553 // 'protected' 'private' 'var'.");
1555 throwSyntaxError("Variable expected after keyword 'public' 'protected' 'private' 'var'.");
1557 if (token != TokenNameCOMMA) {
1562 if (token != TokenNameSEMICOLON) {
1563 throwSyntaxError("';' expected after field declaration.");
1568 private void functionDefinition(MethodDeclaration methodDecl) {
1569 boolean isAbstract = false;
1571 if (compilationUnit != null) {
1572 compilationUnit.types.add(methodDecl);
1575 ASTNode node = astStack[astPtr];
1576 if (node instanceof TypeDeclaration) {
1577 TypeDeclaration typeDecl = ((TypeDeclaration) node);
1578 if (typeDecl.methods == null) {
1579 typeDecl.methods = new AbstractMethodDeclaration[] { methodDecl };
1581 AbstractMethodDeclaration[] newMethods;
1582 System.arraycopy(typeDecl.methods, 0, newMethods = new AbstractMethodDeclaration[typeDecl.methods.length + 1], 0,
1583 typeDecl.methods.length);
1584 newMethods[typeDecl.methods.length] = methodDecl;
1585 typeDecl.methods = newMethods;
1587 if ((typeDecl.modifiers & AccAbstract) == AccAbstract) {
1589 } else if ((typeDecl.modifiers & AccInterface) == AccInterface) {
1595 pushFunctionVariableSet();
1596 functionDeclarator(methodDecl);
1597 if (token == TokenNameSEMICOLON) {
1599 methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
1600 throwSyntaxError("Body declaration expected for method: " + new String(methodDecl.selector));
1605 functionBody(methodDecl);
1607 if (!fStackUnassigned.isEmpty()) {
1608 fStackUnassigned.remove(fStackUnassigned.size() - 1);
1613 private void functionDeclarator(MethodDeclaration methodDecl) {
1614 // identifier '(' [parameter-list] ')'
1615 if (token == TokenNameAND) {
1618 methodDecl.sourceStart = scanner.getCurrentTokenStartPosition();
1619 methodDecl.sourceEnd = scanner.getCurrentTokenEndPosition();
1620 if (Scanner.isIdentifierOrKeyword(token)) {
1621 methodDecl.selector = scanner.getCurrentIdentifierSource();
1622 if (token > TokenNameKEYWORD) {
1623 problemReporter.phpKeywordWarning(new String[] { scanner.toStringAction(token) }, scanner.getCurrentTokenStartPosition(),
1624 scanner.getCurrentTokenEndPosition(), referenceContext, compilationUnit.compilationResult);
1627 if (token == TokenNameLPAREN) {
1630 methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
1631 throwSyntaxError("'(' expected in function declaration.");
1633 if (token != TokenNameRPAREN) {
1634 parameter_list(methodDecl);
1636 if (token != TokenNameRPAREN) {
1637 methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
1638 throwSyntaxError("')' expected in function declaration.");
1640 methodDecl.bodyStart = scanner.getCurrentTokenEndPosition() + 1;
1644 methodDecl.selector = "<undefined>".toCharArray();
1645 methodDecl.sourceEnd = scanner.getCurrentTokenStartPosition() - 1;
1646 throwSyntaxError("Function name expected after keyword 'function'.");
1651 private void parameter_list(MethodDeclaration methodDecl) {
1652 // non_empty_parameter_list
1654 non_empty_parameter_list(methodDecl, true);
1657 private void non_empty_parameter_list(MethodDeclaration methodDecl, boolean empty_allowed) {
1658 // optional_class_type T_VARIABLE
1659 // | optional_class_type '&' T_VARIABLE
1660 // | optional_class_type '&' T_VARIABLE '=' static_scalar
1661 // | optional_class_type T_VARIABLE '=' static_scalar
1662 // | non_empty_parameter_list ',' optional_class_type T_VARIABLE
1663 // | non_empty_parameter_list ',' optional_class_type '&' T_VARIABLE
1664 // | non_empty_parameter_list ',' optional_class_type '&' T_VARIABLE '='
1666 // | non_empty_parameter_list ',' optional_class_type T_VARIABLE '='
1668 char[] typeIdentifier = null;
1669 if (token == TokenNameIdentifier || token == TokenNameVariable || token == TokenNameAND) {
1670 HashSet set = peekVariableSet();
1672 if (token == TokenNameIdentifier) {
1673 typeIdentifier = scanner.getCurrentIdentifierSource();
1676 if (token == TokenNameAND) {
1679 if (token == TokenNameVariable) {
1680 if (fMethodVariables != null) {
1682 if (methodDecl.type == MethodDeclaration.FUNCTION_DEFINITION) {
1683 info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_FUNCTION_DEFINITION);
1685 info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_METHOD_DEFINITION);
1687 info.typeIdentifier = typeIdentifier;
1688 fMethodVariables.put(new String(scanner.getCurrentIdentifierSource()), info);
1690 addVariableSet(set);
1692 if (token == TokenNameEQUAL) {
1697 throwSyntaxError("Variable expected in parameter list.");
1699 if (token != TokenNameCOMMA) {
1706 if (!empty_allowed) {
1707 throwSyntaxError("Identifier expected in parameter list.");
1711 private void optional_class_type() {
1716 // private void parameterDeclaration() {
1718 // //variable-reference
1719 // if (token == TokenNameAND) {
1721 // if (isVariable()) {
1724 // throwSyntaxError("Variable expected after reference operator '&'.");
1727 // //variable '=' constant
1728 // if (token == TokenNameVariable) {
1730 // if (token == TokenNameEQUAL) {
1736 // // if (token == TokenNamethis) {
1737 // // throwSyntaxError("Reserved word '$this' not allowed in parameter
1738 // // declaration.");
1742 private void labeledStatementList() {
1743 if (token != TokenNamecase && token != TokenNamedefault) {
1744 throwSyntaxError("'case' or 'default' expected.");
1747 if (token == TokenNamecase) {
1749 expr(); // constant();
1750 if (token == TokenNameCOLON || token == TokenNameSEMICOLON) {
1752 if (token == TokenNamecase || token == TokenNamedefault) {
1753 // empty case statement ?
1758 // else if (token == TokenNameSEMICOLON) {
1760 // "':' expected after 'case' keyword (Found token: " +
1761 // scanner.toStringAction(token) + ")",
1762 // scanner.getCurrentTokenStartPosition(),
1763 // scanner.getCurrentTokenEndPosition(),
1766 // if (token == TokenNamecase) { // empty case statement ?
1772 throwSyntaxError("':' character expected after 'case' constant (Found token: " + scanner.toStringAction(token) + ")");
1774 } else { // TokenNamedefault
1776 if (token == TokenNameCOLON || token == TokenNameSEMICOLON) {
1778 if (token == TokenNameRBRACE) {
1779 // empty default case
1782 if (token != TokenNamecase) {
1786 throwSyntaxError("':' character expected after 'default'.");
1789 } while (token == TokenNamecase || token == TokenNamedefault);
1792 private void ifStatementColon(IfStatement iState) {
1793 // T_IF '(' expr ')' ':' inner_statement_list new_elseif_list
1794 // new_else_single T_ENDIF ';'
1795 HashSet assignedVariableSet = null;
1797 Block b = inner_statement_list();
1798 iState.thenStatement = b;
1799 checkUnreachable(iState, b);
1801 assignedVariableSet = removeIfVariableSet();
1803 if (token == TokenNameelseif) {
1805 pushIfVariableSet();
1806 new_elseif_list(iState);
1808 HashSet set = removeIfVariableSet();
1809 if (assignedVariableSet != null && set != null) {
1810 assignedVariableSet.addAll(set);
1815 pushIfVariableSet();
1816 new_else_single(iState);
1818 HashSet set = removeIfVariableSet();
1819 if (assignedVariableSet != null) {
1820 HashSet topSet = peekVariableSet();
1821 if (topSet != null) {
1825 topSet.addAll(assignedVariableSet);
1829 if (token != TokenNameendif) {
1830 throwSyntaxError("'endif' expected.");
1833 if (token != TokenNameSEMICOLON) {
1834 reportSyntaxError("';' expected after if-statement.");
1835 iState.sourceEnd = scanner.getCurrentTokenStartPosition();
1837 iState.sourceEnd = scanner.getCurrentTokenEndPosition();
1842 private void ifStatement(IfStatement iState) {
1843 // T_IF '(' expr ')' statement elseif_list else_single
1844 HashSet assignedVariableSet = null;
1846 pushIfVariableSet();
1847 Statement s = statement();
1848 iState.thenStatement = s;
1849 checkUnreachable(iState, s);
1851 assignedVariableSet = removeIfVariableSet();
1854 if (token == TokenNameelseif) {
1856 pushIfVariableSet();
1857 elseif_list(iState);
1859 HashSet set = removeIfVariableSet();
1860 if (assignedVariableSet != null && set != null) {
1861 assignedVariableSet.addAll(set);
1866 pushIfVariableSet();
1867 else_single(iState);
1869 HashSet set = removeIfVariableSet();
1870 if (assignedVariableSet != null) {
1871 HashSet topSet = peekVariableSet();
1872 if (topSet != null) {
1876 topSet.addAll(assignedVariableSet);
1882 private void elseif_list(IfStatement iState) {
1884 // | elseif_list T_ELSEIF '(' expr ')' statement
1885 ArrayList conditionList = new ArrayList();
1886 ArrayList statementList = new ArrayList();
1889 while (token == TokenNameelseif) {
1891 if (token == TokenNameLPAREN) {
1894 throwSyntaxError("'(' expected after 'elseif' keyword.");
1897 conditionList.add(e);
1898 if (token == TokenNameRPAREN) {
1901 throwSyntaxError("')' expected after 'elseif' condition.");
1904 statementList.add(s);
1905 checkUnreachable(iState, s);
1907 iState.elseifConditions = new Expression[conditionList.size()];
1908 iState.elseifStatements = new Statement[statementList.size()];
1909 conditionList.toArray(iState.elseifConditions);
1910 statementList.toArray(iState.elseifStatements);
1913 private void new_elseif_list(IfStatement iState) {
1915 // | new_elseif_list T_ELSEIF '(' expr ')' ':' inner_statement_list
1916 ArrayList conditionList = new ArrayList();
1917 ArrayList statementList = new ArrayList();
1920 while (token == TokenNameelseif) {
1922 if (token == TokenNameLPAREN) {
1925 throwSyntaxError("'(' expected after 'elseif' keyword.");
1928 conditionList.add(e);
1929 if (token == TokenNameRPAREN) {
1932 throwSyntaxError("')' expected after 'elseif' condition.");
1934 if (token == TokenNameCOLON) {
1937 throwSyntaxError("':' expected after 'elseif' keyword.");
1939 b = inner_statement_list();
1940 statementList.add(b);
1941 checkUnreachable(iState, b);
1943 iState.elseifConditions = new Expression[conditionList.size()];
1944 iState.elseifStatements = new Statement[statementList.size()];
1945 conditionList.toArray(iState.elseifConditions);
1946 statementList.toArray(iState.elseifStatements);
1949 private void else_single(IfStatement iState) {
1952 if (token == TokenNameelse) {
1954 Statement s = statement();
1955 iState.elseStatement = s;
1956 checkUnreachable(iState, s);
1958 iState.checkUnreachable = false;
1960 iState.sourceEnd = scanner.getCurrentTokenStartPosition();
1963 private void new_else_single(IfStatement iState) {
1965 // | T_ELSE ':' inner_statement_list
1966 if (token == TokenNameelse) {
1968 if (token == TokenNameCOLON) {
1971 throwSyntaxError("':' expected after 'else' keyword.");
1973 Block b = inner_statement_list();
1974 iState.elseStatement = b;
1975 checkUnreachable(iState, b);
1977 iState.checkUnreachable = false;
1981 private Block inner_statement_list() {
1982 // inner_statement_list inner_statement
1984 return statementList();
1991 private void checkUnreachable(IfStatement iState, Statement s) {
1992 if (s instanceof Block) {
1993 Block b = (Block) s;
1994 if (b.statements == null || b.statements.length == 0) {
1995 iState.checkUnreachable = false;
1997 int off = b.statements.length - 1;
1998 if (!(b.statements[off] instanceof ReturnStatement) && !(b.statements[off] instanceof ContinueStatement)
1999 && !(b.statements[off] instanceof BreakStatement)) {
2000 if (!(b.statements[off] instanceof IfStatement) || !((IfStatement) b.statements[off]).checkUnreachable) {
2001 iState.checkUnreachable = false;
2006 if (!(s instanceof ReturnStatement) && !(s instanceof ContinueStatement) && !(s instanceof BreakStatement)) {
2007 if (!(s instanceof IfStatement) || !((IfStatement) s).checkUnreachable) {
2008 iState.checkUnreachable = false;
2014 // private void elseifStatementList() {
2016 // elseifStatement();
2018 // case TokenNameelse:
2020 // if (token == TokenNameCOLON) {
2022 // if (token != TokenNameendif) {
2027 // if (token == TokenNameif) { //'else if'
2030 // throwSyntaxError("':' expected after 'else'.");
2034 // case TokenNameelseif:
2043 // private void elseifStatement() {
2044 // if (token == TokenNameLPAREN) {
2047 // if (token != TokenNameRPAREN) {
2048 // throwSyntaxError("')' expected in else-if-statement.");
2051 // if (token != TokenNameCOLON) {
2052 // throwSyntaxError("':' expected in else-if-statement.");
2055 // if (token != TokenNameendif) {
2061 private void switchStatement() {
2062 if (token == TokenNameCOLON) {
2063 // ':' [labeled-statement-list] 'endswitch' ';'
2065 labeledStatementList();
2066 if (token != TokenNameendswitch) {
2067 throwSyntaxError("'endswitch' expected.");
2070 if (token != TokenNameSEMICOLON) {
2071 throwSyntaxError("';' expected after switch-statement.");
2075 // '{' [labeled-statement-list] '}'
2076 if (token != TokenNameLBRACE) {
2077 throwSyntaxError("'{' expected in switch statement.");
2080 if (token != TokenNameRBRACE) {
2081 labeledStatementList();
2083 if (token != TokenNameRBRACE) {
2084 throwSyntaxError("'}' expected in switch statement.");
2090 private void forStatement() {
2091 if (token == TokenNameCOLON) {
2094 if (token != TokenNameendfor) {
2095 throwSyntaxError("'endfor' expected.");
2098 if (token != TokenNameSEMICOLON) {
2099 throwSyntaxError("';' expected after for-statement.");
2107 private void whileStatement() {
2108 // ':' statement-list 'endwhile' ';'
2109 if (token == TokenNameCOLON) {
2112 if (token != TokenNameendwhile) {
2113 throwSyntaxError("'endwhile' expected.");
2116 if (token != TokenNameSEMICOLON) {
2117 throwSyntaxError("';' expected after while-statement.");
2125 private void foreachStatement() {
2126 if (token == TokenNameCOLON) {
2129 if (token != TokenNameendforeach) {
2130 throwSyntaxError("'endforeach' expected.");
2133 if (token != TokenNameSEMICOLON) {
2134 throwSyntaxError("';' expected after foreach-statement.");
2142 // private void exitStatus() {
2143 // if (token == TokenNameLPAREN) {
2146 // throwSyntaxError("'(' expected in 'exit-status'.");
2148 // if (token != TokenNameRPAREN) {
2151 // if (token == TokenNameRPAREN) {
2154 // throwSyntaxError("')' expected after 'exit-status'.");
2157 private void expressionList() {
2160 if (token == TokenNameCOMMA) {
2168 private Expression expr() {
2170 // | expr_without_variable
2171 // if (token!=TokenNameEOF) {
2172 if (Scanner.TRACE) {
2173 System.out.println("TRACE: expr()");
2175 return expr_without_variable(true);
2179 private Expression expr_without_variable(boolean only_variable) {
2180 int exprSourceStart = scanner.getCurrentTokenStartPosition();
2181 int exprSourceEnd = scanner.getCurrentTokenEndPosition();
2182 Expression expression = new Expression();
2183 expression.sourceStart = exprSourceStart;
2184 // default, may be overwritten
2185 expression.sourceEnd = exprSourceEnd;
2187 // internal_functions_in_yacc
2196 // | T_INC rw_variable
2197 // | T_DEC rw_variable
2198 // | T_INT_CAST expr
2199 // | T_DOUBLE_CAST expr
2200 // | T_STRING_CAST expr
2201 // | T_ARRAY_CAST expr
2202 // | T_OBJECT_CAST expr
2203 // | T_BOOL_CAST expr
2204 // | T_UNSET_CAST expr
2205 // | T_EXIT exit_expr
2207 // | T_ARRAY '(' array_pair_list ')'
2208 // | '`' encaps_list '`'
2209 // | T_LIST '(' assignment_list ')' '=' expr
2210 // | T_NEW class_name_reference ctor_arguments
2211 // | variable '=' expr
2212 // | variable '=' '&' variable
2213 // | variable '=' '&' T_NEW class_name_reference ctor_arguments
2214 // | variable T_PLUS_EQUAL expr
2215 // | variable T_MINUS_EQUAL expr
2216 // | variable T_MUL_EQUAL expr
2217 // | variable T_DIV_EQUAL expr
2218 // | variable T_CONCAT_EQUAL expr
2219 // | variable T_MOD_EQUAL expr
2220 // | variable T_AND_EQUAL expr
2221 // | variable T_OR_EQUAL expr
2222 // | variable T_XOR_EQUAL expr
2223 // | variable T_SL_EQUAL expr
2224 // | variable T_SR_EQUAL expr
2225 // | rw_variable T_INC
2226 // | rw_variable T_DEC
2227 // | expr T_BOOLEAN_OR expr
2228 // | expr T_BOOLEAN_AND expr
2229 // | expr T_LOGICAL_OR expr
2230 // | expr T_LOGICAL_AND expr
2231 // | expr T_LOGICAL_XOR expr
2243 // | expr T_IS_IDENTICAL expr
2244 // | expr T_IS_NOT_IDENTICAL expr
2245 // | expr T_IS_EQUAL expr
2246 // | expr T_IS_NOT_EQUAL expr
2248 // | expr T_IS_SMALLER_OR_EQUAL expr
2250 // | expr T_IS_GREATER_OR_EQUAL expr
2251 // | expr T_INSTANCEOF class_name_reference
2252 // | expr '?' expr ':' expr
2253 if (Scanner.TRACE) {
2254 System.out.println("TRACE: expr_without_variable() PART 1");
2257 case TokenNameisset:
2258 // T_ISSET '(' isset_variables ')'
2260 if (token != TokenNameLPAREN) {
2261 throwSyntaxError("'(' expected after keyword 'isset'");
2265 if (token != TokenNameRPAREN) {
2266 throwSyntaxError("')' expected after keyword 'isset'");
2270 case TokenNameempty:
2272 if (token != TokenNameLPAREN) {
2273 throwSyntaxError("'(' expected after keyword 'empty'");
2276 variable(true, false);
2277 if (token != TokenNameRPAREN) {
2278 throwSyntaxError("')' expected after keyword 'empty'");
2283 case TokenNameinclude:
2284 case TokenNameinclude_once:
2285 case TokenNamerequire:
2286 case TokenNamerequire_once:
2287 internal_functions_in_yacc();
2290 case TokenNameLPAREN:
2293 if (token == TokenNameRPAREN) {
2296 throwSyntaxError("')' expected in expression.");
2306 // | T_INT_CAST expr
2307 // | T_DOUBLE_CAST expr
2308 // | T_STRING_CAST expr
2309 // | T_ARRAY_CAST expr
2310 // | T_OBJECT_CAST expr
2311 // | T_BOOL_CAST expr
2312 // | T_UNSET_CAST expr
2313 case TokenNameclone:
2314 case TokenNameprint:
2317 case TokenNameMINUS:
2319 case TokenNameTWIDDLE:
2320 case TokenNameintCAST:
2321 case TokenNamedoubleCAST:
2322 case TokenNamestringCAST:
2323 case TokenNamearrayCAST:
2324 case TokenNameobjectCAST:
2325 case TokenNameboolCAST:
2326 case TokenNameunsetCAST:
2336 // | T_STRING_VARNAME
2338 // | T_START_HEREDOC encaps_list T_END_HEREDOC
2339 // | '`' encaps_list '`'
2341 // | '`' encaps_list '`'
2342 // case TokenNameEncapsedString0:
2343 // scanner.encapsedStringStack.push(new Character('`'));
2346 // if (token == TokenNameEncapsedString0) {
2349 // if (token != TokenNameEncapsedString0) {
2350 // throwSyntaxError("\'`\' expected at end of string" + "(Found token: " +
2351 // scanner.toStringAction(token) + " )");
2355 // scanner.encapsedStringStack.pop();
2359 // // | '\'' encaps_list '\''
2360 // case TokenNameEncapsedString1:
2361 // scanner.encapsedStringStack.push(new Character('\''));
2364 // exprSourceStart = scanner.getCurrentTokenStartPosition();
2365 // if (token == TokenNameEncapsedString1) {
2367 // StringLiteralSQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
2368 // exprSourceStart, scanner
2369 // .getCurrentTokenEndPosition());
2372 // if (token != TokenNameEncapsedString1) {
2373 // throwSyntaxError("\'\'\' expected at end of string" + "(Found token: "
2374 // + scanner.toStringAction(token) + " )");
2377 // StringLiteralSQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
2378 // exprSourceStart, scanner
2379 // .getCurrentTokenEndPosition());
2383 // scanner.encapsedStringStack.pop();
2387 // //| '"' encaps_list '"'
2388 // case TokenNameEncapsedString2:
2389 // scanner.encapsedStringStack.push(new Character('"'));
2392 // exprSourceStart = scanner.getCurrentTokenStartPosition();
2393 // if (token == TokenNameEncapsedString2) {
2395 // StringLiteralDQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
2396 // exprSourceStart, scanner
2397 // .getCurrentTokenEndPosition());
2400 // if (token != TokenNameEncapsedString2) {
2401 // throwSyntaxError("'\"' expected at end of string" + "(Found token: " +
2402 // scanner.toStringAction(token) + " )");
2405 // StringLiteralDQ(scanner.getCurrentStringLiteralSource(exprSourceStart),
2406 // exprSourceStart, scanner
2407 // .getCurrentTokenEndPosition());
2411 // scanner.encapsedStringStack.pop();
2415 case TokenNameStringDoubleQuote:
2416 expression = new StringLiteralDQ(scanner.getCurrentStringLiteralSource(), scanner.getCurrentTokenStartPosition(), scanner
2417 .getCurrentTokenEndPosition());
2420 case TokenNameStringSingleQuote:
2421 expression = new StringLiteralSQ(scanner.getCurrentStringLiteralSource(), scanner.getCurrentTokenStartPosition(), scanner
2422 .getCurrentTokenEndPosition());
2425 case TokenNameIntegerLiteral:
2426 case TokenNameDoubleLiteral:
2427 case TokenNameStringInterpolated:
2430 case TokenNameCLASS_C:
2431 case TokenNameMETHOD_C:
2432 case TokenNameFUNC_C:
2435 case TokenNameHEREDOC:
2438 case TokenNamearray:
2439 // T_ARRAY '(' array_pair_list ')'
2441 if (token == TokenNameLPAREN) {
2443 if (token == TokenNameRPAREN) {
2448 if (token != TokenNameRPAREN) {
2449 throwSyntaxError("')' or ',' expected after keyword 'array'" + "(Found token: " + scanner.toStringAction(token) + ")");
2453 throwSyntaxError("'(' expected after keyword 'array'" + "(Found token: " + scanner.toStringAction(token) + ")");
2457 // | T_LIST '(' assignment_list ')' '=' expr
2459 if (token == TokenNameLPAREN) {
2462 if (token != TokenNameRPAREN) {
2463 throwSyntaxError("')' expected after 'list' keyword.");
2466 if (token != TokenNameEQUAL) {
2467 throwSyntaxError("'=' expected after 'list' keyword.");
2472 throwSyntaxError("'(' expected after 'list' keyword.");
2476 // | T_NEW class_name_reference ctor_arguments
2478 Expression typeRef = class_name_reference();
2480 if (typeRef != null) {
2481 expression = typeRef;
2484 // | T_INC rw_variable
2485 // | T_DEC rw_variable
2486 case TokenNamePLUS_PLUS:
2487 case TokenNameMINUS_MINUS:
2491 // | variable '=' expr
2492 // | variable '=' '&' variable
2493 // | variable '=' '&' T_NEW class_name_reference ctor_arguments
2494 // | variable T_PLUS_EQUAL expr
2495 // | variable T_MINUS_EQUAL expr
2496 // | variable T_MUL_EQUAL expr
2497 // | variable T_DIV_EQUAL expr
2498 // | variable T_CONCAT_EQUAL expr
2499 // | variable T_MOD_EQUAL expr
2500 // | variable T_AND_EQUAL expr
2501 // | variable T_OR_EQUAL expr
2502 // | variable T_XOR_EQUAL expr
2503 // | variable T_SL_EQUAL expr
2504 // | variable T_SR_EQUAL expr
2505 // | rw_variable T_INC
2506 // | rw_variable T_DEC
2507 case TokenNameIdentifier:
2508 case TokenNameVariable:
2509 case TokenNameDOLLAR:
2510 Expression lhs = null;
2511 boolean rememberedVar = false;
2512 if (token == TokenNameIdentifier) {
2513 lhs = identifier(true, true);
2518 lhs = variable(true, true);
2522 if (lhs != null && lhs instanceof FieldReference && token != TokenNameEQUAL && token != TokenNamePLUS_EQUAL
2523 && token != TokenNameMINUS_EQUAL && token != TokenNameMULTIPLY_EQUAL && token != TokenNameDIVIDE_EQUAL
2524 && token != TokenNameDOT_EQUAL && token != TokenNameREMAINDER_EQUAL && token != TokenNameAND_EQUAL
2525 && token != TokenNameOR_EQUAL && token != TokenNameXOR_EQUAL && token != TokenNameRIGHT_SHIFT_EQUAL
2526 && token != TokenNameLEFT_SHIFT_EQUAL) {
2527 FieldReference ref = (FieldReference) lhs;
2528 if (!containsVariableSet(ref.token)) {
2529 problemReporter.uninitializedLocalVariable(new String(ref.token), ref.sourceStart(), ref.sourceEnd(),
2530 referenceContext, compilationUnit.compilationResult);
2531 addVariableSet(ref.token);
2536 case TokenNameEQUAL:
2537 if (lhs != null && lhs instanceof FieldReference) {
2538 addVariableSet(((FieldReference) lhs).token);
2541 if (token == TokenNameAND) {
2543 if (token == TokenNamenew) {
2544 // | variable '=' '&' T_NEW class_name_reference
2547 SingleTypeReference classRef = class_name_reference();
2549 if (classRef != null) {
2550 if (lhs != null && lhs instanceof FieldReference) {
2552 // $var = & new Object();
2553 if (fMethodVariables != null) {
2554 VariableInfo lhsInfo = new VariableInfo(((FieldReference) lhs).sourceStart());
2555 lhsInfo.reference = classRef;
2556 lhsInfo.typeIdentifier = classRef.token;
2557 fMethodVariables.put(new String(((FieldReference) lhs).token), lhsInfo);
2558 rememberedVar = true;
2563 Expression rhs = variable(false, false);
2564 if (rhs != null && rhs instanceof FieldReference && lhs != null && lhs instanceof FieldReference) {
2567 if (fMethodVariables != null) {
2568 VariableInfo rhsInfo = (VariableInfo) fMethodVariables.get(((FieldReference) rhs).token);
2569 if (rhsInfo != null && rhsInfo.reference != null) {
2570 VariableInfo lhsInfo = new VariableInfo(((FieldReference) lhs).sourceStart());
2571 lhsInfo.reference = rhsInfo.reference;
2572 lhsInfo.typeIdentifier = rhsInfo.typeIdentifier;
2573 fMethodVariables.put(new String(((FieldReference) lhs).token), lhsInfo);
2574 rememberedVar = true;
2580 Expression rhs = expr();
2581 if (lhs != null && lhs instanceof FieldReference) {
2582 if (rhs != null && rhs instanceof FieldReference) {
2585 if (fMethodVariables != null) {
2586 VariableInfo rhsInfo = (VariableInfo) fMethodVariables.get(((FieldReference) rhs).token);
2587 if (rhsInfo != null && rhsInfo.reference != null) {
2588 VariableInfo lhsInfo = new VariableInfo(((FieldReference) lhs).sourceStart());
2589 lhsInfo.reference = rhsInfo.reference;
2590 lhsInfo.typeIdentifier = rhsInfo.typeIdentifier;
2591 fMethodVariables.put(new String(((FieldReference) lhs).token), lhsInfo);
2592 rememberedVar = true;
2595 } else if (rhs != null && rhs instanceof SingleTypeReference) {
2597 // $var = new Object();
2598 if (fMethodVariables != null) {
2599 VariableInfo lhsInfo = new VariableInfo(((FieldReference) lhs).sourceStart());
2600 lhsInfo.reference = (SingleTypeReference) rhs;
2601 lhsInfo.typeIdentifier = ((SingleTypeReference) rhs).token;
2602 fMethodVariables.put(new String(((FieldReference) lhs).token), lhsInfo);
2603 rememberedVar = true;
2608 if (rememberedVar == false && lhs != null && lhs instanceof FieldReference) {
2609 if (fMethodVariables != null) {
2610 VariableInfo lhsInfo = new VariableInfo(((FieldReference) lhs).sourceStart());
2611 fMethodVariables.put(new String(((FieldReference) lhs).token), lhsInfo);
2615 case TokenNamePLUS_EQUAL:
2616 case TokenNameMINUS_EQUAL:
2617 case TokenNameMULTIPLY_EQUAL:
2618 case TokenNameDIVIDE_EQUAL:
2619 case TokenNameDOT_EQUAL:
2620 case TokenNameREMAINDER_EQUAL:
2621 case TokenNameAND_EQUAL:
2622 case TokenNameOR_EQUAL:
2623 case TokenNameXOR_EQUAL:
2624 case TokenNameRIGHT_SHIFT_EQUAL:
2625 case TokenNameLEFT_SHIFT_EQUAL:
2626 if (lhs != null && lhs instanceof FieldReference) {
2627 addVariableSet(((FieldReference) lhs).token);
2632 case TokenNamePLUS_PLUS:
2633 case TokenNameMINUS_MINUS:
2637 if (!only_variable) {
2638 throwSyntaxError("Variable expression not allowed (found token '" + scanner.toStringAction(token) + "').");
2646 if (token != TokenNameINLINE_HTML) {
2647 if (token > TokenNameKEYWORD) {
2651 // System.out.println(scanner.getCurrentTokenStartPosition());
2652 // System.out.println(scanner.getCurrentTokenEndPosition());
2654 throwSyntaxError("Error in expression (found token '" + scanner.toStringAction(token) + "').");
2659 if (Scanner.TRACE) {
2660 System.out.println("TRACE: expr_without_variable() PART 2");
2662 // | expr T_BOOLEAN_OR expr
2663 // | expr T_BOOLEAN_AND expr
2664 // | expr T_LOGICAL_OR expr
2665 // | expr T_LOGICAL_AND expr
2666 // | expr T_LOGICAL_XOR expr
2678 // | expr T_IS_IDENTICAL expr
2679 // | expr T_IS_NOT_IDENTICAL expr
2680 // | expr T_IS_EQUAL expr
2681 // | expr T_IS_NOT_EQUAL expr
2683 // | expr T_IS_SMALLER_OR_EQUAL expr
2685 // | expr T_IS_GREATER_OR_EQUAL expr
2688 case TokenNameOR_OR:
2690 expression = new OR_OR_Expression(expression, expr(), token);
2692 case TokenNameAND_AND:
2694 expression = new AND_AND_Expression(expression, expr(), token);
2696 case TokenNameEQUAL_EQUAL:
2698 expression = new EqualExpression(expression, expr(), token);
2708 case TokenNameMINUS:
2709 case TokenNameMULTIPLY:
2710 case TokenNameDIVIDE:
2711 case TokenNameREMAINDER:
2712 case TokenNameLEFT_SHIFT:
2713 case TokenNameRIGHT_SHIFT:
2714 case TokenNameEQUAL_EQUAL_EQUAL:
2715 case TokenNameNOT_EQUAL_EQUAL:
2716 case TokenNameNOT_EQUAL:
2718 case TokenNameLESS_EQUAL:
2719 case TokenNameGREATER:
2720 case TokenNameGREATER_EQUAL:
2722 expression = new BinaryExpression(expression, expr(), token);
2724 // | expr T_INSTANCEOF class_name_reference
2725 // | expr '?' expr ':' expr
2726 case TokenNameinstanceof:
2728 TypeReference classRef = class_name_reference();
2729 if (classRef != null) {
2730 expression = new InstanceOfExpression(expression, classRef, OperatorIds.INSTANCEOF);
2731 expression.sourceStart = exprSourceStart;
2732 expression.sourceEnd = scanner.getCurrentTokenEndPosition();
2735 case TokenNameQUESTION:
2737 Expression valueIfTrue = expr();
2738 if (token != TokenNameCOLON) {
2739 throwSyntaxError("':' expected in conditional expression.");
2742 Expression valueIfFalse = expr();
2744 expression = new ConditionalExpression(expression, valueIfTrue, valueIfFalse);
2750 } catch (SyntaxError e) {
2751 // try to find next token after expression with errors:
2752 if (token == TokenNameSEMICOLON) {
2756 if (token == TokenNameRBRACE || token == TokenNameRPAREN || token == TokenNameRBRACKET) {
2764 private SingleTypeReference class_name_reference() {
2765 // class_name_reference:
2767 // | dynamic_class_name_reference
2768 SingleTypeReference ref = null;
2769 if (Scanner.TRACE) {
2770 System.out.println("TRACE: class_name_reference()");
2772 if (token == TokenNameIdentifier) {
2773 ref = new SingleTypeReference(scanner.getCurrentIdentifierSource(), scanner.getCurrentTokenStartPosition());
2777 dynamic_class_name_reference();
2782 private void dynamic_class_name_reference() {
2783 // dynamic_class_name_reference:
2784 // base_variable T_OBJECT_OPERATOR object_property
2785 // dynamic_class_name_variable_properties
2787 if (Scanner.TRACE) {
2788 System.out.println("TRACE: dynamic_class_name_reference()");
2791 if (token == TokenNameMINUS_GREATER) {
2794 dynamic_class_name_variable_properties();
2798 private void dynamic_class_name_variable_properties() {
2799 // dynamic_class_name_variable_properties:
2800 // dynamic_class_name_variable_properties
2801 // dynamic_class_name_variable_property
2803 if (Scanner.TRACE) {
2804 System.out.println("TRACE: dynamic_class_name_variable_properties()");
2806 while (token == TokenNameMINUS_GREATER) {
2807 dynamic_class_name_variable_property();
2811 private void dynamic_class_name_variable_property() {
2812 // dynamic_class_name_variable_property:
2813 // T_OBJECT_OPERATOR object_property
2814 if (Scanner.TRACE) {
2815 System.out.println("TRACE: dynamic_class_name_variable_property()");
2817 if (token == TokenNameMINUS_GREATER) {
2823 private void ctor_arguments() {
2826 // | '(' function_call_parameter_list ')'
2827 if (token == TokenNameLPAREN) {
2829 if (token == TokenNameRPAREN) {
2833 non_empty_function_call_parameter_list();
2834 if (token != TokenNameRPAREN) {
2835 throwSyntaxError("')' expected in ctor_arguments.");
2841 private void assignment_list() {
2843 // assignment_list ',' assignment_list_element
2844 // | assignment_list_element
2846 assignment_list_element();
2847 if (token != TokenNameCOMMA) {
2854 private void assignment_list_element() {
2855 // assignment_list_element:
2857 // | T_LIST '(' assignment_list ')'
2859 if (token == TokenNameVariable) {
2860 variable(true, false);
2861 } else if (token == TokenNameDOLLAR) {
2862 variable(false, false);
2864 if (token == TokenNamelist) {
2866 if (token == TokenNameLPAREN) {
2869 if (token != TokenNameRPAREN) {
2870 throwSyntaxError("')' expected after 'list' keyword.");
2874 throwSyntaxError("'(' expected after 'list' keyword.");
2880 private void array_pair_list() {
2883 // | non_empty_array_pair_list possible_comma
2884 non_empty_array_pair_list();
2885 if (token == TokenNameCOMMA) {
2890 private void non_empty_array_pair_list() {
2891 // non_empty_array_pair_list:
2892 // non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr
2893 // | non_empty_array_pair_list ',' expr
2894 // | expr T_DOUBLE_ARROW expr
2896 // | non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_variable
2897 // | non_empty_array_pair_list ',' '&' w_variable
2898 // | expr T_DOUBLE_ARROW '&' w_variable
2901 if (token == TokenNameAND) {
2903 variable(true, false);
2906 if (token == TokenNameAND) {
2908 variable(true, false);
2909 } else if (token == TokenNameEQUAL_GREATER) {
2911 if (token == TokenNameAND) {
2913 variable(true, false);
2919 if (token != TokenNameCOMMA) {
2923 if (token == TokenNameRPAREN) {
2929 // private void variableList() {
2932 // if (token == TokenNameCOMMA) {
2939 private Expression variable_without_objects(boolean lefthandside, boolean ignoreVar) {
2940 // variable_without_objects:
2941 // reference_variable
2942 // | simple_indirect_reference reference_variable
2943 if (Scanner.TRACE) {
2944 System.out.println("TRACE: variable_without_objects()");
2946 while (token == TokenNameDOLLAR) {
2949 return reference_variable(lefthandside, ignoreVar);
2952 private Expression function_call(boolean lefthandside, boolean ignoreVar) {
2954 // T_STRING '(' function_call_parameter_list ')'
2955 // | class_constant '(' function_call_parameter_list ')'
2956 // | static_member '(' function_call_parameter_list ')'
2957 // | variable_without_objects '(' function_call_parameter_list ')'
2958 char[] defineName = null;
2959 char[] ident = null;
2962 Expression ref = null;
2963 if (Scanner.TRACE) {
2964 System.out.println("TRACE: function_call()");
2966 if (token == TokenNameIdentifier) {
2967 ident = scanner.getCurrentIdentifierSource();
2969 startPos = scanner.getCurrentTokenStartPosition();
2970 endPos = scanner.getCurrentTokenEndPosition();
2973 case TokenNamePAAMAYIM_NEKUDOTAYIM:
2977 if (token == TokenNameIdentifier) {
2982 variable_without_objects(true, false);
2987 ref = variable_without_objects(lefthandside, ignoreVar);
2989 if (token != TokenNameLPAREN) {
2990 if (defineName != null) {
2991 // does this identifier contain only uppercase characters?
2992 if (defineName.length == 3) {
2993 if (defineName[0] == 'd' && defineName[1] == 'i' && defineName[2] == 'e') {
2996 } else if (defineName.length == 4) {
2997 if (defineName[0] == 't' && defineName[1] == 'r' && defineName[2] == 'u' && defineName[3] == 'e') {
2999 } else if (defineName[0] == 'n' && defineName[1] == 'u' && defineName[2] == 'l' && defineName[3] == 'l') {
3002 } else if (defineName.length == 5) {
3003 if (defineName[0] == 'f' && defineName[1] == 'a' && defineName[2] == 'l' && defineName[3] == 's' && defineName[4] == 'e') {
3007 if (defineName != null) {
3008 for (int i = 0; i < defineName.length; i++) {
3009 if (Character.isLowerCase(defineName[i])) {
3010 problemReporter.phpUppercaseIdentifierWarning(startPos, endPos, referenceContext, compilationUnit.compilationResult);
3016 // TODO is this ok ?
3018 // throwSyntaxError("'(' expected in function call.");
3021 if (token == TokenNameRPAREN) {
3025 non_empty_function_call_parameter_list();
3026 if (token != TokenNameRPAREN) {
3027 String functionName;
3028 if (ident == null) {
3029 functionName = new String(" ");
3031 functionName = new String(ident);
3033 throwSyntaxError("')' expected in function call (" + functionName + ").");
3039 // private void function_call_parameter_list() {
3040 // function_call_parameter_list:
3041 // non_empty_function_call_parameter_list { $$ = $1; }
3044 private void non_empty_function_call_parameter_list() {
3045 // non_empty_function_call_parameter_list:
3046 // expr_without_variable
3049 // | non_empty_function_call_parameter_list ',' expr_without_variable
3050 // | non_empty_function_call_parameter_list ',' variable
3051 // | non_empty_function_call_parameter_list ',' '&' w_variable
3052 if (Scanner.TRACE) {
3053 System.out.println("TRACE: non_empty_function_call_parameter_list()");
3056 if (token == TokenNameAND) {
3060 // if (token == TokenNameIdentifier || token ==
3061 // TokenNameVariable
3062 // || token == TokenNameDOLLAR) {
3065 expr_without_variable(true);
3068 if (token != TokenNameCOMMA) {
3075 private void fully_qualified_class_name() {
3076 if (token == TokenNameIdentifier) {
3079 throwSyntaxError("Class name expected.");
3083 private void static_member() {
3085 // fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM
3086 // variable_without_objects
3087 if (Scanner.TRACE) {
3088 System.out.println("TRACE: static_member()");
3090 fully_qualified_class_name();
3091 if (token != TokenNamePAAMAYIM_NEKUDOTAYIM) {
3092 throwSyntaxError("'::' expected after class name (static_member).");
3095 variable_without_objects(false, false);
3098 private Expression base_variable_with_function_calls(boolean lefthandside, boolean ignoreVar) {
3099 // base_variable_with_function_calls:
3102 if (Scanner.TRACE) {
3103 System.out.println("TRACE: base_variable_with_function_calls()");
3105 return function_call(lefthandside, ignoreVar);
3108 private Expression base_variable() {
3110 // reference_variable
3111 // | simple_indirect_reference reference_variable
3113 Expression ref = null;
3114 if (Scanner.TRACE) {
3115 System.out.println("TRACE: base_variable()");
3117 if (token == TokenNameIdentifier) {
3120 while (token == TokenNameDOLLAR) {
3123 reference_variable(false, false);
3128 // private void simple_indirect_reference() {
3129 // // simple_indirect_reference:
3131 // //| simple_indirect_reference '$'
3133 private Expression reference_variable(boolean lefthandside, boolean ignoreVar) {
3134 // reference_variable:
3135 // reference_variable '[' dim_offset ']'
3136 // | reference_variable '{' expr '}'
3137 // | compound_variable
3138 Expression ref = null;
3139 if (Scanner.TRACE) {
3140 System.out.println("TRACE: reference_variable()");
3142 ref = compound_variable(lefthandside, ignoreVar);
3144 if (token == TokenNameLBRACE) {
3148 if (token != TokenNameRBRACE) {
3149 throwSyntaxError("'}' expected in reference variable.");
3152 } else if (token == TokenNameLBRACKET) {
3153 if (ref != null && ref instanceof FieldReference) {
3154 FieldReference fref = (FieldReference) ref;
3155 addVariableSet(fref.token);
3159 if (token != TokenNameRBRACKET) {
3162 if (token != TokenNameRBRACKET) {
3163 throwSyntaxError("']' expected in reference variable.");
3174 private Expression compound_variable(boolean lefthandside, boolean ignoreVar) {
3175 // compound_variable:
3177 // | '$' '{' expr '}'
3178 if (Scanner.TRACE) {
3179 System.out.println("TRACE: compound_variable()");
3181 if (token == TokenNameVariable) {
3182 if (!lefthandside) {
3183 if (!containsVariableSet()) {
3184 // reportSyntaxError("The local variable " + new
3185 // String(scanner.getCurrentIdentifierSource())
3186 // + " may not have been initialized");
3187 problemReporter.uninitializedLocalVariable(new String(scanner.getCurrentIdentifierSource()), scanner
3188 .getCurrentTokenStartPosition(), scanner.getCurrentTokenEndPosition(), referenceContext,
3189 compilationUnit.compilationResult);
3196 FieldReference ref = new FieldReference(scanner.getCurrentIdentifierSource(), scanner.getCurrentTokenStartPosition());
3200 // because of simple_indirect_reference
3201 while (token == TokenNameDOLLAR) {
3204 if (token != TokenNameLBRACE) {
3205 reportSyntaxError("'{' expected after compound variable token '$'.");
3210 if (token != TokenNameRBRACE) {
3211 throwSyntaxError("'}' expected after compound variable token '$'.");
3216 } // private void dim_offset() { // // dim_offset: // // /* empty */
3221 private void object_property() {
3224 // | variable_without_objects
3225 if (Scanner.TRACE) {
3226 System.out.println("TRACE: object_property()");
3228 if (token == TokenNameVariable || token == TokenNameDOLLAR) {
3229 variable_without_objects(false, false);
3235 private void object_dim_list() {
3237 // object_dim_list '[' dim_offset ']'
3238 // | object_dim_list '{' expr '}'
3240 if (Scanner.TRACE) {
3241 System.out.println("TRACE: object_dim_list()");
3245 if (token == TokenNameLBRACE) {
3248 if (token != TokenNameRBRACE) {
3249 throwSyntaxError("'}' expected in object_dim_list.");
3252 } else if (token == TokenNameLBRACKET) {
3254 if (token == TokenNameRBRACKET) {
3259 if (token != TokenNameRBRACKET) {
3260 throwSyntaxError("']' expected in object_dim_list.");
3269 private void variable_name() {
3273 if (Scanner.TRACE) {
3274 System.out.println("TRACE: variable_name()");
3276 if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
3277 if (token > TokenNameKEYWORD) {
3278 // TODO show a warning "Keyword used as variable" ?
3282 if (token != TokenNameLBRACE) {
3283 throwSyntaxError("'{' expected in variable name.");
3287 if (token != TokenNameRBRACE) {
3288 throwSyntaxError("'}' expected in variable name.");
3294 private void r_variable() {
3295 variable(false, false);
3298 private void w_variable(boolean lefthandside) {
3299 variable(lefthandside, false);
3302 private void rw_variable() {
3303 variable(false, false);
3306 private Expression variable(boolean lefthandside, boolean ignoreVar) {
3308 // base_variable_with_function_calls T_OBJECT_OPERATOR
3309 // object_property method_or_not variable_properties
3310 // | base_variable_with_function_calls
3311 Expression ref = base_variable_with_function_calls(lefthandside, ignoreVar);
3312 if (token == TokenNameMINUS_GREATER) {
3317 variable_properties();
3322 private void variable_properties() {
3323 // variable_properties:
3324 // variable_properties variable_property
3326 while (token == TokenNameMINUS_GREATER) {
3327 variable_property();
3331 private void variable_property() {
3332 // variable_property:
3333 // T_OBJECT_OPERATOR object_property method_or_not
3334 if (Scanner.TRACE) {
3335 System.out.println("TRACE: variable_property()");
3337 if (token == TokenNameMINUS_GREATER) {
3342 throwSyntaxError("'->' expected in variable_property.");
3346 private Expression identifier(boolean lefthandside, boolean ignoreVar) {
3348 // base_variable_with_function_calls T_OBJECT_OPERATOR
3349 // object_property method_or_not variable_properties
3350 // | base_variable_with_function_calls
3352 // Expression ref = function_call(lefthandside, ignoreVar);
3355 // T_STRING '(' function_call_parameter_list ')'
3356 // | class_constant '(' function_call_parameter_list ')'
3357 // | static_member '(' function_call_parameter_list ')'
3358 // | variable_without_objects '(' function_call_parameter_list ')'
3359 char[] defineName = null;
3360 char[] ident = null;
3363 Expression ref = null;
3364 if (Scanner.TRACE) {
3365 System.out.println("TRACE: function_call()");
3367 if (token == TokenNameIdentifier) {
3368 ident = scanner.getCurrentIdentifierSource();
3370 startPos = scanner.getCurrentTokenStartPosition();
3371 endPos = scanner.getCurrentTokenEndPosition();
3374 if (token == TokenNameEQUAL || token == TokenNamePLUS_EQUAL || token == TokenNameMINUS_EQUAL
3375 || token == TokenNameMULTIPLY_EQUAL || token == TokenNameDIVIDE_EQUAL || token == TokenNameDOT_EQUAL
3376 || token == TokenNameREMAINDER_EQUAL || token == TokenNameAND_EQUAL || token == TokenNameOR_EQUAL
3377 || token == TokenNameXOR_EQUAL || token == TokenNameRIGHT_SHIFT_EQUAL || token == TokenNameLEFT_SHIFT_EQUAL) {
3378 String error = "Assignment operator '" + scanner.toStringAction(token) + "' not allowed after identifier '"
3379 + new String(ident) + "' (use 'define(...)' to define constants).";
3380 reportSyntaxError(error);
3384 case TokenNamePAAMAYIM_NEKUDOTAYIM:
3388 if (token == TokenNameIdentifier) {
3393 variable_without_objects(true, false);
3398 ref = variable_without_objects(lefthandside, ignoreVar);
3400 if (token != TokenNameLPAREN) {
3401 if (defineName != null) {
3402 // does this identifier contain only uppercase characters?
3403 if (defineName.length == 3) {
3404 if (defineName[0] == 'd' && defineName[1] == 'i' && defineName[2] == 'e') {
3407 } else if (defineName.length == 4) {
3408 if (defineName[0] == 't' && defineName[1] == 'r' && defineName[2] == 'u' && defineName[3] == 'e') {
3410 } else if (defineName[0] == 'n' && defineName[1] == 'u' && defineName[2] == 'l' && defineName[3] == 'l') {
3413 } else if (defineName.length == 5) {
3414 if (defineName[0] == 'f' && defineName[1] == 'a' && defineName[2] == 'l' && defineName[3] == 's' && defineName[4] == 'e') {
3418 if (defineName != null) {
3419 for (int i = 0; i < defineName.length; i++) {
3420 if (Character.isLowerCase(defineName[i])) {
3421 problemReporter.phpUppercaseIdentifierWarning(startPos, endPos, referenceContext, compilationUnit.compilationResult);
3427 // TODO is this ok ?
3429 // throwSyntaxError("'(' expected in function call.");
3433 if (token == TokenNameRPAREN) {
3437 non_empty_function_call_parameter_list();
3438 if (token != TokenNameRPAREN) {
3439 String functionName;
3440 if (ident == null) {
3441 functionName = new String(" ");
3443 functionName = new String(ident);
3445 throwSyntaxError("')' expected in function call (" + functionName + ").");
3450 if (token == TokenNameMINUS_GREATER) {
3455 variable_properties();
3460 private void method_or_not() {
3462 // '(' function_call_parameter_list ')'
3464 if (Scanner.TRACE) {
3465 System.out.println("TRACE: method_or_not()");
3467 if (token == TokenNameLPAREN) {
3469 if (token == TokenNameRPAREN) {
3473 non_empty_function_call_parameter_list();
3474 if (token != TokenNameRPAREN) {
3475 throwSyntaxError("')' expected in method_or_not.");
3481 private void exit_expr() {
3485 if (token != TokenNameLPAREN) {
3489 if (token == TokenNameRPAREN) {
3494 if (token != TokenNameRPAREN) {
3495 throwSyntaxError("')' expected after keyword 'exit'");
3500 // private void encaps_list() {
3501 // // encaps_list encaps_var
3502 // // | encaps_list T_STRING
3503 // // | encaps_list T_NUM_STRING
3504 // // | encaps_list T_ENCAPSED_AND_WHITESPACE
3505 // // | encaps_list T_CHARACTER
3506 // // | encaps_list T_BAD_CHARACTER
3507 // // | encaps_list '['
3508 // // | encaps_list ']'
3509 // // | encaps_list '{'
3510 // // | encaps_list '}'
3511 // // | encaps_list T_OBJECT_OPERATOR
3515 // case TokenNameSTRING:
3518 // case TokenNameLBRACE:
3519 // // scanner.encapsedStringStack.pop();
3522 // case TokenNameRBRACE:
3523 // // scanner.encapsedStringStack.pop();
3526 // case TokenNameLBRACKET:
3527 // // scanner.encapsedStringStack.pop();
3530 // case TokenNameRBRACKET:
3531 // // scanner.encapsedStringStack.pop();
3534 // case TokenNameMINUS_GREATER:
3535 // // scanner.encapsedStringStack.pop();
3538 // case TokenNameVariable:
3539 // case TokenNameDOLLAR_LBRACE:
3540 // case TokenNameLBRACE_DOLLAR:
3544 // char encapsedChar = ((Character)
3545 // scanner.encapsedStringStack.peek()).charValue();
3546 // if (encapsedChar == '$') {
3547 // scanner.encapsedStringStack.pop();
3548 // encapsedChar = ((Character)
3549 // scanner.encapsedStringStack.peek()).charValue();
3550 // switch (encapsedChar) {
3552 // if (token == TokenNameEncapsedString0) {
3555 // token = TokenNameSTRING;
3558 // if (token == TokenNameEncapsedString1) {
3561 // token = TokenNameSTRING;
3564 // if (token == TokenNameEncapsedString2) {
3567 // token = TokenNameSTRING;
3576 // private void encaps_var() {
3578 // // | T_VARIABLE '[' encaps_var_offset ']'
3579 // // | T_VARIABLE T_OBJECT_OPERATOR T_STRING
3580 // // | T_DOLLAR_OPEN_CURLY_BRACES expr '}'
3581 // // | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}'
3582 // // | T_CURLY_OPEN variable '}'
3584 // case TokenNameVariable:
3586 // if (token == TokenNameLBRACKET) {
3588 // expr(); //encaps_var_offset();
3589 // if (token != TokenNameRBRACKET) {
3590 // throwSyntaxError("']' expected after variable.");
3592 // // scanner.encapsedStringStack.pop();
3595 // } else if (token == TokenNameMINUS_GREATER) {
3597 // if (token != TokenNameIdentifier) {
3598 // throwSyntaxError("Identifier expected after '->'.");
3600 // // scanner.encapsedStringStack.pop();
3604 // // // scanner.encapsedStringStack.pop();
3605 // // int tempToken = TokenNameSTRING;
3606 // // if (!scanner.encapsedStringStack.isEmpty()
3607 // // && (token == TokenNameEncapsedString0
3608 // // || token == TokenNameEncapsedString1
3609 // // || token == TokenNameEncapsedString2 || token ==
3610 // // TokenNameERROR)) {
3611 // // char encapsedChar = ((Character)
3612 // // scanner.encapsedStringStack.peek())
3614 // // switch (token) {
3615 // // case TokenNameEncapsedString0 :
3616 // // if (encapsedChar == '`') {
3617 // // tempToken = TokenNameEncapsedString0;
3620 // // case TokenNameEncapsedString1 :
3621 // // if (encapsedChar == '\'') {
3622 // // tempToken = TokenNameEncapsedString1;
3625 // // case TokenNameEncapsedString2 :
3626 // // if (encapsedChar == '"') {
3627 // // tempToken = TokenNameEncapsedString2;
3630 // // case TokenNameERROR :
3631 // // if (scanner.source[scanner.currentPosition - 1] == '\\') {
3632 // // scanner.currentPosition--;
3633 // // getNextToken();
3638 // // token = tempToken;
3641 // case TokenNameDOLLAR_LBRACE:
3643 // if (token == TokenNameDOLLAR_LBRACE) {
3645 // } else if (token == TokenNameIdentifier) {
3647 // if (token == TokenNameLBRACKET) {
3649 // // if (token == TokenNameRBRACKET) {
3650 // // getNextToken();
3653 // if (token != TokenNameRBRACKET) {
3654 // throwSyntaxError("']' expected after '${'.");
3662 // if (token != TokenNameRBRACE) {
3663 // throwSyntaxError("'}' expected.");
3667 // case TokenNameLBRACE_DOLLAR:
3669 // if (token == TokenNameLBRACE_DOLLAR) {
3671 // } else if (token == TokenNameIdentifier || token > TokenNameKEYWORD) {
3673 // if (token == TokenNameLBRACKET) {
3675 // // if (token == TokenNameRBRACKET) {
3676 // // getNextToken();
3679 // if (token != TokenNameRBRACKET) {
3680 // throwSyntaxError("']' expected.");
3684 // } else if (token == TokenNameMINUS_GREATER) {
3686 // if (token != TokenNameIdentifier && token != TokenNameVariable) {
3687 // throwSyntaxError("String or Variable token expected.");
3690 // if (token == TokenNameLBRACKET) {
3692 // // if (token == TokenNameRBRACKET) {
3693 // // getNextToken();
3696 // if (token != TokenNameRBRACKET) {
3697 // throwSyntaxError("']' expected after '${'.");
3703 // // if (token != TokenNameRBRACE) {
3704 // // throwSyntaxError("'}' expected after '{$'.");
3706 // // // scanner.encapsedStringStack.pop();
3707 // // getNextToken();
3710 // if (token != TokenNameRBRACE) {
3711 // throwSyntaxError("'}' expected.");
3713 // // scanner.encapsedStringStack.pop();
3720 // private void encaps_var_offset() {
3722 // // | T_NUM_STRING
3725 // case TokenNameSTRING:
3728 // case TokenNameIntegerLiteral:
3731 // case TokenNameVariable:
3734 // case TokenNameIdentifier:
3738 // throwSyntaxError("Variable or String token expected.");
3743 private void internal_functions_in_yacc() {
3746 // case TokenNameisset:
3747 // // T_ISSET '(' isset_variables ')'
3749 // if (token != TokenNameLPAREN) {
3750 // throwSyntaxError("'(' expected after keyword 'isset'");
3753 // isset_variables();
3754 // if (token != TokenNameRPAREN) {
3755 // throwSyntaxError("')' expected after keyword 'isset'");
3759 // case TokenNameempty:
3760 // // T_EMPTY '(' variable ')'
3762 // if (token != TokenNameLPAREN) {
3763 // throwSyntaxError("'(' expected after keyword 'empty'");
3767 // if (token != TokenNameRPAREN) {
3768 // throwSyntaxError("')' expected after keyword 'empty'");
3772 case TokenNameinclude:
3774 checkFileName(token);
3776 case TokenNameinclude_once:
3777 // T_INCLUDE_ONCE expr
3778 checkFileName(token);
3781 // T_EVAL '(' expr ')'
3783 if (token != TokenNameLPAREN) {
3784 throwSyntaxError("'(' expected after keyword 'eval'");
3788 if (token != TokenNameRPAREN) {
3789 throwSyntaxError("')' expected after keyword 'eval'");
3793 case TokenNamerequire:
3795 checkFileName(token);
3797 case TokenNamerequire_once:
3798 // T_REQUIRE_ONCE expr
3799 checkFileName(token);
3805 * Parse and check the include file name
3807 * @param includeToken
3809 private void checkFileName(int includeToken) {
3810 // <include-token> expr
3811 int start = scanner.getCurrentTokenStartPosition();
3812 boolean hasLPAREN = false;
3814 if (token == TokenNameLPAREN) {
3818 Expression expression = expr();
3820 if (token == TokenNameRPAREN) {
3823 throwSyntaxError("')' expected for keyword '" + scanner.toStringAction(includeToken) + "'");
3826 char[] currTokenSource = scanner.getCurrentTokenSource(start);
3828 if (scanner.compilationUnit != null) {
3829 IResource resource = scanner.compilationUnit.getResource();
3830 if (resource != null && resource instanceof IFile) {
3831 file = (IFile) resource;
3835 tokens = new char[1][];
3836 tokens[0] = currTokenSource;
3838 ImportReference impt = new ImportReference(tokens, currTokenSource, start, scanner.getCurrentTokenEndPosition(), false);
3839 impt.declarationSourceEnd = impt.sourceEnd;
3840 impt.declarationEnd = impt.declarationSourceEnd;
3841 // endPosition is just before the ;
3842 impt.declarationSourceStart = start;
3843 includesList.add(impt);
3845 if (expression instanceof StringLiteral) {
3846 StringLiteral literal = (StringLiteral) expression;
3847 char[] includeName = literal.source();
3848 if (includeName.length == 0) {
3849 reportSyntaxError("Empty filename after keyword '" + scanner.toStringAction(includeToken) + "'", literal.sourceStart,
3850 literal.sourceStart + 1);
3852 String includeNameString = new String(includeName);
3853 if (literal instanceof StringLiteralDQ) {
3854 if (includeNameString.indexOf('$') >= 0) {
3855 // assuming that the filename contains a variable => no filename check
3859 if (includeNameString.startsWith("http://")) {
3860 // assuming external include location
3864 // check the filename:
3865 // System.out.println(new String(compilationUnit.getFileName())+" - "+
3866 // expression.toStringExpression());
3867 IProject project = file.getProject();
3868 if (project != null) {
3869 IPath path = PHPFileUtil.determineFilePath(includeNameString, file, project);
3872 // SyntaxError: "File: << >> doesn't exist in project."
3873 String[] args = { expression.toStringExpression(), project.getLocation().toString() };
3874 problemReporter.phpIncludeNotExistWarning(args, literal.sourceStart, literal.sourceEnd, referenceContext,
3875 compilationUnit.compilationResult);
3878 String filePath = path.toString();
3879 String ext = file.getRawLocation().getFileExtension();
3880 int fileExtensionLength = ext == null ? 0 : ext.length() + 1;
3882 impt.tokens = CharOperation.splitOn('/', filePath.toCharArray(), 0, filePath.length() - fileExtensionLength);
3883 impt.setFile(PHPFileUtil.createFile(path, project));
3884 } catch (Exception e) {
3885 // the file is outside of the workspace
3893 private void isset_variables() {
3895 // | isset_variables ','
3896 if (token == TokenNameRPAREN) {
3897 throwSyntaxError("Variable expected after keyword 'isset'");
3900 variable(true, false);
3901 if (token == TokenNameCOMMA) {
3909 private boolean common_scalar() {
3913 // | T_CONSTANT_ENCAPSED_STRING
3920 case TokenNameIntegerLiteral:
3923 case TokenNameDoubleLiteral:
3926 case TokenNameStringDoubleQuote:
3929 case TokenNameStringSingleQuote:
3932 case TokenNameStringInterpolated:
3941 case TokenNameCLASS_C:
3944 case TokenNameMETHOD_C:
3947 case TokenNameFUNC_C:
3954 private void scalar() {
3957 // | T_STRING_VARNAME
3960 // | '"' encaps_list '"'
3961 // | '\'' encaps_list '\''
3962 // | T_START_HEREDOC encaps_list T_END_HEREDOC
3963 throwSyntaxError("Not yet implemented (scalar).");
3966 private void static_scalar() {
3967 // static_scalar: /* compile-time evaluated scalars */
3970 // | '+' static_scalar
3971 // | '-' static_scalar
3972 // | T_ARRAY '(' static_array_pair_list ')'
3973 // | static_class_constant
3974 if (common_scalar()) {
3978 case TokenNameIdentifier:
3980 // static_class_constant:
3981 // T_STRING T_PAAMAYIM_NEKUDOTAYIM T_STRING
3982 if (token == TokenNamePAAMAYIM_NEKUDOTAYIM) {
3984 if (token == TokenNameIdentifier) {
3987 throwSyntaxError("Identifier expected after '::' operator.");
3991 case TokenNameEncapsedString0:
3993 scanner.currentCharacter = scanner.source[scanner.currentPosition++];
3994 while (scanner.currentCharacter != '`') {
3995 if (scanner.currentCharacter == '\\') {
3996 scanner.currentPosition++;
3998 scanner.currentCharacter = scanner.source[scanner.currentPosition++];
4001 } catch (IndexOutOfBoundsException e) {
4002 throwSyntaxError("'`' expected at end of static string.");
4005 // case TokenNameEncapsedString1:
4007 // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
4008 // while (scanner.currentCharacter != '\'') {
4009 // if (scanner.currentCharacter == '\\') {
4010 // scanner.currentPosition++;
4012 // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
4015 // } catch (IndexOutOfBoundsException e) {
4016 // throwSyntaxError("'\'' expected at end of static string.");
4019 // case TokenNameEncapsedString2:
4021 // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
4022 // while (scanner.currentCharacter != '"') {
4023 // if (scanner.currentCharacter == '\\') {
4024 // scanner.currentPosition++;
4026 // scanner.currentCharacter = scanner.source[scanner.currentPosition++];
4029 // } catch (IndexOutOfBoundsException e) {
4030 // throwSyntaxError("'\"' expected at end of static string.");
4033 case TokenNameStringSingleQuote:
4036 case TokenNameStringDoubleQuote:
4043 case TokenNameMINUS:
4047 case TokenNamearray:
4049 if (token != TokenNameLPAREN) {
4050 throwSyntaxError("'(' expected after keyword 'array'");
4053 if (token == TokenNameRPAREN) {
4057 non_empty_static_array_pair_list();
4058 if (token != TokenNameRPAREN) {
4059 throwSyntaxError("')' or ',' expected after keyword 'array'");
4063 // case TokenNamenull :
4066 // case TokenNamefalse :
4069 // case TokenNametrue :
4073 throwSyntaxError("Static scalar/constant expected.");
4077 private void non_empty_static_array_pair_list() {
4078 // non_empty_static_array_pair_list:
4079 // non_empty_static_array_pair_list ',' static_scalar T_DOUBLE_ARROW
4081 // | non_empty_static_array_pair_list ',' static_scalar
4082 // | static_scalar T_DOUBLE_ARROW static_scalar
4086 if (token == TokenNameEQUAL_GREATER) {
4090 if (token != TokenNameCOMMA) {
4094 if (token == TokenNameRPAREN) {
4100 // public void reportSyntaxError() { //int act, int currentKind, int
4101 // // stateStackTop) {
4102 // /* remember current scanner position */
4103 // int startPos = scanner.startPosition;
4104 // int currentPos = scanner.currentPosition;
4106 // this.checkAndReportBracketAnomalies(problemReporter());
4107 // /* reset scanner where it was */
4108 // scanner.startPosition = startPos;
4109 // scanner.currentPosition = currentPos;
4112 public static final int RoundBracket = 0;
4114 public static final int SquareBracket = 1;
4116 public static final int CurlyBracket = 2;
4118 public static final int BracketKinds = 3;
4120 protected int[] nestedMethod; // the ptr is nestedType
4122 protected int nestedType, dimensions;
4124 // variable set stack
4125 final static int VariableStackIncrement = 10;
4127 HashMap fTypeVariables = null;
4129 HashMap fMethodVariables = null;
4131 ArrayList fStackUnassigned = new ArrayList();
4134 final static int AstStackIncrement = 100;
4136 protected int astPtr;
4138 protected ASTNode[] astStack = new ASTNode[AstStackIncrement];
4140 protected int astLengthPtr;
4142 protected int[] astLengthStack;
4144 ASTNode[] noAstNodes = new ASTNode[AstStackIncrement];
4146 public CompilationUnitDeclaration compilationUnit; /*
4147 * the result from parse()
4150 protected ReferenceContext referenceContext;
4152 protected ProblemReporter problemReporter;
4154 protected CompilerOptions options;
4156 private ArrayList includesList;
4158 // protected CompilationResult compilationResult;
4160 * Returns this parser's problem reporter initialized with its reference
4161 * context. Also it is assumed that a problem is going to be reported, so
4162 * initializes the compilation result's line positions.
4164 public ProblemReporter problemReporter() {
4165 if (scanner.recordLineSeparator) {
4166 compilationUnit.compilationResult.lineSeparatorPositions = scanner.getLineEnds();
4168 problemReporter.referenceContext = referenceContext;
4169 return problemReporter;
4173 * Reconsider the entire source looking for inconsistencies in {} () []
4175 // public boolean checkAndReportBracketAnomalies(ProblemReporter
4176 // problemReporter) {
4177 // scanner.wasAcr = false;
4178 // boolean anomaliesDetected = false;
4180 // char[] source = scanner.source;
4181 // int[] leftCount = { 0, 0, 0 };
4182 // int[] rightCount = { 0, 0, 0 };
4183 // int[] depths = { 0, 0, 0 };
4184 // int[][] leftPositions = new int[][] { new int[10], new int[10], new int[10]
4186 // int[][] leftDepths = new int[][] { new int[10], new int[10], new int[10] };
4187 // int[][] rightPositions = new int[][] { new int[10], new int[10], new
4189 // int[][] rightDepths = new int[][] { new int[10], new int[10], new int[10]
4191 // scanner.currentPosition = scanner.initialPosition; //starting
4193 // // (first-zero-based
4195 // while (scanner.currentPosition < scanner.eofPosition) { //loop for
4200 // // ---------Consume white space and handles
4201 // // startPosition---------
4202 // boolean isWhiteSpace;
4204 // scanner.startPosition = scanner.currentPosition;
4205 // // if (((scanner.currentCharacter =
4206 // // source[scanner.currentPosition++]) == '\\') &&
4207 // // (source[scanner.currentPosition] == 'u')) {
4208 // // isWhiteSpace = scanner.jumpOverUnicodeWhiteSpace();
4210 // if (scanner.recordLineSeparator && ((scanner.currentCharacter == '\r') ||
4211 // (scanner.currentCharacter == '\n'))) {
4212 // if (scanner.lineEnds[scanner.linePtr] < scanner.startPosition) {
4213 // // only record line positions we have not
4215 // scanner.pushLineSeparator();
4218 // isWhiteSpace = CharOperation.isWhitespace(scanner.currentCharacter);
4220 // } while (isWhiteSpace && (scanner.currentPosition < scanner.eofPosition));
4221 // // -------consume token until } is found---------
4222 // switch (scanner.currentCharacter) {
4224 // int index = leftCount[CurlyBracket]++;
4225 // if (index == leftPositions[CurlyBracket].length) {
4226 // System.arraycopy(leftPositions[CurlyBracket], 0,
4227 // (leftPositions[CurlyBracket] = new int[index * 2]), 0, index);
4228 // System.arraycopy(leftDepths[CurlyBracket], 0, (leftDepths[CurlyBracket] =
4229 // new int[index * 2]), 0, index);
4231 // leftPositions[CurlyBracket][index] = scanner.startPosition;
4232 // leftDepths[CurlyBracket][index] = depths[CurlyBracket]++;
4236 // int index = rightCount[CurlyBracket]++;
4237 // if (index == rightPositions[CurlyBracket].length) {
4238 // System.arraycopy(rightPositions[CurlyBracket], 0,
4239 // (rightPositions[CurlyBracket] = new int[index * 2]), 0, index);
4240 // System.arraycopy(rightDepths[CurlyBracket], 0, (rightDepths[CurlyBracket] =
4241 // new int[index * 2]), 0, index);
4243 // rightPositions[CurlyBracket][index] = scanner.startPosition;
4244 // rightDepths[CurlyBracket][index] = --depths[CurlyBracket];
4248 // int index = leftCount[RoundBracket]++;
4249 // if (index == leftPositions[RoundBracket].length) {
4250 // System.arraycopy(leftPositions[RoundBracket], 0,
4251 // (leftPositions[RoundBracket] = new int[index * 2]), 0, index);
4252 // System.arraycopy(leftDepths[RoundBracket], 0, (leftDepths[RoundBracket] =
4253 // new int[index * 2]), 0, index);
4255 // leftPositions[RoundBracket][index] = scanner.startPosition;
4256 // leftDepths[RoundBracket][index] = depths[RoundBracket]++;
4260 // int index = rightCount[RoundBracket]++;
4261 // if (index == rightPositions[RoundBracket].length) {
4262 // System.arraycopy(rightPositions[RoundBracket], 0,
4263 // (rightPositions[RoundBracket] = new int[index * 2]), 0, index);
4264 // System.arraycopy(rightDepths[RoundBracket], 0, (rightDepths[RoundBracket] =
4265 // new int[index * 2]), 0, index);
4267 // rightPositions[RoundBracket][index] = scanner.startPosition;
4268 // rightDepths[RoundBracket][index] = --depths[RoundBracket];
4272 // int index = leftCount[SquareBracket]++;
4273 // if (index == leftPositions[SquareBracket].length) {
4274 // System.arraycopy(leftPositions[SquareBracket], 0,
4275 // (leftPositions[SquareBracket] = new int[index * 2]), 0, index);
4276 // System.arraycopy(leftDepths[SquareBracket], 0, (leftDepths[SquareBracket] =
4277 // new int[index * 2]), 0, index);
4279 // leftPositions[SquareBracket][index] = scanner.startPosition;
4280 // leftDepths[SquareBracket][index] = depths[SquareBracket]++;
4284 // int index = rightCount[SquareBracket]++;
4285 // if (index == rightPositions[SquareBracket].length) {
4286 // System.arraycopy(rightPositions[SquareBracket], 0,
4287 // (rightPositions[SquareBracket] = new int[index * 2]), 0, index);
4288 // System.arraycopy(rightDepths[SquareBracket], 0, (rightDepths[SquareBracket]
4289 // = new int[index * 2]), 0, index);
4291 // rightPositions[SquareBracket][index] = scanner.startPosition;
4292 // rightDepths[SquareBracket][index] = --depths[SquareBracket];
4296 // if (scanner.getNextChar('\\')) {
4297 // scanner.scanEscapeCharacter();
4298 // } else { // consume next character
4299 // scanner.unicodeAsBackSlash = false;
4300 // // if (((scanner.currentCharacter =
4301 // // source[scanner.currentPosition++]) ==
4303 // // (source[scanner.currentPosition] ==
4305 // // scanner.getNextUnicodeChar();
4307 // if (scanner.withoutUnicodePtr != 0) {
4308 // scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] =
4309 // scanner.currentCharacter;
4313 // scanner.getNextChar('\'');
4317 // // consume next character
4318 // scanner.unicodeAsBackSlash = false;
4319 // // if (((scanner.currentCharacter =
4320 // // source[scanner.currentPosition++]) == '\\') &&
4321 // // (source[scanner.currentPosition] == 'u')) {
4322 // // scanner.getNextUnicodeChar();
4324 // if (scanner.withoutUnicodePtr != 0) {
4325 // scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] =
4326 // scanner.currentCharacter;
4329 // while (scanner.currentCharacter != '"') {
4330 // if (scanner.currentCharacter == '\r') {
4331 // if (source[scanner.currentPosition] == '\n')
4332 // scanner.currentPosition++;
4333 // break; // the string cannot go further that
4336 // if (scanner.currentCharacter == '\n') {
4337 // break; // the string cannot go further that
4340 // if (scanner.currentCharacter == '\\') {
4341 // scanner.scanEscapeCharacter();
4343 // // consume next character
4344 // scanner.unicodeAsBackSlash = false;
4345 // // if (((scanner.currentCharacter =
4346 // // source[scanner.currentPosition++]) == '\\')
4347 // // && (source[scanner.currentPosition] == 'u'))
4349 // // scanner.getNextUnicodeChar();
4351 // if (scanner.withoutUnicodePtr != 0) {
4352 // scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] =
4353 // scanner.currentCharacter;
4360 // if ((test = scanner.getNextChar('/', '*')) == 0) { //line
4362 // //get the next char
4363 // if (((scanner.currentCharacter = source[scanner.currentPosition++]) ==
4365 // && (source[scanner.currentPosition] == 'u')) {
4366 // //-------------unicode traitement
4368 // int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
4369 // scanner.currentPosition++;
4370 // while (source[scanner.currentPosition] == 'u') {
4371 // scanner.currentPosition++;
4373 // if ((c1 = Character.getNumericValue(source[scanner.currentPosition++])) >
4375 // || (c2 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4377 // || (c3 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4379 // || (c4 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4380 // || c4 < 0) { //error
4384 // scanner.currentCharacter = 'A';
4385 // } //something different from \n and \r
4387 // scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
4390 // while (scanner.currentCharacter != '\r' && scanner.currentCharacter !=
4392 // //get the next char
4393 // scanner.startPosition = scanner.currentPosition;
4394 // if (((scanner.currentCharacter = source[scanner.currentPosition++]) ==
4396 // && (source[scanner.currentPosition] == 'u')) {
4397 // //-------------unicode traitement
4399 // int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
4400 // scanner.currentPosition++;
4401 // while (source[scanner.currentPosition] == 'u') {
4402 // scanner.currentPosition++;
4404 // if ((c1 = Character.getNumericValue(source[scanner.currentPosition++])) >
4406 // || (c2 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4408 // || (c3 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4410 // || (c4 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4411 // || c4 < 0) { //error
4415 // scanner.currentCharacter = 'A';
4416 // } //something different from \n
4419 // scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
4423 // if (scanner.recordLineSeparator && ((scanner.currentCharacter == '\r') ||
4424 // (scanner.currentCharacter == '\n'))) {
4425 // if (scanner.lineEnds[scanner.linePtr] < scanner.startPosition) {
4426 // // only record line positions we
4427 // // have not recorded yet
4428 // scanner.pushLineSeparator();
4429 // if (this.scanner.taskTags != null) {
4430 // this.scanner.checkTaskTag(this.scanner.getCurrentTokenStartPosition(),
4432 // .getCurrentTokenEndPosition());
4438 // if (test > 0) { //traditional and annotation
4440 // boolean star = false;
4441 // // consume next character
4442 // scanner.unicodeAsBackSlash = false;
4443 // // if (((scanner.currentCharacter =
4444 // // source[scanner.currentPosition++]) ==
4446 // // (source[scanner.currentPosition] ==
4448 // // scanner.getNextUnicodeChar();
4450 // if (scanner.withoutUnicodePtr != 0) {
4451 // scanner.withoutUnicodeBuffer[++scanner.withoutUnicodePtr] =
4452 // scanner.currentCharacter;
4455 // if (scanner.currentCharacter == '*') {
4458 // //get the next char
4459 // if (((scanner.currentCharacter = source[scanner.currentPosition++]) ==
4461 // && (source[scanner.currentPosition] == 'u')) {
4462 // //-------------unicode traitement
4464 // int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
4465 // scanner.currentPosition++;
4466 // while (source[scanner.currentPosition] == 'u') {
4467 // scanner.currentPosition++;
4469 // if ((c1 = Character.getNumericValue(source[scanner.currentPosition++])) >
4471 // || (c2 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4473 // || (c3 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4475 // || (c4 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4476 // || c4 < 0) { //error
4480 // scanner.currentCharacter = 'A';
4481 // } //something different from * and /
4483 // scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
4486 // //loop until end of comment */
4487 // while ((scanner.currentCharacter != '/') || (!star)) {
4488 // star = scanner.currentCharacter == '*';
4490 // if (((scanner.currentCharacter = source[scanner.currentPosition++]) ==
4492 // && (source[scanner.currentPosition] == 'u')) {
4493 // //-------------unicode traitement
4495 // int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
4496 // scanner.currentPosition++;
4497 // while (source[scanner.currentPosition] == 'u') {
4498 // scanner.currentPosition++;
4500 // if ((c1 = Character.getNumericValue(source[scanner.currentPosition++])) >
4502 // || (c2 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4504 // || (c3 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4506 // || (c4 = Character.getNumericValue(source[scanner.currentPosition++])) > 15
4507 // || c4 < 0) { //error
4511 // scanner.currentCharacter = 'A';
4512 // } //something different from * and
4515 // scanner.currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
4519 // if (this.scanner.taskTags != null) {
4520 // this.scanner.checkTaskTag(this.scanner.getCurrentTokenStartPosition(),
4521 // this.scanner.getCurrentTokenEndPosition());
4528 // if (Scanner.isPHPIdentifierStart(scanner.currentCharacter)) {
4529 // scanner.scanIdentifierOrKeyword(false);
4532 // if (Character.isDigit(scanner.currentCharacter)) {
4533 // scanner.scanNumber(false);
4537 // //-----------------end switch while
4538 // // try--------------------
4539 // } catch (IndexOutOfBoundsException e) {
4540 // break; // read until EOF
4541 // } catch (InvalidInputException e) {
4542 // return false; // no clue
4545 // if (scanner.recordLineSeparator) {
4546 // compilationUnit.compilationResult.lineSeparatorPositions =
4547 // scanner.getLineEnds();
4549 // // check placement anomalies against other kinds of brackets
4550 // for (int kind = 0; kind < BracketKinds; kind++) {
4551 // for (int leftIndex = leftCount[kind] - 1; leftIndex >= 0; leftIndex--) {
4552 // int start = leftPositions[kind][leftIndex]; // deepest
4554 // // find matching closing bracket
4555 // int depth = leftDepths[kind][leftIndex];
4557 // for (int i = 0; i < rightCount[kind]; i++) {
4558 // int pos = rightPositions[kind][i];
4559 // // want matching bracket further in source with same
4561 // if ((pos > start) && (depth == rightDepths[kind][i])) {
4566 // if (end < 0) { // did not find a good closing match
4567 // problemReporter.unmatchedBracket(start, referenceContext,
4568 // compilationUnit.compilationResult);
4571 // // check if even number of opening/closing other brackets
4572 // // in between this pair of brackets
4574 // for (int otherKind = 0; (balance == 0) && (otherKind < BracketKinds);
4576 // for (int i = 0; i < leftCount[otherKind]; i++) {
4577 // int pos = leftPositions[otherKind][i];
4578 // if ((pos > start) && (pos < end))
4581 // for (int i = 0; i < rightCount[otherKind]; i++) {
4582 // int pos = rightPositions[otherKind][i];
4583 // if ((pos > start) && (pos < end))
4586 // if (balance != 0) {
4587 // problemReporter.unmatchedBracket(start, referenceContext,
4588 // compilationUnit.compilationResult); //bracket
4594 // // too many opening brackets ?
4595 // for (int i = rightCount[kind]; i < leftCount[kind]; i++) {
4596 // anomaliesDetected = true;
4597 // problemReporter.unmatchedBracket(leftPositions[kind][leftCount[kind] - i -
4598 // 1], referenceContext,
4599 // compilationUnit.compilationResult);
4601 // // too many closing brackets ?
4602 // for (int i = leftCount[kind]; i < rightCount[kind]; i++) {
4603 // anomaliesDetected = true;
4604 // problemReporter.unmatchedBracket(rightPositions[kind][i], referenceContext,
4605 // compilationUnit.compilationResult);
4607 // if (anomaliesDetected)
4610 // return anomaliesDetected;
4611 // } catch (ArrayStoreException e) { // jdk1.2.2 jit bug
4612 // return anomaliesDetected;
4613 // } catch (NullPointerException e) { // jdk1.2.2 jit bug
4614 // return anomaliesDetected;
4617 protected void pushOnAstLengthStack(int pos) {
4619 astLengthStack[++astLengthPtr] = pos;
4620 } catch (IndexOutOfBoundsException e) {
4621 int oldStackLength = astLengthStack.length;
4622 int[] oldPos = astLengthStack;
4623 astLengthStack = new int[oldStackLength + StackIncrement];
4624 System.arraycopy(oldPos, 0, astLengthStack, 0, oldStackLength);
4625 astLengthStack[astLengthPtr] = pos;
4629 protected void pushOnAstStack(ASTNode node) {
4631 * add a new obj on top of the ast stack
4634 astStack[++astPtr] = node;
4635 } catch (IndexOutOfBoundsException e) {
4636 int oldStackLength = astStack.length;
4637 ASTNode[] oldStack = astStack;
4638 astStack = new ASTNode[oldStackLength + AstStackIncrement];
4639 System.arraycopy(oldStack, 0, astStack, 0, oldStackLength);
4640 astPtr = oldStackLength;
4641 astStack[astPtr] = node;
4644 astLengthStack[++astLengthPtr] = 1;
4645 } catch (IndexOutOfBoundsException e) {
4646 int oldStackLength = astLengthStack.length;
4647 int[] oldPos = astLengthStack;
4648 astLengthStack = new int[oldStackLength + AstStackIncrement];
4649 System.arraycopy(oldPos, 0, astLengthStack, 0, oldStackLength);
4650 astLengthStack[astLengthPtr] = 1;
4654 protected void resetModifiers() {
4655 this.modifiers = AccDefault;
4656 this.modifiersSourceStart = -1; // <-- see comment into
4657 // modifiersFlag(int)
4658 this.scanner.commentPtr = -1;
4661 protected void consumePackageDeclarationName(IFile file) {
4662 // create a package name similar to java package names
4663 String projectPath = ProjectPrefUtil.getDocumentRoot(file.getProject()).toString();
4664 String filePath = file.getRawLocation().toString();
4665 String ext = file.getRawLocation().getFileExtension();
4666 int fileExtensionLength = ext == null ? 0 : ext.length() + 1;
4667 ImportReference impt;
4669 if (filePath.startsWith(projectPath)) {
4670 tokens = CharOperation
4671 .splitOn('/', filePath.toCharArray(), projectPath.length() + 1, filePath.length() - fileExtensionLength);
4673 String name = file.getName();
4674 tokens = new char[1][];
4675 tokens[0] = name.substring(0, name.length() - fileExtensionLength).toCharArray();
4678 this.compilationUnit.currentPackage = impt = new ImportReference(tokens, new char[0], 0, 0, true);
4680 impt.declarationSourceStart = 0;
4681 impt.declarationSourceEnd = 0;
4682 impt.declarationEnd = 0;
4683 // endPosition is just before the ;
4687 public final static String[] GLOBALS = { "$this", "$_COOKIE", "$_ENV", "$_FILES", "$_GET", "$GLOBALS", "$_POST", "$_REQUEST",
4688 "$_SESSION", "$_SERVER" };
4693 private void pushFunctionVariableSet() {
4694 HashSet set = new HashSet();
4695 if (fStackUnassigned.isEmpty()) {
4696 for (int i = 0; i < GLOBALS.length; i++) {
4697 set.add(GLOBALS[i]);
4700 fStackUnassigned.add(set);
4703 private void pushIfVariableSet() {
4704 if (!fStackUnassigned.isEmpty()) {
4705 HashSet set = new HashSet();
4706 fStackUnassigned.add(set);
4710 private HashSet removeIfVariableSet() {
4711 if (!fStackUnassigned.isEmpty()) {
4712 return (HashSet) fStackUnassigned.remove(fStackUnassigned.size() - 1);
4718 * Returns the <i>set of assigned variables </i> returns null if no Set is
4719 * defined at the current scanner position
4721 private HashSet peekVariableSet() {
4722 if (!fStackUnassigned.isEmpty()) {
4723 return (HashSet) fStackUnassigned.get(fStackUnassigned.size() - 1);
4729 * add the current identifier source to the <i>set of assigned variables </i>
4733 private void addVariableSet(HashSet set) {
4735 set.add(new String(scanner.getCurrentTokenSource()));
4740 * add the current identifier source to the <i>set of assigned variables </i>
4743 private void addVariableSet() {
4744 HashSet set = peekVariableSet();
4746 set.add(new String(scanner.getCurrentTokenSource()));
4751 * add the current identifier source to the <i>set of assigned variables </i>
4754 private void addVariableSet(char[] token) {
4755 HashSet set = peekVariableSet();
4757 set.add(new String(token));
4762 * check if the current identifier source is in the <i>set of assigned
4763 * variables </i> Returns true, if no set is defined for the current scanner
4767 private boolean containsVariableSet() {
4768 return containsVariableSet(scanner.getCurrentTokenSource());
4771 private boolean containsVariableSet(char[] token) {
4773 if (!fStackUnassigned.isEmpty()) {
4775 String str = new String(token);
4776 for (int i = 0; i < fStackUnassigned.size(); i++) {
4777 set = (HashSet) fStackUnassigned.get(i);
4778 if (set.contains(str)) {