import org.eclipse.ui.texteditor.MarkerUtilities;
import org.eclipse.jface.preference.IPreferenceStore;
-import java.io.CharArrayReader;
import java.util.Hashtable;
import java.io.StringReader;
import java.text.MessageFormat;
import net.sourceforge.phpeclipse.actions.PHPStartApacheAction;
import net.sourceforge.phpeclipse.PHPeclipsePlugin;
import net.sourceforge.phpdt.internal.compiler.parser.PHPOutlineInfo;
+import net.sourceforge.phpdt.internal.compiler.parser.PHPSegmentWithChildren;
+import net.sourceforge.phpdt.internal.compiler.parser.PHPFunctionDeclaration;
+import net.sourceforge.phpdt.internal.compiler.parser.PHPClassDeclaration;
+import net.sourceforge.phpdt.internal.compiler.parser.PHPVarDeclaration;
+import net.sourceforge.phpdt.internal.compiler.parser.PHPReqIncDeclaration;
/**
* A new php parser.
*/
public class PHPParser extends PHPParserSuperclass {
- private static PHPParser me;
-
private static IFile fileToParse;
+ /** The current segment */
+ private static PHPSegmentWithChildren currentSegment;
+
private static final String PARSE_ERROR_STRING = "Parse error"; //$NON-NLS-1$
private static final String PARSE_WARNING_STRING = "Warning"; //$NON-NLS-1$
- public static final int ERROR = 2;
- public static final int WARNING = 1;
- public static final int INFO = 0;
PHPOutlineInfo outlineInfo;
private static int errorLevel = ERROR;
private static String errorMessage;
public PHPParser() {
}
- public static PHPParser getInstance(IFile fileToParse) {
- if (me == null) {
- me = new PHPParser(fileToParse);
- } else {
- me.setFileToParse(fileToParse);
- }
- return me;
- }
-
public void setFileToParse(IFile fileToParse) {
this.fileToParse = fileToParse;
}
- public static PHPParser getInstance(java.io.Reader stream) {
- if (me == null) {
- me = new PHPParser(stream);
- } else {
- me.ReInit(stream);
- }
- return me;
- }
-
public PHPParser(IFile fileToParse) {
this(new StringReader(""));
this.fileToParse = fileToParse;
jj_input_stream = new SimpleCharStream(stream, 1, 1);
}
ReInit(stream);
- phpTest();
+ phpFile();
}
public PHPOutlineInfo parseInfo(Object parent, String s) {
outlineInfo = new PHPOutlineInfo(parent);
+ currentSegment = outlineInfo.getDeclarations();
StringReader stream = new StringReader(s);
if (jj_input_stream == null) {
jj_input_stream = new SimpleCharStream(stream, 1, 1);
try {
parse();
} catch (ParseException e) {
- if (errorMessage == null) {
- PHPeclipsePlugin.log(e);
- } else {
- setMarker(errorMessage, e.currentToken.beginLine, errorLevel);
- errorMessage = null;
- }
+ processParseException(e);
}
return outlineInfo;
}
-
/**
- * Create marker for the parse error
+ * This method will process the parse exception.
+ * If the error message is null, the parse exception wasn't catched and a trace is written in the log
+ * @param e the ParseException
*/
- private static void setMarker(String message, int lineNumber, int errorLevel) {
- try {
- setMarker(fileToParse, message, lineNumber, errorLevel);
- } catch (CoreException e) {
+ private static void processParseException(final ParseException e) {
+ if (errorMessage == null) {
PHPeclipsePlugin.log(e);
+ errorMessage = "this exception wasn't handled by the parser please tell us how to reproduce it";
}
+ setMarker(e);
+ errorMessage = null;
}
- public static void setMarker(IFile file, String message, int lineNumber, int errorLevel) throws CoreException {
- if (file != null) {
- Hashtable attributes = new Hashtable();
- MarkerUtilities.setMessage(attributes, message);
- switch (errorLevel) {
- case ERROR :
- attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_ERROR));
- break;
- case WARNING :
- attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
- break;
- case INFO :
- attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_INFO));
- break;
- }
- MarkerUtilities.setLineNumber(attributes, lineNumber);
- MarkerUtilities.createMarker(file, attributes, IMarker.PROBLEM);
+ /**
+ * Create marker for the parse error
+ */
+ private static void setMarker(ParseException e) {
+ try {
+ setMarker(fileToParse, errorMessage, jj_input_stream.tokenBegin,jj_input_stream.tokenBegin+e.currentToken.image.length(), errorLevel);
+ } catch (CoreException e2) {
+ PHPeclipsePlugin.log(e2);
}
}
try {
parse();
} catch (ParseException e) {
- PHPeclipsePlugin.log(e);
+ processParseException(e);
}
}
<DEFAULT> TOKEN :
{
- "<?php" : PHPPARSING
-| "<?" : PHPPARSING
+ <PHPSTART : "<?php" | "<?"> : PHPPARSING
}
-<DEFAULT> SKIP :
+<PHPPARSING> TOKEN :
{
- < ~[] >
+ <PHPEND :"?>"> : DEFAULT
}
-<PHPPARSING> TOKEN :
+<DEFAULT> SKIP :
{
- "?>" : DEFAULT
+ < ~[] >
}
+
/* WHITE SPACE */
<PHPPARSING> SKIP :
void phpFile() :
{}
{
- ("<?php" Php() "?>")*
+ (<PHPSTART> Php() <PHPEND>)*
<EOF>
}
}
void ClassDeclaration() :
-{}
{
- <CLASS> <IDENTIFIER> [ <EXTENDS> <IDENTIFIER> ]
+ PHPClassDeclaration classDeclaration;
+ Token className;
+ int pos = jj_input_stream.bufpos;
+}
+{
+ <CLASS> className = <IDENTIFIER> [ <EXTENDS> <IDENTIFIER> ]
+ {
+ classDeclaration = new PHPClassDeclaration(currentSegment,className.image,pos);
+ currentSegment.add(classDeclaration);
+ currentSegment = classDeclaration;
+ }
ClassBody()
+ {
+ currentSegment = (PHPSegmentWithChildren) currentSegment.getParent();
+ }
}
void ClassBody() :
{}
{
- <LBRACE> ( ClassBodyDeclaration() )* <RBRACE>
+ try {
+ <LBRACE>
+ } catch (ParseException e) {
+ errorMessage = "'{' expected";
+ errorLevel = ERROR;
+ throw e;
+ }
+ ( ClassBodyDeclaration() )*
+ try {
+ <RBRACE>
+ } catch (ParseException e) {
+ errorMessage = "'var', 'function' or '}' expected";
+ errorLevel = ERROR;
+ throw e;
+ }
}
void ClassBodyDeclaration() :
}
void FieldDeclaration() :
-{}
{
- <VAR> VariableDeclarator() ( <COMMA> VariableDeclarator() )* <SEMICOLON>
+ PHPVarDeclaration variableDeclaration;
+}
+{
+ <VAR> variableDeclaration = VariableDeclarator()
+ {currentSegment.add(variableDeclaration);}
+ ( <COMMA>
+ variableDeclaration = VariableDeclarator()
+ {currentSegment.add(variableDeclaration);}
+ )*
+ try {
+ <SEMICOLON>
+ } catch (ParseException e) {
+ errorMessage = "';' expected after variable declaration";
+ errorLevel = ERROR;
+ throw e;
+ }
}
-void VariableDeclarator() :
-{}
+PHPVarDeclaration VariableDeclarator() :
{
- VariableDeclaratorId() [ <ASSIGN> VariableInitializer() ]
+ String varName;
+ String varValue = null;
+ int pos;
+}
+{
+ varName = VariableDeclaratorId()
+ {pos = jj_input_stream.tokenBegin;}
+ [
+ <ASSIGN>
+ try {
+ varValue = VariableInitializer()
+ } catch (ParseException e) {
+ errorMessage = "Literal expression expected in variable initializer";
+ errorLevel = ERROR;
+ throw e;
+ }
+ ]
+ {
+ if (varValue == null) {
+ return new PHPVarDeclaration(currentSegment,varName,pos);
+ }
+ return new PHPVarDeclaration(currentSegment,varName,pos,varValue);
+ }
}
-void VariableDeclaratorId() :
-{}
+String VariableDeclaratorId() :
+{
+ String expr;
+ StringBuffer buff = new StringBuffer();
+}
{
- Variable() ( LOOKAHEAD(2) VariableSuffix() )*
+ try {
+ expr = Variable()
+ {buff.append(expr);}
+ ( LOOKAHEAD(2) expr = VariableSuffix()
+ {buff.append(expr);}
+ )*
+ {return buff.toString();}
+ } catch (ParseException e) {
+ errorMessage = "'$' expected for variable identifier";
+ errorLevel = ERROR;
+ throw e;
+ }
}
-void Variable():
-{}
+String Variable():
+{
+ String expr = null;
+ Token token;
+}
{
- <DOLLAR_ID> (<LBRACE> Expression() <RBRACE>) *
+ token = <DOLLAR_ID> [<LBRACE> expr = Expression() <RBRACE>]
+ {
+ if (expr == null) {
+ return token.image;
+ }
+ return token + "{" + expr + "}";
+ }
|
- <DOLLAR> VariableName()
+ <DOLLAR> expr = VariableName()
+ {return "$" + expr;}
}
-void VariableName():
-{}
+String VariableName():
+{
+String expr = null;
+Token token;
+}
{
- <LBRACE> Expression() <RBRACE>
+ <LBRACE> expr = Expression() <RBRACE>
+ {return "{"+expr+"}";}
+|
+ token = <IDENTIFIER> [<LBRACE> expr = Expression() <RBRACE>]
+ {
+ if (expr == null) {
+ return token.image;
+ }
+ return token + "{" + expr + "}";
+ }
|
- <IDENTIFIER> (<LBRACE> Expression() <RBRACE>) *
+ <DOLLAR> expr = VariableName()
+ {return "$" + expr;}
|
- <DOLLAR> VariableName()
+ token = <DOLLAR_ID> [expr = VariableName()]
+ {
+ if (expr == null) {
+ return token.image;
+ }
+ return token.image + expr;
+ }
}
-void VariableInitializer() :
-{}
+String VariableInitializer() :
{
- Expression()
+ String expr;
+}
+{
+ expr = Literal()
+ {return expr;}
}
-void ArrayVariable() :
-{}
+String ArrayVariable() :
+{
+String expr;
+StringBuffer buff = new StringBuffer();
+}
{
- Expression() (<ARRAYASSIGN> Expression())*
+ expr = Expression()
+ {buff.append(expr);}
+ [<ARRAYASSIGN> expr = Expression()
+ {buff.append("=>").append(expr);}]
+ {return buff.toString();}
}
-void ArrayInitializer() :
-{}
+String ArrayInitializer() :
+{
+String expr = null;
+StringBuffer buff = new StringBuffer("(");
+}
{
- <LPAREN> [ ArrayVariable() ( LOOKAHEAD(2) <COMMA> ArrayVariable() )* ]<RPAREN>
+ <LPAREN> [ expr = ArrayVariable()
+ {buff.append(expr);}
+ ( LOOKAHEAD(2) <COMMA> expr = ArrayVariable()
+ {buff.append(",").append(expr);}
+ )* ]
+ <RPAREN>
+ {
+ buff.append(")");
+ return buff.toString();
+ }
}
void MethodDeclaration() :
-{}
{
- <FUNCTION> MethodDeclarator()
- ( Block() | <SEMICOLON> )
+ PHPFunctionDeclaration functionDeclaration;
+}
+{
+ <FUNCTION> functionDeclaration = MethodDeclarator()
+ {
+ currentSegment.add(functionDeclaration);
+ currentSegment = functionDeclaration;
+ }
+ Block()
+ {
+ currentSegment = (PHPSegmentWithChildren) currentSegment.getParent();
+ }
}
-void MethodDeclarator() :
-{}
+PHPFunctionDeclaration MethodDeclarator() :
{
- [<BIT_AND>] <IDENTIFIER> FormalParameters()
+ Token identifier;
+ StringBuffer methodDeclaration = new StringBuffer();
+ String formalParameters;
+ int pos = jj_input_stream.bufpos;
+}
+{
+ [ <BIT_AND> {methodDeclaration.append("&");} ]
+ identifier = <IDENTIFIER>
+ {methodDeclaration.append(identifier);}
+ formalParameters = FormalParameters()
+ {
+ methodDeclaration.append(formalParameters);
+ return new PHPFunctionDeclaration(currentSegment,methodDeclaration.toString(),pos);
+ }
}
-void FormalParameters() :
-{}
+String FormalParameters() :
+{
+ String expr;
+ final StringBuffer buff = new StringBuffer("(");
+}
{
- <LPAREN> [ FormalParameter() ( <COMMA> FormalParameter() )* ] <RPAREN>
+ try {
+ <LPAREN>
+ } catch (ParseException e) {
+ errorMessage = "Formal parameter expected after function identifier";
+ errorLevel = ERROR;
+ jj_consume_token(token.kind);
+ }
+ [ expr = FormalParameter()
+ {buff.append(expr);}
+ (
+ <COMMA> expr = FormalParameter()
+ {buff.append(",").append(expr);}
+ )*
+ ]
+ try {
+ <RPAREN>
+ } catch (ParseException e) {
+ errorMessage = "')' expected";
+ errorLevel = ERROR;
+ throw e;
+ }
+ {
+ buff.append(")");
+ return buff.toString();
+ }
}
-void FormalParameter() :
-{}
+String FormalParameter() :
{
- [<BIT_AND>] VariableDeclarator()
+ PHPVarDeclaration variableDeclaration;
+ StringBuffer buff = new StringBuffer();
+}
+{
+ [<BIT_AND> {buff.append("&");}] variableDeclaration = VariableDeclarator()
+ {
+ buff.append(variableDeclaration.toString());
+ return buff.toString();
+ }
}
-void Type() :
+String Type() :
{}
{
<STRING>
+ {return "string";}
|
<BOOL>
+ {return "bool";}
|
<BOOLEAN>
+ {return "boolean";}
|
<REAL>
+ {return "real";}
|
<DOUBLE>
+ {return "double";}
|
<FLOAT>
+ {return "float";}
|
<INT>
+ {return "int";}
|
<INTEGER>
+ {return "integer";}
}
-/*
- * Expression syntax follows.
- */
-
-void Expression() :
-/*
- * This expansion has been written this way instead of:
- * Assignment() | ConditionalExpression()
- * for performance reasons.
- * However, it is a weakening of the grammar for it allows the LHS of
- * assignments to be any conditional expression whereas it can only be
- * a primary expression. Consider adding a semantic predicate to work
- * around this.
- */
-{}
+String Expression() :
+{
+ String expr;
+ String assignOperator = null;
+ String expr2 = null;
+}
{
- PrintExpression()
+ expr = PrintExpression()
+ {return expr;}
|
- ConditionalExpression()
+ expr = ConditionalExpression()
[
- AssignmentOperator() Expression()
+ assignOperator = AssignmentOperator()
+ expr2 = Expression()
]
+ {
+ if (expr2 == null) {
+ return expr;
+ } else {
+ return expr + assignOperator + expr2;
+ }
+ }
}
-void AssignmentOperator() :
-{}
-{
- <ASSIGN> | <STARASSIGN> | <SLASHASSIGN> | <REMASSIGN> | <PLUSASSIGN> | <MINUSASSIGN> | <LSHIFTASSIGN> | <RSIGNEDSHIFTASSIGN> | <RUNSIGNEDSHIFTASSIGN> | <ANDASSIGN> | <XORASSIGN> | <ORASSIGN> | <DOTASSIGN>
+String AssignmentOperator() :
+{
+ Token assignOperator;
+}
+{
+ <ASSIGN>
+{return "=";}
+| <STARASSIGN>
+{return "*=";}
+| <SLASHASSIGN>
+{return "/=";}
+| <REMASSIGN>
+{return "%=";}
+| <PLUSASSIGN>
+{return "+=";}
+| <MINUSASSIGN>
+{return "-=";}
+| <LSHIFTASSIGN>
+{return "<<=";}
+| <RSIGNEDSHIFTASSIGN>
+{return ">>=";}
+| <RUNSIGNEDSHIFTASSIGN>
+{return ">>>=";}
+| <ANDASSIGN>
+{return "&=";}
+| <XORASSIGN>
+{return "|=";}
+| <ORASSIGN>
+{return "|=";}
+| <DOTASSIGN>
+{return ".=";}
+}
+
+String ConditionalExpression() :
+{
+ String expr;
+ String expr2 = null;
+ String expr3 = null;
+}
+{
+ expr = ConditionalOrExpression() [ <HOOK> expr2 = Expression() <COLON> expr3 = ConditionalExpression() ]
+{
+ if (expr3 == null) {
+ return expr;
+ } else {
+ return expr + "?" + expr2 + ":" + expr3;
+ }
+}
}
-void ConditionalExpression() :
-{}
+String ConditionalOrExpression() :
{
- ConditionalOrExpression() [ <HOOK> Expression() <COLON> ConditionalExpression() ]
+ String expr;
+ Token operator;
+ String expr2 = null;
+ StringBuffer buff = new StringBuffer();
}
-
-void ConditionalOrExpression() :
-{}
{
- ConditionalAndExpression() ( (<SC_OR> | <_ORL>) ConditionalAndExpression() )*
+ expr = ConditionalAndExpression()
+ {
+ buff.append(expr);
+ }
+ (
+ (operator = <SC_OR> | operator = <_ORL>) expr2 = ConditionalAndExpression()
+ {
+ buff.append(operator.image);
+ buff.append(expr2);
+ }
+ )*
+ {
+ return buff.toString();
+ }
}
-void ConditionalAndExpression() :
-{}
+String ConditionalAndExpression() :
+{
+ String expr;
+ Token operator;
+ String expr2 = null;
+ StringBuffer buff = new StringBuffer();
+}
{
- ConcatExpression() ( (<SC_AND> | <_ANDL>) ConcatExpression() )*
+ expr = ConcatExpression()
+ {
+ buff.append(expr);
+ }
+ (
+ (operator = <SC_AND> | operator = <_ANDL>) expr2 = ConcatExpression()
+ {
+ buff.append(operator.image);
+ buff.append(expr2);
+ }
+ )*
+ {
+ return buff.toString();
+ }
}
-void ConcatExpression() :
-{}
+String ConcatExpression() :
{
- InclusiveOrExpression() ( <DOT> InclusiveOrExpression() )*
+ String expr;
+ String expr2 = null;
+ StringBuffer buff = new StringBuffer();
+}
+{
+ expr = InclusiveOrExpression()
+ {
+ buff.append(expr);
+ }
+ (
+ <DOT> expr2 = InclusiveOrExpression()
+ {
+ buff.append(".");
+ buff.append(expr2);
+ }
+ )*
+ {
+ return buff.toString();
+ }
}
-void InclusiveOrExpression() :
-{}
+String InclusiveOrExpression() :
{
- ExclusiveOrExpression() ( <BIT_OR> ExclusiveOrExpression() )*
+ String expr;
+ String expr2 = null;
+ StringBuffer buff = new StringBuffer();
+}
+{
+ expr = ExclusiveOrExpression()
+ {
+ buff.append(expr);
+ }
+ (
+ <BIT_OR> expr2 = ExclusiveOrExpression()
+ {
+ buff.append("|");
+ buff.append(expr2);
+ }
+ )*
+ {
+ return buff.toString();
+ }
}
-void ExclusiveOrExpression() :
-{}
+String ExclusiveOrExpression() :
+{
+ String expr;
+ String expr2 = null;
+ StringBuffer buff = new StringBuffer();
+}
{
- AndExpression() ( <XOR> AndExpression() )*
+ expr = AndExpression()
+ {
+ buff.append(expr);
+ }
+ (
+ <XOR> expr2 = AndExpression()
+ {
+ buff.append("^");
+ buff.append(expr2);
+ }
+ )*
+ {
+ return buff.toString();
+ }
}
-void AndExpression() :
-{}
+String AndExpression() :
{
- EqualityExpression() ( <BIT_AND> EqualityExpression() )*
+ String expr;
+ String expr2 = null;
+ StringBuffer buff = new StringBuffer();
+}
+{
+ expr = EqualityExpression()
+ {
+ buff.append(expr);
+ }
+ (
+ <BIT_AND> expr2 = EqualityExpression()
+ {
+ buff.append("&");
+ buff.append(expr2);
+ }
+ )*
+ {
+ return buff.toString();
+ }
}
-void EqualityExpression() :
-{}
+String EqualityExpression() :
{
- RelationalExpression() ( ( <EQ> | <NE> ) RelationalExpression() )*
+ String expr;
+ Token operator;
+ String expr2;
+ StringBuffer buff = new StringBuffer();
+}
+{
+ expr = RelationalExpression()
+ {buff.append(expr);}
+ (
+ ( operator = <EQ> | operator = <NE> ) expr2 = RelationalExpression()
+ {
+ buff.append(operator.image);
+ buff.append(expr2);
+ }
+ )*
+ {return buff.toString();}
}
-void RelationalExpression() :
-{}
+String RelationalExpression() :
+{
+ String expr;
+ Token operator;
+ String expr2;
+ StringBuffer buff = new StringBuffer();
+}
{
- ShiftExpression() ( ( <LT> | <GT> | <LE> | <GE> ) ShiftExpression() )*
+ expr = ShiftExpression()
+ {buff.append(expr);}
+ (
+ ( operator = <LT> | operator = <GT> | operator = <LE> | operator = <GE> ) expr2 = ShiftExpression()
+ {
+ buff.append(operator.image);
+ buff.append(expr2);
+ }
+ )*
+ {return buff.toString();}
}
-void ShiftExpression() :
-{}
+String ShiftExpression() :
+{
+ String expr;
+ Token operator;
+ String expr2;
+ StringBuffer buff = new StringBuffer();
+}
{
- AdditiveExpression() ( ( <LSHIFT> | <RSIGNEDSHIFT> | <RUNSIGNEDSHIFT> ) AdditiveExpression() )*
+ expr = AdditiveExpression()
+ {buff.append(expr);}
+ (
+ (operator = <LSHIFT> | operator = <RSIGNEDSHIFT> | operator = <RUNSIGNEDSHIFT> ) expr2 = AdditiveExpression()
+ {
+ buff.append(operator.image);
+ buff.append(expr2);
+ }
+ )*
+ {return buff.toString();}
}
-void AdditiveExpression() :
-{}
+String AdditiveExpression() :
{
- MultiplicativeExpression() ( ( <PLUS> | <MINUS> ) MultiplicativeExpression() )*
+ String expr;
+ Token operator;
+ String expr2;
+ StringBuffer buff = new StringBuffer();
+}
+{
+ expr = MultiplicativeExpression()
+ {buff.append(expr);}
+ (
+ ( operator = <PLUS> | operator = <MINUS> ) expr2 = MultiplicativeExpression()
+ {
+ buff.append(operator.image);
+ buff.append(expr2);
+ }
+ )*
+ {return buff.toString();}
}
-void MultiplicativeExpression() :
-{}
+String MultiplicativeExpression() :
+{
+ String expr, expr2;
+ Token operator;
+ final StringBuffer buff = new StringBuffer();}
{
- UnaryExpression() ( ( <STAR> | <SLASH> | <REM> ) UnaryExpression() )*
+ expr = UnaryExpression()
+ {buff.append(expr);}
+ (
+ ( operator = <STAR> | operator = <SLASH> | operator = <REM> ) expr2 = UnaryExpression()
+ {
+ buff.append(operator.image);
+ buff.append(expr2);
+ }
+ )*
+ {return buff.toString();}
}
-void UnaryExpression() :
-{}
+String UnaryExpression() :
{
- <AT> UnaryExpression()
+ String expr;
+ final StringBuffer buff = new StringBuffer();
+}
+{
+ <AT> expr = UnaryExpression()
+ {return "@" + expr;}
|
- ( <PLUS> | <MINUS> ) UnaryExpression()
+ ( <PLUS> {buff.append("+");}| <MINUS> {buff.append("-");}) expr = UnaryExpression()
+ {
+ buff.append(expr);
+ return buff.toString();
+ }
|
- PreIncrementExpression()
+ expr = PreIncrementExpression()
+ {return expr;}
|
- PreDecrementExpression()
+ expr = PreDecrementExpression()
+ {return expr;}
|
- UnaryExpressionNotPlusMinus()
+ expr = UnaryExpressionNotPlusMinus()
+ {return expr;}
}
-void PreIncrementExpression() :
-{}
+String PreIncrementExpression() :
+{
+String expr;
+}
{
- <INCR> PrimaryExpression()
+ <INCR> expr = PrimaryExpression()
+ {return "++"+expr;}
}
-void PreDecrementExpression() :
-{}
+String PreDecrementExpression() :
+{
+String expr;
+}
{
- <DECR> PrimaryExpression()
+ <DECR> expr = PrimaryExpression()
+ {return "--"+expr;}
}
-void UnaryExpressionNotPlusMinus() :
-{}
+String UnaryExpressionNotPlusMinus() :
{
- <BANG> UnaryExpression()
+ String expr;
+}
+{
+ <BANG> expr = UnaryExpression()
+ {return "!" + expr;}
|
LOOKAHEAD( <LPAREN> Type() <RPAREN> )
- CastExpression()
+ expr = CastExpression()
+ {return expr;}
|
- PostfixExpression()
+ expr = PostfixExpression()
+ {return expr;}
|
- Literal()
+ expr = Literal()
+ {return expr;}
|
- <LPAREN>Expression()<RPAREN>
+ <LPAREN> expr = Expression()<RPAREN>
+ {return "("+expr+")";}
}
-void CastExpression() :
-{}
+String CastExpression() :
+{
+String type;
+String expr;
+}
{
- <LPAREN> Type() <RPAREN> UnaryExpression()
+ <LPAREN> type = Type() <RPAREN> expr = UnaryExpression()
+ {return "(" + type + ")" + expr;}
}
-void PostfixExpression() :
-{}
+String PostfixExpression() :
+{
+ String expr;
+ Token operator = null;
+}
{
- PrimaryExpression() [ <INCR> | <DECR> ]
+ expr = PrimaryExpression() [ operator = <INCR> | operator = <DECR> ]
+ {
+ if (operator == null) {
+ return expr;
+ }
+ return expr + operator.image;
+ }
}
-void PrimaryExpression() :
-{}
+String PrimaryExpression() :
+{
+ Token identifier;
+ String expr;
+ final StringBuffer buff = new StringBuffer();
+}
{
LOOKAHEAD(2)
- <IDENTIFIER> <STATICCLASSACCESS> ClassIdentifier() (PrimarySuffix())*
+ identifier = <IDENTIFIER> <STATICCLASSACCESS> expr = ClassIdentifier()
+ {buff.append(identifier.image).append("::").append(expr);}
+ (
+ expr = PrimarySuffix()
+ {buff.append(expr);}
+ )*
+ {return buff.toString();}
|
- PrimaryPrefix() ( PrimarySuffix() )*
+ expr = PrimaryPrefix() {buff.append(expr);}
+ ( expr = PrimarySuffix() {buff.append(expr);} )*
+ {return buff.toString();}
|
- <ARRAY> ArrayInitializer()
+ <ARRAY> expr = ArrayInitializer()
+ {return "array" + expr;}
}
-void PrimaryPrefix() :
-{}
+String PrimaryPrefix() :
+{
+ String expr;
+ Token token = null;
+}
{
- <IDENTIFIER>
+ token = <IDENTIFIER>
+ {return token.image;}
|
- <NEW> ClassIdentifier()
+ [token = <BIT_AND>] <NEW> expr = ClassIdentifier()
+ {
+ if (token == null) {
+ return "new " + expr;
+ }
+ return "new &" + expr;
+ }
|
- VariableDeclaratorId()
+ expr = VariableDeclaratorId()
+ {return expr;}
}
-void ClassIdentifier():
-{}
+String ClassIdentifier():
+{
+ String expr;
+ Token token;
+}
{
- <IDENTIFIER>
+ token = <IDENTIFIER>
+ {return token.image;}
|
- VariableDeclaratorId()
+ expr = VariableDeclaratorId()
+ {return expr;}
}
-void PrimarySuffix() :
-{}
+String PrimarySuffix() :
{
- Arguments()
+ String expr;
+}
+{
+ expr = Arguments()
+ {return expr;}
|
- VariableSuffix()
+ expr = VariableSuffix()
+ {return expr;}
}
-void VariableSuffix() :
-{}
+String VariableSuffix() :
+{
+ String expr = null;
+}
{
- <CLASSACCESS> VariableName()
+ <CLASSACCESS> expr = VariableName()
+ {return "->" + expr;}
|
- <LBRACKET> [ Expression() ] <RBRACKET>
+ <LBRACKET> [ expr = Expression() ] <RBRACKET>
+ {
+ if(expr == null) {
+ return "[]";
+ }
+ return "[" + expr + "]";
+ }
}
-void Literal() :
-{}
+String Literal() :
{
- <INTEGER_LITERAL>
+ String expr;
+ Token token;
+}
+{
+ token = <INTEGER_LITERAL>
+ {return token.image;}
|
- <FLOATING_POINT_LITERAL>
+ token = <FLOATING_POINT_LITERAL>
+ {return token.image;}
|
- <STRING_LITERAL>
+ try {
+ token = <STRING_LITERAL>
+ {return token.image;}
+ } catch (TokenMgrError e) {
+ errorMessage = "unterminated string";
+ errorLevel = ERROR;
+ throw generateParseException();
+ }
|
- BooleanLiteral()
+ expr = BooleanLiteral()
+ {return expr;}
|
- NullLiteral()
+ expr = NullLiteral()
+ {return expr;}
}
-void BooleanLiteral() :
+String BooleanLiteral() :
{}
{
<TRUE>
+ {return "true";}
|
<FALSE>
+ {return "false";}
}
-void NullLiteral() :
+String NullLiteral() :
{}
{
<NULL>
+ {return "null";}
}
-void Arguments() :
-{}
+String Arguments() :
{
- <LPAREN> [ ArgumentList() ] <RPAREN>
+String expr = null;
+}
+{
+ <LPAREN> [ expr = ArgumentList() ]
+ try {
+ <RPAREN>
+ } catch (ParseException e) {
+ errorMessage = "')' expected to close the argument list";
+ errorLevel = ERROR;
+ throw e;
+ }
+ {
+ if (expr == null) {
+ return "()";
+ }
+ return "(" + expr + ")";
+ }
}
-void ArgumentList() :
-{}
+String ArgumentList() :
{
- Expression() ( <COMMA> Expression() )*
+String expr;
+StringBuffer buff = new StringBuffer();
+}
+{
+ expr = Expression()
+ {buff.append(expr);}
+ ( <COMMA>
+ try {
+ expr = Expression()
+ } catch (ParseException e) {
+ errorMessage = "expression expected after a comma in argument list";
+ errorLevel = ERROR;
+ throw e;
+ }
+ {
+ buff.append(",").append("expr");
+ }
+ )*
+ {return buff.toString();}
}
/*
|
EchoStatement()
|
- IncludeStatement()
+ [<AT>] IncludeStatement()
|
StaticStatement()
|
}
void IncludeStatement() :
-{}
{
- <REQUIRE> Expression() (<SEMICOLON> | "?>")
+ Token token;
+ String expr;
+ int pos;
+}
+{
+ token = <REQUIRE>
+ {pos = token.beginLine;}
+ expr = Expression()
+ {currentSegment.add(new PHPReqIncDeclaration(currentSegment, "require",pos,expr));}
+ (<SEMICOLON> | "?>")
|
- <REQUIRE_ONCE> Expression() (<SEMICOLON> | "?>")
+ token = <REQUIRE_ONCE>
+ {pos = token.beginLine;}
+ expr = Expression()
+ {currentSegment.add(new PHPReqIncDeclaration(currentSegment, "require_once",pos,expr));}
+ (<SEMICOLON> | "?>")
|
- <INCLUDE> Expression() (<SEMICOLON> | "?>")
+ token = <INCLUDE>
+ {pos = token.beginLine;}
+ expr = Expression()
+ {currentSegment.add(new PHPReqIncDeclaration(currentSegment, "include",pos,expr));}
+ (<SEMICOLON> | "?>")
|
- <INCLUDE_ONCE> Expression() (<SEMICOLON> | "?>")
+ token = <INCLUDE_ONCE>
+ {pos = token.beginLine;}
+ expr = Expression()
+ {currentSegment.add(new PHPReqIncDeclaration(currentSegment, "include_once",pos,expr));}
+ (<SEMICOLON> | "?>")
}
-void PrintExpression() :
-{}
+String PrintExpression() :
+{
+ StringBuffer buff = new StringBuffer("print ");
+ String expr;
+}
{
- <PRINT> Expression()
+ <PRINT> expr = Expression()
+ {
+ buff.append(expr);
+ return buff.toString();
+ }
}
void EchoStatement() :
void Block() :
{}
{
- <LBRACE> ( BlockStatement() )* <RBRACE>
+ try {
+ <LBRACE>
+ } catch (ParseException e) {
+ errorMessage = "'{' expected";
+ errorLevel = ERROR;
+ throw e;
+ }
+ ( BlockStatement() )*
+ <RBRACE>
}
void BlockStatement() :
*/
{}
{
- <IF> Condition("if") Statement() [ LOOKAHEAD(1) ElseIfStatement() ] [ LOOKAHEAD(1) <ELSE> Statement() ]
+ <IF> Condition("if") Statement() ( LOOKAHEAD(1) ElseIfStatement() )* [ LOOKAHEAD(1) <ELSE> Statement() ]
}
void Condition(String keyword) :
git://secure.phpeclipse.com / phpeclipse.git / blobdiff