X-Git-Url: http://secure.phpeclipse.com

diff --git a/net.sourceforge.phpeclipse/src/test/PHPParser.jj b/net.sourceforge.phpeclipse/src/test/PHPParser.jj
index 57e9eb8..a6bce7c 100644
--- a/net.sourceforge.phpeclipse/src/test/PHPParser.jj
+++ b/net.sourceforge.phpeclipse/src/test/PHPParser.jj
@@ -28,7 +28,6 @@ import org.eclipse.core.runtime.CoreException;
 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;
@@ -36,6 +35,9 @@ 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;
 
 /**
  * A new php parser.
@@ -46,10 +48,11 @@ import net.sourceforge.phpdt.internal.compiler.parser.PHPOutlineInfo;
  */
 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;
@@ -62,28 +65,10 @@ public class PHPParser extends PHPParserSuperclass {
   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;
@@ -105,11 +90,12 @@ public class PHPParser extends PHPParserSuperclass {
       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);
@@ -228,7 +214,12 @@ public class PHPParser extends PHPParserSuperclass {
     try {
       parse();
     } catch (ParseException e) {
-      PHPeclipsePlugin.log(e);
+      if (errorMessage == null) {
+        PHPeclipsePlugin.log(e);
+      } else {
+        setMarker(errorMessage, e.currentToken.beginLine, errorLevel);
+        errorMessage = null;
+      }
     }
   }
 
@@ -263,20 +254,20 @@ PARSER_END(PHPParser)
 
 <DEFAULT> TOKEN :
 {
-  "<?php" : PHPPARSING
-| "<?"    : PHPPARSING
+  <PHPSTART : "<?php" | "<?"> : PHPPARSING
 }
 
-<DEFAULT> SKIP :
+<PHPPARSING> TOKEN :
 {
- < ~[] >
+  <PHPEND :"?>"> : DEFAULT
 }
 
-<PHPPARSING> TOKEN :
+<DEFAULT> SKIP :
 {
-  "?>" : DEFAULT
+ < ~[] >
 }
 
+
 /* WHITE SPACE */
 
 <PHPPARSING> SKIP :
@@ -545,7 +536,7 @@ void phpTest() :
 void phpFile() :
 {}
 {
- ("<?php" Php() "?>")*
+  (<PHPSTART> Php() <PHPEND>)*
   <EOF>
 }
 
@@ -556,10 +547,22 @@ void Php() :
 }
 
 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() :
@@ -582,337 +585,782 @@ void FieldDeclaration() :
   <VAR> VariableDeclarator() ( <COMMA> VariableDeclarator() )* <SEMICOLON>
 }
 
-void VariableDeclarator() :
-{}
+String VariableDeclarator() :
 {
-  VariableDeclaratorId() [ <ASSIGN> VariableInitializer() ]
+  String expr;
+  StringBuffer buff = new StringBuffer();
+}
+{
+  expr = VariableDeclaratorId()
+  {buff.append(expr);}
+  [ <ASSIGN> expr = VariableInitializer()
+    {buff.append("=").append(expr);}
+  ]
+  {return buff.toString();}
 }
 
-void VariableDeclaratorId() :
-{}
+String VariableDeclaratorId() :
+{
+  String expr;
+  StringBuffer buff = new StringBuffer();
+}
 {
-  Variable() ( LOOKAHEAD(2) VariableSuffix() )*
+  expr = Variable()
+  {buff.append(expr);}
+  ( LOOKAHEAD(2) expr = VariableSuffix()
+  {buff.append(expr);}
+  )*
+  {return buff.toString();}
 }
 
-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():
 {
-  <LBRACE> Expression() <RBRACE>
-|
-  <IDENTIFIER> (<LBRACE> Expression() <RBRACE>) *
+String expr = null;
+Token token;
+}
+{
+  <LBRACE> expr = Expression() <RBRACE>
+  {return "{"+expr+"}";}
 |
-  <DOLLAR> VariableName()
+  token = <IDENTIFIER> [<LBRACE> expr = Expression() <RBRACE>]
+  {
+    if (expr == null) {
+      return token.image;
+    }
+    return token + "{" + expr + "}";
+  }|
+  <DOLLAR> expr = VariableName()
+  {return "$" + expr;}
 }
 
