import java.util.ArrayList;
import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Stack;
import net.sourceforge.phpdt.core.compiler.CharOperation;
import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
import net.sourceforge.phpeclipse.internal.compiler.ast.ASTNode;
import net.sourceforge.phpeclipse.internal.compiler.ast.AbstractMethodDeclaration;
import net.sourceforge.phpeclipse.internal.compiler.ast.BinaryExpression;
+import net.sourceforge.phpeclipse.internal.compiler.ast.Block;
+import net.sourceforge.phpeclipse.internal.compiler.ast.BreakStatement;
import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration;
import net.sourceforge.phpeclipse.internal.compiler.ast.ConditionalExpression;
-import net.sourceforge.phpeclipse.internal.compiler.ast.EmptyStatement;
+import net.sourceforge.phpeclipse.internal.compiler.ast.ContinueStatement;
import net.sourceforge.phpeclipse.internal.compiler.ast.EqualExpression;
import net.sourceforge.phpeclipse.internal.compiler.ast.Expression;
import net.sourceforge.phpeclipse.internal.compiler.ast.FieldDeclaration;
import net.sourceforge.phpeclipse.internal.compiler.ast.MethodDeclaration;
import net.sourceforge.phpeclipse.internal.compiler.ast.OR_OR_Expression;
import net.sourceforge.phpeclipse.internal.compiler.ast.OperatorIds;
+import net.sourceforge.phpeclipse.internal.compiler.ast.ReturnStatement;
import net.sourceforge.phpeclipse.internal.compiler.ast.SingleTypeReference;
import net.sourceforge.phpeclipse.internal.compiler.ast.Statement;
import net.sourceforge.phpeclipse.internal.compiler.ast.StringLiteral;
*/
public void parse(String s, HashMap variables) {
fMethodVariables = variables;
+ fStackUnassigned = new Stack();
init(s);
parse();
}
return compilationUnit;
}
- private boolean isVariable() {
- return token == TokenNameVariable; // || token == TokenNamethis;
- }
-
- private void statementList() {
+ private Block statementList() {
+ boolean branchStatement = false;
+ Statement statement;
+ int blockStart = scanner.getCurrentTokenStartPosition();
+ ArrayList blockStatements = new ArrayList();
do {
try {
- statement(TokenNameEOF);
+ statement = statement();
+ blockStatements.add(statement);
+ if (branchStatement && statement != null) {
+// reportSyntaxError("Unreachable code", statement.sourceStart, statement.sourceEnd);
+ problemReporter.unreachableCode(new String(scanner.getCurrentIdentifierSource()),statement.sourceStart, statement.sourceEnd,
+ referenceContext, compilationUnit.compilationResult);
+ }
if ((token == TokenNameRBRACE) || (token == TokenNamecase) || (token == TokenNamedefault) || (token == TokenNameelse)
|| (token == TokenNameelseif) || (token == TokenNameendif) || (token == TokenNameendfor)
|| (token == TokenNameendforeach) || (token == TokenNameendwhile) || (token == TokenNameendswitch)
|| (token == TokenNameenddeclare) || (token == TokenNameEOF) || (token == TokenNameERROR)) {
- return;
+ return createBlock(blockStart, blockStatements);
}
+ branchStatement = checkUnreachableStatements(statement);
} catch (SyntaxError sytaxErr1) {
// if an error occured,
// try to find keywords
|| (token == TokenNameelseif) || (token == TokenNameendif) || (token == TokenNameendfor)
|| (token == TokenNameendforeach) || (token == TokenNameendwhile) || (token == TokenNameendswitch)
|| (token == TokenNameenddeclare) || (token == TokenNameEOF) || (token == TokenNameERROR)) {
- return;
+ return createBlock(blockStart, blockStatements);
}
if (token == TokenNameif || token == TokenNameswitch || token == TokenNamefor || token == TokenNamewhile
|| token == TokenNamedo || token == TokenNameforeach || token == TokenNamecontinue || token == TokenNamebreak
} while (true);
}
+ /**
+ * @param statement
+ * @return
+ */
+ private boolean checkUnreachableStatements(Statement statement) {
+ if (statement instanceof ReturnStatement || statement instanceof ContinueStatement || statement instanceof BreakStatement) {
+ return true;
+ } else if (statement instanceof IfStatement && ((IfStatement) statement).checkUnreachable) {
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * @param blockStart
+ * @param blockStatements
+ * @return
+ */
+ private Block createBlock(int blockStart, ArrayList blockStatements) {
+ int blockEnd = scanner.getCurrentTokenEndPosition();
+ Block b = Block.EmptyWith(blockStart, blockEnd);
+ b.statements = new Statement[blockStatements.size()];
+ blockStatements.toArray(b.statements);
+ return b;
+ }
+
private void functionBody(MethodDeclaration methodDecl) {
// '{' [statement-list] '}'
if (token == TokenNameLBRACE) {
}
}
- private Statement statement(int previousToken) {
+ private Statement statement() {
Statement statement = null;
Expression expression;
int sourceStart = scanner.getCurrentTokenStartPosition();
+ int sourceEnd;
if (token == TokenNameif) {
+ // T_IF '(' expr ')' statement elseif_list else_single
+ // T_IF '(' expr ')' ':' inner_statement_list new_elseif_list new_else_single T_ENDIF ';'
getNextToken();
if (token == TokenNameLPAREN) {
getNextToken();
} else {
throwSyntaxError("')' expected after 'if' condition.");
}
- ifStatement();
- return new IfStatement(expression, statement, sourceStart, scanner.getCurrentTokenEndPosition());
+ // create basic IfStatement
+ IfStatement ifStatement = new IfStatement(expression, null, null, sourceStart, -1);
+ if (token == TokenNameCOLON) {
+ getNextToken();
+ ifStatementColon(ifStatement);
+ } else {
+ ifStatement(ifStatement);
+ }
+ return ifStatement;
} else if (token == TokenNameswitch) {
getNextToken();
if (token == TokenNameLPAREN) {
throwSyntaxError("'}' expected after 'do' keyword.");
}
} else {
- statement(TokenNameEOF);
+ statement();
}
if (token == TokenNamewhile) {
getNextToken();
foreach_optional_arg();
if (token == TokenNameEQUAL_GREATER) {
getNextToken();
- variable();
+ variable(false);
}
if (token == TokenNameRPAREN) {
getNextToken();
}
foreachStatement();
return statement;
- } else if (token == TokenNamecontinue || token == TokenNamebreak || token == TokenNamereturn) {
+ } else if (token == TokenNamebreak) {
+ expression = null;
getNextToken();
if (token != TokenNameSEMICOLON) {
- expr();
+ expression = expr();
}
if (token == TokenNameSEMICOLON) {
+ sourceEnd = scanner.getCurrentTokenEndPosition();
getNextToken();
} else {
if (token != TokenNameINLINE_HTML) {
- throwSyntaxError("';' expected after 'continue', 'break' or 'return'.");
+ throwSyntaxError("';' expected after 'break'.");
}
+ sourceEnd = scanner.getCurrentTokenEndPosition();
getNextToken();
}
- return statement;
+ return new BreakStatement(null, sourceStart, sourceEnd);
+ } else if (token == TokenNamecontinue) {
+ expression = null;
+ getNextToken();
+ if (token != TokenNameSEMICOLON) {
+ expression = expr();
+ }
+ if (token == TokenNameSEMICOLON) {
+ sourceEnd = scanner.getCurrentTokenEndPosition();
+ getNextToken();
+ } else {
+ if (token != TokenNameINLINE_HTML) {
+ throwSyntaxError("';' expected after 'continue'.");
+ }
+ sourceEnd = scanner.getCurrentTokenEndPosition();
+ getNextToken();
+ }
+ return new ContinueStatement(null, sourceStart, sourceEnd);
+ } else if (token == TokenNamereturn) {
+ expression = null;
+ getNextToken();
+ if (token != TokenNameSEMICOLON) {
+ expression = expr();
+ }
+ if (token == TokenNameSEMICOLON) {
+ sourceEnd = scanner.getCurrentTokenEndPosition();
+ getNextToken();
+ } else {
+ if (token != TokenNameINLINE_HTML) {
+ throwSyntaxError("';' expected after 'return'.");
+ }
+ sourceEnd = scanner.getCurrentTokenEndPosition();
+ getNextToken();
+ }
+ return new ReturnStatement(expression, sourceStart, sourceEnd);
} else if (token == TokenNameecho) {
getNextToken();
expressionList();
getNextToken();
functionDefinition(methodDecl);
} finally {
- int sourceEnd = scanner.getCurrentTokenStartPosition();
+ sourceEnd = scanner.getCurrentTokenStartPosition();
if (sourceEnd <= 0 || methodDecl.declarationSourceStart > sourceEnd) {
sourceEnd = methodDecl.declarationSourceStart + 1;
}
} else if (token == TokenNameLBRACE) {
getNextToken();
if (token != TokenNameRBRACE) {
- statementList();
+ statement = statementList();
}
if (token == TokenNameRBRACE) {
getNextToken();
}
getNextToken();
} else {
- statement(TokenNameRPAREN);
+ statement();
}
}
if (token == TokenNameAND) {
getNextToken();
}
- w_variable();
+ w_variable(true);
}
private void foreach_optional_arg() {
// global_var_list:
// global_var_list ',' global_var
//| global_var
+ HashSet set = peekVariableSet();
while (true) {
- global_var();
+ global_var(set);
if (token != TokenNameCOMMA) {
break;
}
}
}
- private void global_var() {
+ private void global_var(HashSet set) {
//global_var:
// T_VARIABLE
//| '$' r_variable
//| '$' '{' expr '}'
if (token == TokenNameVariable) {
- VariableInfo info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_GLOBAL_VAR);
if (fMethodVariables != null) {
+ VariableInfo info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_GLOBAL_VAR);
fMethodVariables.put(new String(scanner.getCurrentIdentifierSource()), info);
}
+ addVariableSet(set);
getNextToken();
} else if (token == TokenNameDOLLAR) {
getNextToken();
// static_var_list ',' T_VARIABLE
//| static_var_list ',' T_VARIABLE '=' static_scalar
//| T_VARIABLE
- //| T_VARIABLE '=' static_scalar
+ //| T_VARIABLE '=' static_scalar,
+ HashSet set = peekVariableSet();
while (true) {
if (token == TokenNameVariable) {
- VariableInfo info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_STATIC_VAR);
if (fMethodVariables != null) {
+ VariableInfo info = new VariableInfo(scanner.getCurrentTokenStartPosition(), VariableInfo.LEVEL_STATIC_VAR);
fMethodVariables.put(new String(scanner.getCurrentIdentifierSource()), info);
- }
+ }
+ addVariableSet(set);
getNextToken();
if (token == TokenNameEQUAL) {
getNextToken();
// unset_variable:
// variable
while (true) {
- variable();
+ variable(false);
if (token != TokenNameCOMMA) {
break;
}
}
}
}
- functionDeclarator(methodDecl);
- if (token == TokenNameSEMICOLON) {
- if (!isAbstract) {
- throwSyntaxError("Body declaration expected for method: " + new String(methodDecl.selector));
+ try {
+ pushVariableSet();
+ functionDeclarator(methodDecl);
+ if (token == TokenNameSEMICOLON) {
+ if (!isAbstract) {
+ throwSyntaxError("Body declaration expected for method: " + new String(methodDecl.selector));
+ }
+ getNextToken();
+ return;
}
- getNextToken();
- return;
+ functionBody(methodDecl);
+ } finally {
+ fStackUnassigned.pop();
}
- functionBody(methodDecl);
}
private void functionDeclarator(MethodDeclaration methodDecl) {
// static_scalar
char[] typeIdentifier = null;
if (token == TokenNameIdentifier || token == TokenNameVariable || token == TokenNameAND) {
+ HashSet set = peekVariableSet();
while (true) {
if (token == TokenNameIdentifier) {
typeIdentifier = scanner.getCurrentIdentifierSource();
info.typeIdentifier = typeIdentifier;
fMethodVariables.put(new String(scanner.getCurrentIdentifierSource()), info);
}
+ addVariableSet(set);
getNextToken();
if (token == TokenNameEQUAL) {
getNextToken();
} while (token == TokenNamecase || token == TokenNamedefault);
}
- // public void labeledStatement() {
- // if (token == TokenNamecase) {
- // getNextToken();
- // constant();
- // if (token == TokenNameDDOT) {
- // getNextToken();
- // statement();
- // } else {
- // throwSyntaxError("':' character after 'case' constant expected.");
- // }
- // return;
- // } else if (token == TokenNamedefault) {
- // getNextToken();
- // if (token == TokenNameDDOT) {
- // getNextToken();
- // statement();
- // } else {
- // throwSyntaxError("':' character after 'default' expected.");
- // }
- // return;
- // }
- // }
- // public void expressionStatement() {
- // }
- // private void inclusionStatement() {
- // }
- // public void compoundStatement() {
- // }
- // public void selectionStatement() {
- // }
- //
- // public void iterationStatement() {
- // }
- //
- // public void jumpStatement() {
- // }
- //
- // public void outputStatement() {
- // }
- //
- // public void scopeStatement() {
- // }
- //
- // public void flowStatement() {
- // }
- //
- // public void definitionStatement() {
- // }
- private void ifStatement() {
- // ':' statement-list [elseif-list] [else-colon-statement] 'endif' ';'
- if (token == TokenNameCOLON) {
- getNextToken();
- if (token != TokenNameendif) {
- statementList();
- switch (token) {
- case TokenNameelse:
- getNextToken();
- if (token == TokenNameCOLON) {
- getNextToken();
- if (token != TokenNameendif) {
- statementList();
- }
- } else {
- if (token == TokenNameif) { //'else if'
- getNextToken();
- elseifStatementList();
- } else {
- throwSyntaxError("':' expected after 'else'.");
- }
- }
- break;
- case TokenNameelseif:
- getNextToken();
- elseifStatementList();
- break;
- }
- }
- if (token != TokenNameendif) {
- throwSyntaxError("'endif' expected.");
- }
+ private void ifStatementColon(IfStatement iState) {
+ // T_IF '(' expr ')' ':' inner_statement_list new_elseif_list new_else_single T_ENDIF ';'
+ Block b = inner_statement_list();
+ iState.thenStatement = b;
+ checkUnreachable(iState, b);
+ if (token == TokenNameelseif) {
+ new_elseif_list(iState);
+ }
+ new_else_single(iState);
+ if (token != TokenNameendif) {
+ throwSyntaxError("'endif' expected.");
+ }
+ getNextToken();
+ if (token != TokenNameSEMICOLON) {
+ reportSyntaxError("';' expected after if-statement.");
+ iState.sourceEnd = scanner.getCurrentTokenStartPosition();
+ } else {
+ iState.sourceEnd = scanner.getCurrentTokenEndPosition();
getNextToken();
- if (token != TokenNameSEMICOLON) {
- throwSyntaxError("';' expected after if-statement.");
- }
+ }
+ }
+
+ private void ifStatement(IfStatement iState) {
+ // T_IF '(' expr ')' statement elseif_list else_single
+ Statement s = statement();
+ iState.thenStatement = s;
+ checkUnreachable(iState, s);
+ if (token == TokenNameelseif) {
+ elseif_list(iState);
+ }
+ else_single(iState);
+ }
+
+ private void elseif_list(IfStatement iState) {
+ // /* empty */
+ //| elseif_list T_ELSEIF '(' expr ')' statement
+ ArrayList conditionList = new ArrayList();
+ ArrayList statementList = new ArrayList();
+ Expression e;
+ Statement s;
+ while (token == TokenNameelseif) {
getNextToken();
- } else {
- // statement [else-statement]
- statement(TokenNameEOF);
- if (token == TokenNameelseif) {
+ if (token == TokenNameLPAREN) {
getNextToken();
- if (token == TokenNameLPAREN) {
- getNextToken();
- } else {
- throwSyntaxError("'(' expected after 'elseif' keyword.");
- }
- expr();
- if (token == TokenNameRPAREN) {
- getNextToken();
- } else {
- throwSyntaxError("')' expected after 'elseif' condition.");
- }
- ifStatement();
- } else if (token == TokenNameelse) {
+ } else {
+ throwSyntaxError("'(' expected after 'elseif' keyword.");
+ }
+ e = expr();
+ conditionList.add(e);
+ if (token == TokenNameRPAREN) {
getNextToken();
- statement(TokenNameEOF);
+ } else {
+ throwSyntaxError("')' expected after 'elseif' condition.");
}
+ s = statement();
+ statementList.add(s);
+ checkUnreachable(iState, s);
}
+ iState.elseifConditions = new Expression[conditionList.size()];
+ iState.elseifStatements = new Statement[statementList.size()];
+ conditionList.toArray(iState.elseifConditions);
+ statementList.toArray(iState.elseifStatements);
}
- private void elseifStatementList() {
- do {
- elseifStatement();
- switch (token) {
- case TokenNameelse:
+ private void new_elseif_list(IfStatement iState) {
+ // /* empty */
+ //| new_elseif_list T_ELSEIF '(' expr ')' ':' inner_statement_list
+ ArrayList conditionList = new ArrayList();
+ ArrayList statementList = new ArrayList();
+ Expression e;
+ Block b;
+ while (token == TokenNameelseif) {
+ getNextToken();
+ if (token == TokenNameLPAREN) {
getNextToken();
- if (token == TokenNameCOLON) {
- getNextToken();
- if (token != TokenNameendif) {
- statementList();
- }
- return;
- } else {
- if (token == TokenNameif) { //'else if'
- getNextToken();
- } else {
- throwSyntaxError("':' expected after 'else'.");
- }
- }
- break;
- case TokenNameelseif:
+ } else {
+ throwSyntaxError("'(' expected after 'elseif' keyword.");
+ }
+ e = expr();
+ conditionList.add(e);
+ if (token == TokenNameRPAREN) {
getNextToken();
- break;
- default:
- return;
+ } else {
+ throwSyntaxError("')' expected after 'elseif' condition.");
}
- } while (true);
+ if (token == TokenNameCOLON) {
+ getNextToken();
+ } else {
+ throwSyntaxError("':' expected after 'elseif' keyword.");
+ }
+ b = inner_statement_list();
+ statementList.add(b);
+ checkUnreachable(iState, b);
+ }
+ iState.elseifConditions = new Expression[conditionList.size()];
+ iState.elseifStatements = new Statement[statementList.size()];
+ conditionList.toArray(iState.elseifConditions);
+ statementList.toArray(iState.elseifStatements);
}
- private void elseifStatement() {
- if (token == TokenNameLPAREN) {
+ private void else_single(IfStatement iState) {
+ // /* empty */
+ // T_ELSE statement
+ if (token == TokenNameelse) {
getNextToken();
- expr();
- if (token != TokenNameRPAREN) {
- throwSyntaxError("')' expected in else-if-statement.");
- }
+ Statement s = statement();
+ iState.elseStatement = s;
+ checkUnreachable(iState, s);
+ } else {
+ iState.checkUnreachable = false;
+ }
+ iState.sourceEnd = scanner.getCurrentTokenStartPosition();
+ }
+
+ private void new_else_single(IfStatement iState) {
+ // /* empty */
+ //| T_ELSE ':' inner_statement_list
+ if (token == TokenNameelse) {
getNextToken();
- if (token != TokenNameCOLON) {
- throwSyntaxError("':' expected in else-if-statement.");
+ if (token == TokenNameCOLON) {
+ getNextToken();
+ } else {
+ throwSyntaxError("':' expected after 'else' keyword.");
}
- getNextToken();
- if (token != TokenNameendif) {
- statementList();
+ Block b = inner_statement_list();
+ iState.elseStatement = b;
+ checkUnreachable(iState, b);
+ } else {
+ iState.checkUnreachable = false;
+ }
+ }
+
+ private Block inner_statement_list() {
+ // inner_statement_list inner_statement
+ // /* empty */
+ return statementList();
+ }
+
+ /**
+ * @param iState
+ * @param b
+ */
+ private void checkUnreachable(IfStatement iState, Statement s) {
+ if (s instanceof Block) {
+ Block b = (Block) s;
+ if (b.statements == null || b.statements.length == 0) {
+ iState.checkUnreachable = false;
+ } else {
+ int off = b.statements.length - 1;
+ if (!(b.statements[off] instanceof ReturnStatement) && !(b.statements[off] instanceof ContinueStatement)
+ && !(b.statements[off] instanceof BreakStatement)) {
+ if (!(b.statements[off] instanceof IfStatement) || !((IfStatement) b.statements[off]).checkUnreachable) {
+ iState.checkUnreachable = false;
+ }
+ }
+ }
+ } else {
+ if (!(s instanceof ReturnStatement) && !(s instanceof ContinueStatement) && !(s instanceof BreakStatement)) {
+ if (!(s instanceof IfStatement) || !((IfStatement) s).checkUnreachable) {
+ iState.checkUnreachable = false;
+ }
}
}
}
+ // private void elseifStatementList() {
+ // do {
+ // elseifStatement();
+ // switch (token) {
+ // case TokenNameelse:
+ // getNextToken();
+ // if (token == TokenNameCOLON) {
+ // getNextToken();
+ // if (token != TokenNameendif) {
+ // statementList();
+ // }
+ // return;
+ // } else {
+ // if (token == TokenNameif) { //'else if'
+ // getNextToken();
+ // } else {
+ // throwSyntaxError("':' expected after 'else'.");
+ // }
+ // }
+ // break;
+ // case TokenNameelseif:
+ // getNextToken();
+ // break;
+ // default:
+ // return;
+ // }
+ // } while (true);
+ // }
+
+ // private void elseifStatement() {
+ // if (token == TokenNameLPAREN) {
+ // getNextToken();
+ // expr();
+ // if (token != TokenNameRPAREN) {
+ // throwSyntaxError("')' expected in else-if-statement.");
+ // }
+ // getNextToken();
+ // if (token != TokenNameCOLON) {
+ // throwSyntaxError("':' expected in else-if-statement.");
+ // }
+ // getNextToken();
+ // if (token != TokenNameendif) {
+ // statementList();
+ // }
+ // }
+ // }
+
private void switchStatement() {
if (token == TokenNameCOLON) {
// ':' [labeled-statement-list] 'endswitch' ';'
}
getNextToken();
} else {
- statement(TokenNameEOF);
+ statement();
}
}
}
getNextToken();
} else {
- statement(TokenNameEOF);
+ statement();
}
}
}
getNextToken();
} else {
- statement(TokenNameEOF);
+ statement();
}
}
case TokenNameVariable:
case TokenNameDOLLAR:
boolean rememberedVar = false;
- Expression lhs = variable();
+// char[] lhsVar = null;
+// if (token==TokenNameVariable) {
+// lhsVar = scanner.getCurrentTokenSource();
+// }
+ Expression lhs = variable(true);
+
switch (token) {
case TokenNameEQUAL:
+// if (lhsVar != null) {
+// addVariableSet(lhsVar);
+// }
getNextToken();
if (token == TokenNameAND) {
getNextToken();
}
}
} else {
- Expression rhs = variable();
+ Expression rhs = variable(false);
if (rhs != null && rhs instanceof FieldReference && lhs != null && lhs instanceof FieldReference) {
// example:
// $var = &$ref;
// variable
//| T_LIST '(' assignment_list ')'
//| /* empty */
- if (token == TokenNameVariable || token == TokenNameDOLLAR) {
- variable();
+ if (token == TokenNameVariable) {
+ variable(true);
+ } else if (token == TokenNameDOLLAR) {
+ variable(false);
} else {
if (token == TokenNamelist) {
getNextToken();
while (true) {
if (token == TokenNameAND) {
getNextToken();
- variable();
+ variable(false);
} else {
expr();
if (token == TokenNameAND) {
getNextToken();
- variable();
+ variable(false);
} else if (token == TokenNameEQUAL_GREATER) {
getNextToken();
if (token == TokenNameAND) {
getNextToken();
- variable();
+ variable(false);
} else {
expr();
}
// }
// } while (true);
// }
- private Expression variable_without_objects() {
+ private Expression variable_without_objects(boolean lefthandside) {
// variable_without_objects:
// reference_variable
// | simple_indirect_reference reference_variable
while (token == TokenNameDOLLAR) {
getNextToken();
}
- return reference_variable();
+ return reference_variable(lefthandside);
}
- private Expression function_call() {
+ private Expression function_call(boolean lefthandside) {
// function_call:
// T_STRING '(' function_call_parameter_list ')'
//| class_constant '(' function_call_parameter_list ')'
getNextToken();
} else {
// static member:
- variable_without_objects();
+ variable_without_objects(false);
}
break;
}
} else {
- ref = variable_without_objects();
+ ref = variable_without_objects(lefthandside);
}
if (token != TokenNameLPAREN) {
if (defineName != null) {
while (true) {
if (token == TokenNameAND) {
getNextToken();
- w_variable();
+ w_variable(false);
} else {
// if (token == TokenNameIdentifier || token ==
// TokenNameVariable
throwSyntaxError("'::' expected after class name (static_member).");
}
getNextToken();
- variable_without_objects();
+ variable_without_objects(false);
}
- private Expression base_variable_with_function_calls() {
+ private Expression base_variable_with_function_calls(boolean lefthandside) {
// base_variable_with_function_calls:
// base_variable
//| function_call
// scanner.phpMode = true;
// }
// if (functionCall) {
- return function_call();
+ return function_call(lefthandside);
// } else {
// base_variable();
// }
while (token == TokenNameDOLLAR) {
getNextToken();
}
- reference_variable();
+ reference_variable(false);
}
return ref;
}
// // '$'
// //| simple_indirect_reference '$'
// }
- private Expression reference_variable() {
+ private Expression reference_variable(boolean lefthandside) {
// reference_variable:
// reference_variable '[' dim_offset ']'
// | reference_variable '{' expr '}'
if (Scanner.TRACE) {
System.out.println("TRACE: reference_variable()");
}
- ref = compound_variable();
+ ref = compound_variable(lefthandside);
while (true) {
if (token == TokenNameLBRACE) {
ref = null;
return ref;
}
- private Expression compound_variable() {
+ private Expression compound_variable(boolean lefthandside) {
// compound_variable:
// T_VARIABLE
// | '$' '{' expr '}'
System.out.println("TRACE: compound_variable()");
}
if (token == TokenNameVariable) {
+ if (!lefthandside) {
+ if (!containsVariableSet()) {
+// reportSyntaxError("The local variable " + new String(scanner.getCurrentIdentifierSource())
+// + " may not have been initialized");
+ problemReporter.uninitializedLocalVariable(new String(scanner.getCurrentIdentifierSource()),scanner.getCurrentTokenStartPosition(), scanner.getCurrentTokenEndPosition(),
+ referenceContext, compilationUnit.compilationResult);
+ }
+ } else {
+ addVariableSet();
+ }
FieldReference ref = new FieldReference(scanner.getCurrentIdentifierSource(), scanner.getCurrentTokenStartPosition());
getNextToken();
return ref;
System.out.println("TRACE: object_property()");
}
if (token == TokenNameVariable || token == TokenNameDOLLAR) {
- variable_without_objects();
+ variable_without_objects(false);
} else {
object_dim_list();
}
}
private void r_variable() {
- variable();
+ variable(false);
}
- private void w_variable() {
- variable();
+ private void w_variable(boolean lefthandside) {
+ variable(lefthandside);
}
private void rw_variable() {
- variable();
+ variable(false);
}
- private Expression variable() {
+ private Expression variable(boolean lefthandside) {
// variable:
// base_variable_with_function_calls T_OBJECT_OPERATOR
// object_property method_or_not variable_properties
// | base_variable_with_function_calls
- Expression ref = base_variable_with_function_calls();
+ Expression ref = base_variable_with_function_calls(lefthandside);
if (token == TokenNameMINUS_GREATER) {
ref = null;
getNextToken();
throwSyntaxError("'(' expected after keyword 'empty'");
}
getNextToken();
- variable();
+ variable(false);
if (token != TokenNameRPAREN) {
throwSyntaxError("')' expected after keyword 'empty'");
}
throwSyntaxError("Variable expected after keyword 'isset'");
}
while (true) {
- variable();
+ variable(false);
if (token == TokenNameCOMMA) {
getNextToken();
} else {
HashMap fMethodVariables = null;
+ Stack fStackUnassigned = new Stack();
+
//ast stack
final static int AstStackIncrement = 100;
}
}
if (scanner.recordLineSeparator) {
- // compilationUnit.compilationResult.lineSeparatorPositions =
- // scanner.getLineEnds();
+ compilationUnit.compilationResult.lineSeparatorPositions = scanner.getLineEnds();
}
// check placement anomalies against other kinds of brackets
for (int kind = 0; kind < BracketKinds; kind++) {
//endPosition is just before the ;
}
+
+ public final static String[] GLOBALS = {
+ "$this",
+ "$_COOKIE",
+ "$_ENV",
+ "$_FILES",
+ "$_GET",
+ "$GLOBALS",
+ "$_POST",
+ "$_REQUEST",
+ "$_SESSION",
+ "$_SERVER"
+ };
+ /**
+ *
+ */
+ private void pushVariableSet() {
+ HashSet set =new HashSet();
+ for (int i = 0; i < GLOBALS.length; i++) {
+ set.add(GLOBALS[i]);
+ }
+ fStackUnassigned.push(set);
+ }
+
+ /**
+ * Returns the <i>set of assigned variables </i> returns null if no Set is defined at the current scanner position
+ */
+ private HashSet peekVariableSet() {
+ if (!fStackUnassigned.isEmpty()) {
+ return (HashSet) fStackUnassigned.peek();
+ }
+ return null;
+ }
+
+ /**
+ * add the current identifier source to the <i>set of assigned variables </i>
+ *
+ * @param set
+ */
+ private void addVariableSet(HashSet set) {
+ if (set != null) {
+ set.add(new String(scanner.getCurrentTokenSource()));
+ }
+ }
+
+ /**
+ * add the current identifier source to the <i>set of assigned variables </i>
+ *
+ */
+ private void addVariableSet() {
+ HashSet set = peekVariableSet();
+ if (set != null) {
+ set.add(new String(scanner.getCurrentTokenSource()));
+ }
+ }
+
+ /**
+ * add the current identifier source to the <i>set of assigned variables </i>
+ *
+ */
+ private void addVariableSet(char[] token) {
+ HashSet set = peekVariableSet();
+ if (set != null) {
+ set.add(new String(token));
+ }
+ }
+
+ /**
+ * check if the current identifier source is in the <i>set of assigned variables </i> Returns true, if no set is defined for the
+ * current scanner position
+ *
+ */
+ private boolean containsVariableSet() {
+ HashSet set = peekVariableSet();
+ if (set != null) {
+ return set.contains(new String(scanner.getCurrentTokenSource()));
+ }
+ return true;
+ }
}
\ No newline at end of file
git://git.phpeclipse.com / phpeclipse.git / blobdiff