-void VariableInitializer() :
-{}
+String VariableInitializer() :
 {
-  Expression()
+  String expr;
+}
+{
+  expr = Expression()
+  {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() :
 {
-  <LPAREN> [ ArrayVariable() ( LOOKAHEAD(2) <COMMA> ArrayVariable() )* ]<RPAREN>
+String expr = null;
+StringBuffer buff = new StringBuffer("(");
+}
+{
+  <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()
+  PHPFunctionDeclaration functionDeclaration;
+}
+{
+  <FUNCTION> functionDeclaration = MethodDeclarator()
+  {
+    currentSegment.add(functionDeclaration);
+    currentSegment = functionDeclaration;
+  }
   ( Block() | <SEMICOLON> )
+  {
+    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> formalParameters = FormalParameters()
+  {
+    methodDeclaration.append(identifier).append(formalParameters);
+    return new PHPFunctionDeclaration(currentSegment,methodDeclaration.toString(),pos);
+  }
 }
 
-void FormalParameters() :
-{}
+String FormalParameters() :
+{
+  String expr;
+  StringBuffer buff = new StringBuffer("(");
+}
 {
-  <LPAREN> [ FormalParameter() ( <COMMA> FormalParameter() )* ] <RPAREN>
+  <LPAREN> [ expr = FormalParameter() {buff.append(expr);}
+            ( <COMMA> expr = FormalParameter()
+            {buff.append(",").append(expr);}
+            )* ] <RPAREN>
+ {
+  buff.append(")");
+  return buff.toString();
+ }
 }
 
-void FormalParameter() :
-{}
+String FormalParameter() :
 {
-  [<BIT_AND>] VariableDeclarator()
+  String expr;
+  StringBuffer buff = new StringBuffer();
+}
+{
+  [<BIT_AND> {buff.append("&");}] expr = VariableDeclarator()
+  {
+    buff.append(expr);
+    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() :
 {
-  PrintExpression()
+  String expr;
+  String assignOperator = null;
+  String expr2 = null;
+}
+{
+  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() :
 {
-  ConcatExpression() ( (<SC_AND> | <_ANDL>) ConcatExpression() )*
+  String expr;
+  Token operator;
+  String expr2 = null;
+  StringBuffer buff = new StringBuffer();
+}
+{
+  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() :
 {
-  ShiftExpression() ( ( <LT> | <GT> | <LE> | <GE> ) ShiftExpression() )*
+  String expr;
+  Token operator;
+  String expr2;
+  StringBuffer buff = new StringBuffer();
+}
+{
+  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() :
 {
-  AdditiveExpression() ( ( <LSHIFT> | <RSIGNEDSHIFT> | <RUNSIGNEDSHIFT> ) AdditiveExpression() )*
+  String expr;
+  Token operator;
+  String expr2;
+  StringBuffer buff = new StringBuffer();
+}
+{
+  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() :
 {
-  UnaryExpression() ( ( <STAR> | <SLASH> | <REM> ) UnaryExpression() )*
+  String expr;
+  Token operator;
+  String expr2;
+  StringBuffer buff = new StringBuffer();}
+{
+  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;
+  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 buff.toString();}
 }
 
-void PreIncrementExpression() :
-{}
+String PreIncrementExpression() :
 {
-  <INCR> PrimaryExpression()
+String expr;
+}
+{
+  <INCR> expr = PrimaryExpression()
+  {return "++"+expr;}
 }
 
-void PreDecrementExpression() :
-{}
+String PreDecrementExpression() :
+{
+String expr;
+}
 {
-  <DECR> PrimaryExpression()
+  <DECR> expr = PrimaryExpression()
+  {return "--"+expr;}
 }
 
-void UnaryExpressionNotPlusMinus() :
-{}
+String UnaryExpressionNotPlusMinus() :
+{
+  String expr;
+}
 {
-  <BANG> UnaryExpression()
+  <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;
+  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() :
 {
-  <IDENTIFIER>
+  String expr;
+  Token token = null;
+}
+{
+  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():
 {
-  <IDENTIFIER>
+  String expr;
+  Token token;
+}
+{
+  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() :
 {
-  <CLASSACCESS> VariableName()
+  String expr = null;
+}
+{
+  <CLASSACCESS> expr = VariableName()
+  {return "->" + expr;}
 | 
-  <LBRACKET> [ Expression() ] <RBRACKET>
+  <LBRACKET> [ expr = Expression() ] <RBRACKET>
+  {
+    if(expr == null) {
+      return "[]";
+    }
+    return "[" + expr + "]";
+  }
 }
 
-void Literal() :
-{}
+String Literal() :
+{
+  String expr;
+  Token token;
+}
 {
-  <INTEGER_LITERAL>
+  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() :
+{
+String expr = null;
+}
 {
-  <LPAREN> [ ArgumentList() ] <RPAREN>
+  <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();}
 }
 
 /*
@@ -978,10 +1426,17 @@ void IncludeStatement() :
   <INCLUDE_ONCE> Expression() (<SEMICOLON> | "?>")
 }
 
-void PrintExpression() :
-{}
+String PrintExpression() :
 {
-  <PRINT> Expression()
+  StringBuffer buff = new StringBuffer("print ");
+  String expr;
+}
+{
+  <PRINT> expr = Expression()
+  {
+    buff.append(expr);
+    return buff.toString();
+  }
 }
 
 void EchoStatement() :
@@ -1089,7 +1544,7 @@ void IfStatement() :
  */
 {}
 {
-  <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) :