*** empty log message ***
[phpeclipse.git] / net.sourceforge.phpeclipse / src / test / PHPParser.jj
index 57e9eb8..9327af8 100644 (file)
@@ -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,11 @@ 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.
@@ -44,17 +48,15 @@ import net.sourceforge.phpdt.internal.compiler.parser.PHPOutlineInfo;
  * You can test the parser with the PHPParserTestCase2.java
  * @author Matthieu Casanova
  */
-public class PHPParser extends PHPParserSuperclass {
-
-  private static PHPParser me;
+public final class PHPParser extends PHPParserSuperclass {
 
   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;
@@ -62,36 +64,18 @@ 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) {
+  public final void setFileToParse(final 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) {
+  public PHPParser(final IFile fileToParse) {
     this(new StringReader(""));
     this.fileToParse = fileToParse;
   }
 
-  public void phpParserTester(String strEval) throws CoreException, ParseException {
+  public static final void phpParserTester(final String strEval) throws CoreException, ParseException {
     PHPParserTokenManager.SwitchTo(PHPParserTokenManager.PHPPARSING);
-    StringReader stream = new StringReader(strEval);
+    final StringReader stream = new StringReader(strEval);
     if (jj_input_stream == null) {
       jj_input_stream = new SimpleCharStream(stream, 1, 1);
     }
@@ -99,18 +83,19 @@ public class PHPParser extends PHPParserSuperclass {
     phpTest();
   }
 
-  public void htmlParserTester(String strEval) throws CoreException, ParseException {
-    StringReader stream = new StringReader(strEval);
+  public static final void htmlParserTester(final String strEval) throws CoreException, ParseException {
+    final StringReader stream = new StringReader(strEval);
     if (jj_input_stream == null) {
       jj_input_stream = new SimpleCharStream(stream, 1, 1);
     }
     ReInit(stream);
-    phpTest();
+    phpFile();
   }
 
-  public PHPOutlineInfo parseInfo(Object parent, String s) {
+  public final PHPOutlineInfo parseInfo(final Object parent, final String s) {
     outlineInfo = new PHPOutlineInfo(parent);
-    StringReader stream = new StringReader(s);
+    currentSegment = outlineInfo.getDeclarations();
+    final StringReader stream = new StringReader(s);
     if (jj_input_stream == null) {
       jj_input_stream = new SimpleCharStream(stream, 1, 1);
     }
@@ -118,57 +103,51 @@ public class PHPParser extends PHPParserSuperclass {
     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
+   * @param e the ParseException
+   */
+  private static void setMarker(final ParseException e) {
+    try {
+      setMarker(fileToParse,
+                errorMessage,
+                jj_input_stream.tokenBegin,
+                jj_input_stream.tokenBegin + e.currentToken.image.length(),
+                errorLevel,
+                "Line " + e.currentToken.beginLine);
+    } catch (CoreException e2) {
+      PHPeclipsePlugin.log(e2);
     }
   }
 
   /**
    * Create markers according to the external parser output
    */
-  private static void createMarkers(String output, IFile file) throws CoreException {
+  private static void createMarkers(final String output, final IFile file) throws CoreException {
     // delete all markers
     file.deleteMarkers(IMarker.PROBLEM, false, 0);
 
     int indx = 0;
-    int brIndx = 0;
+    int brIndx;
     boolean flag = true;
     while ((brIndx = output.indexOf("<br />", indx)) != -1) {
       // newer php error output (tested with 4.2.3)
@@ -185,7 +164,10 @@ public class PHPParser extends PHPParserSuperclass {
     }
   }
 
-  private static void scanLine(String output, IFile file, int indx, int brIndx) throws CoreException {
+  private static void scanLine(final String output,
+                               final IFile file,
+                               final int indx,
+                               final int brIndx) throws CoreException {
     String current;
     StringBuffer lineNumberBuffer = new StringBuffer(10);
     char ch;
@@ -223,12 +205,16 @@ public class PHPParser extends PHPParserSuperclass {
     }
   }
 
-  public void parse(String s) throws CoreException {
-    ReInit(new StringReader(s));
+  public final void parse(final String s) throws CoreException {
+    final StringReader stream = new StringReader(s);
+    if (jj_input_stream == null) {
+      jj_input_stream = new SimpleCharStream(stream, 1, 1);
+    }
+    ReInit(stream);
     try {
       parse();
     } catch (ParseException e) {
-      PHPeclipsePlugin.log(e);
+      processParseException(e);
     }
   }
 
@@ -236,15 +222,15 @@ public class PHPParser extends PHPParserSuperclass {
    * Call the php parse command ( php -l -f &lt;filename&gt; )
    * and create markers according to the external parser output
    */
-  public static void phpExternalParse(IFile file) {
-    IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
-    String filename = file.getLocation().toString();
+  public static void phpExternalParse(final IFile file) {
+    final IPreferenceStore store = PHPeclipsePlugin.getDefault().getPreferenceStore();
+    final String filename = file.getLocation().toString();
 
-    String[] arguments = { filename };
-    MessageFormat form = new MessageFormat(store.getString(PHPeclipsePlugin.EXTERNAL_PARSER_PREF));
-    String command = form.format(arguments);
+    final String[] arguments = { filename };
+    final MessageFormat form = new MessageFormat(store.getString(PHPeclipsePlugin.EXTERNAL_PARSER_PREF));
+    final String command = form.format(arguments);
 
-    String parserResult = PHPStartApacheAction.getParserOutput(command, "External parser: ");
+    final String parserResult = PHPStartApacheAction.getParserOutput(command, "External parser: ");
 
     try {
       // parse the buffer to find the errors and warnings
@@ -254,7 +240,7 @@ public class PHPParser extends PHPParserSuperclass {
     }
   }
 
-  public void parse() throws ParseException {
+  public static final void parse() throws ParseException {
          phpFile();
   }
 }
@@ -263,20 +249,22 @@ PARSER_END(PHPParser)
 
 <DEFAULT> TOKEN :
 {
-  "<?php" : PHPPARSING
-| "<?"    : PHPPARSING
+  <PHPSTARTSHORT : "<?"> : PHPPARSING
+| <PHPSTARTLONG : "<?php"> : PHPPARSING
+| <PHPECHOSTART : "<?=">      : PHPPARSING
 }
 
-<DEFAULT> SKIP :
+<PHPPARSING> TOKEN :
 {
- < ~[] >
+  <PHPEND :"?>"> : DEFAULT
 }
 
-<PHPPARSING> TOKEN :
+<DEFAULT> SKIP :
 {
-  "?>" : DEFAULT
+ < ~[] >
 }
 
+
 /* WHITE SPACE */
 
 <PHPPARSING> SKIP :
@@ -290,7 +278,7 @@ PARSER_END(PHPParser)
 
 /* COMMENTS */
 
-<PHPPARSING> MORE :
+<PHPPARSING> SPECIAL_TOKEN :
 {
   "//" : IN_SINGLE_LINE_COMMENT
 |
@@ -299,10 +287,14 @@ PARSER_END(PHPParser)
   "/*" : IN_MULTI_LINE_COMMENT
 }
 
-<IN_SINGLE_LINE_COMMENT>
-SPECIAL_TOKEN :
+<IN_SINGLE_LINE_COMMENT> SPECIAL_TOKEN :
+{
+  <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" > : PHPPARSING
+}
+
+<IN_SINGLE_LINE_COMMENT> SPECIAL_TOKEN :
 {
-  <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" | "?>" > : PHPPARSING
+  <SINGLE_LINE_COMMENT_PHPEND : "?>" > : DEFAULT
 }
 
 <IN_FORMAL_COMMENT>
@@ -333,68 +325,76 @@ MORE :
 | <ELSEIF   : "elseif">
 | <ELSE     : "else">
 | <ARRAY    : "array">
+| <BREAK    : "break">
 }
 
 /* LANGUAGE CONSTRUCT */
 <PHPPARSING> TOKEN :
 {
-  <PRINT : "print">
-| <ECHO : "echo">
-| <INCLUDE : "include">
-| <REQUIRE : "require">
-| <INCLUDE_ONCE : "include_once">
-| <REQUIRE_ONCE : "require_once">
-| <GLOBAL : "global">
-| <STATIC : "static">
-| <CLASSACCESS: "->">
-| <STATICCLASSACCESS: "::">
-| <ARRAYASSIGN: "=>">
+  <PRINT              : "print">
+| <ECHO               : "echo">
+| <INCLUDE            : "include">
+| <REQUIRE            : "require">
+| <INCLUDE_ONCE       : "include_once">
+| <REQUIRE_ONCE       : "require_once">
+| <GLOBAL             : "global">
+| <STATIC             : "static">
+| <CLASSACCESS        : "->">
+| <STATICCLASSACCESS  : "::">
+| <ARRAYASSIGN        : "=>">
 }
 
+<PHPPARSING> TOKEN :
+{
+  <LIST   : "list">
+}
 /* RESERVED WORDS AND LITERALS */
 
 <PHPPARSING> TOKEN :
 {
-  < BREAK: "break" >
-| < CASE: "case" >
-| < CONST: "const" >
-| < CONTINUE: "continue" >
-| < _DEFAULT: "default" >
-| < DO: "do" >
-| < EXTENDS: "extends" >
-| < FALSE: "false" >
-| < FOR: "for" >
-| < GOTO: "goto" >
-| < NEW: "new" >
-| < NULL: "null" >
-| < RETURN: "return" >
-| < SUPER: "super" >
-| < SWITCH: "switch" >
-| < THIS: "this" >
-| < TRUE: "true" >
-| < WHILE: "while" >
-| < ENDWHILE : "endwhile" >
+  <CASE     : "case">
+| <CONST    : "const">
+| <CONTINUE : "continue">
+| <_DEFAULT : "default">
+| <DO       : "do">
+| <EXTENDS  : "extends">
+| <FOR      : "for">
+| <GOTO     : "goto">
+| <NEW      : "new">
+| <NULL     : "null">
+| <RETURN   : "return">
+| <SUPER    : "super">
+| <SWITCH   : "switch">
+| <THIS     : "this">
+| <TRUE     : "true">
+| <FALSE    : "false">
+| <WHILE    : "while">
+| <ENDWHILE : "endwhile">
+| <ENDIF    : "endif">
+| <ENDFOR   : "endfor">
+| <FOREACH  : "foreach">
+| <AS       : "as" >
 }
 
 /* TYPES */
 
 <PHPPARSING> TOKEN :
 {
-  <STRING : "string">
-| <OBJECT : "object">
-| <BOOL : "bool">
+  <STRING  : "string">
+| <OBJECT  : "object">
+| <BOOL    : "bool">
 | <BOOLEAN : "boolean">
-| <REAL : "real">
-| <DOUBLE : "double">
-| <FLOAT : "float">
-| <INT : "int">
+| <REAL    : "real">
+| <DOUBLE  : "double">
+| <FLOAT   : "float">
+| <INT     : "int">
 | <INTEGER : "integer">
 }
 
 <PHPPARSING> TOKEN :
 {
-  < _ORL : "OR" >
-| < _ANDL: "AND">
+  <_ORL  : "OR">
+| <_ANDL : "AND">
 }
 
 /* LITERALS */
@@ -425,20 +425,30 @@ MORE :
   < STRING_LITERAL: (<STRING_1> | <STRING_2> | <STRING_3>)>
 |    < STRING_1:
       "\""
-      (   (~["\""])
-        | "\\\""
+      (
+        ~["\""]
+        |
+        "\\\""
       )*
       "\""
     >
 |    < STRING_2:
       "'"
-      (   (~["'"]))*
+      (
+      ~["'"]
+       |
+       "\\'"
+      )*
 
       "'"
     >
 |   < STRING_3:
       "`"
-      (   (~["`"]))*
+      (
+        ~["`"]
+      |
+        "\\`"
+      )*
       "`"
     >
 }
@@ -458,7 +468,7 @@ MORE :
   >
 |
   < #SPECIAL:
-    "_"
+    "_" | ["\u007f"-"\u00ff"]
   >
 }
 
@@ -466,74 +476,79 @@ MORE :
 
 <PHPPARSING> TOKEN :
 {
-  < LPAREN: "(" >
-| < RPAREN: ")" >
-| < LBRACE: "{" >
-| < RBRACE: "}" >
-| < LBRACKET: "[" >
-| < RBRACKET: "]" >
-| < SEMICOLON: ";" >
-| < COMMA: "," >
-| < DOT: "." >
+  <LPAREN    : "(">
+| <RPAREN    : ")">
+| <LBRACE    : "{">
+| <RBRACE    : "}">
+| <LBRACKET  : "[">
+| <RBRACKET  : "]">
+| <SEMICOLON : ";">
+| <COMMA     : ",">
+| <DOT       : ".">
 }
 
-/* OPERATORS */
 
+/* COMPARATOR */
 <PHPPARSING> TOKEN :
 {
-  <AT     : "@">
-| <DOLLAR : "$">
-| < ASSIGN: "=" >
-| < GT: ">" >
-| < LT: "<" >
-| < BANG: "!" >
-| < HOOK: "?" >
-| < COLON: ":" >
-| < EQ: "==" >
-| < LE: "<=" >
-| < GE: ">=" >
-| < NE: "!=" >
-| < SC_OR: "||" >
-| < SC_AND: "&&" >
-| < INCR: "++" >
-| < DECR: "--" >
-| < PLUS: "+" >
-| < MINUS: "-" >
-| < STAR: "*" >
-| < SLASH: "/" >
-| < BIT_AND: "&" >
-| < BIT_OR: "|" >
-| < XOR: "^" >
-| < REM: "%" >
-| < LSHIFT: "<<" >
-| < RSIGNEDSHIFT: ">>" >
-| < RUNSIGNEDSHIFT: ">>>" >
-| < PLUSASSIGN: "+=" >
-| < MINUSASSIGN: "-=" >
-| < STARASSIGN: "*=" >
-| < SLASHASSIGN: "/=" >
-| < ANDASSIGN: "&=" >
-| < ORASSIGN: "|=" >
-| < XORASSIGN: "^=" >
-| < DOTASSIGN: ".=" >
-| < REMASSIGN: "%=" >
-| < LSHIFTASSIGN: "<<=" >
-| < RSIGNEDSHIFTASSIGN: ">>=" >
-| < RUNSIGNEDSHIFTASSIGN: ">>>=" >
+  <GT                 : ">">
+| <LT                 : "<">
+| <EQ                 : "==">
+| <LE                 : "<=">
+| <GE                 : ">=">
+| <NE                 : "!=">
+| <DIF                : "<>">
+| <BANGDOUBLEEQUAL    : "!==">
+| <TRIPLEEQUAL        : "===">
 }
 
+/* ASSIGNATION */
 <PHPPARSING> TOKEN :
 {
-  < DOLLAR_ID: <DOLLAR> <IDENTIFIER>  >
+  <ASSIGN             : "=">
+| <PLUSASSIGN         : "+=">
+| <MINUSASSIGN        : "-=">
+| <STARASSIGN         : "*=">
+| <SLASHASSIGN        : "/=">
+| <ANDASSIGN          : "&=">
+| <ORASSIGN           : "|=">
+| <XORASSIGN          : "^=">
+| <DOTASSIGN          : ".=">
+| <REMASSIGN          : "%=">
+| <TILDEEQUAL         : "~=">
 }
 
-/*****************************************
- * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
- *****************************************/
+/* OPERATORS */
+<PHPPARSING> TOKEN :
+{
+  <AT                 : "@">
+| <DOLLAR             : "$">
+| <BANG               : "!">
+| <HOOK               : "?">
+| <COLON              : ":">
+| <SC_OR              : "||">
+| <SC_AND             : "&&">
+| <INCR               : "++">
+| <DECR               : "--">
+| <PLUS               : "+">
+| <MINUS              : "-">
+| <STAR               : "*">
+| <SLASH              : "/">
+| <BIT_AND            : "&">
+| <BIT_OR             : "|">
+| <XOR                : "^">
+| <REM                : "%">
+| <LSHIFT             : "<<">
+| <RSIGNEDSHIFT       : ">>">
+| <RUNSIGNEDSHIFT     : ">>>">
+| <LSHIFTASSIGN       : "<<=">
+| <RSIGNEDSHIFTASSIGN : ">>=">
+}
 
-/*
- * Program structuring syntax follows.
- */
+<PHPPARSING> TOKEN :
+{
+  < DOLLAR_ID: <DOLLAR> <IDENTIFIER>  >
+}
 
 void phpTest() :
 {}
@@ -545,8 +560,44 @@ void phpTest() :
 void phpFile() :
 {}
 {
- ("<?php" Php() "?>")*
-  <EOF>
+  try {
+    (PhpBlock())*
+    <EOF>
+  } catch (TokenMgrError e) {
+    errorMessage = e.getMessage();
+    errorLevel   = ERROR;
+    throw generateParseException();
+  }
+}
+
+void PhpBlock() :
+{
+  final int start = jj_input_stream.bufpos;
+}
+{
+  <PHPECHOSTART> Expression() [ <SEMICOLON> ] <PHPEND>
+|
+  [ <PHPSTARTLONG>
+    | <PHPSTARTSHORT>
+    {try {
+      setMarker(fileToParse,
+                "You should use '<?php' instead of '<?' it will avoid some problems with XML",
+                start,
+                jj_input_stream.bufpos,
+                INFO,
+                "Line " + token.beginLine);
+    } catch (CoreException e) {
+      PHPeclipsePlugin.log(e);
+    }}
+  ]
+  Php()
+  try {
+    <PHPEND>
+  } catch (ParseException e) {
+    errorMessage = "'?>' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
 }
 
 void Php() :
@@ -556,16 +607,46 @@ void Php() :
 }
 
 void ClassDeclaration() :
-{}
 {
-  <CLASS> <IDENTIFIER> [ <EXTENDS> <IDENTIFIER> ]
+  final PHPClassDeclaration classDeclaration;
+  final Token className;
+  final int pos = jj_input_stream.bufpos;
+}
+{
+  <CLASS> className = <IDENTIFIER> [ <EXTENDS> <IDENTIFIER> ]
+  {
+    if (currentSegment != null) {
+      classDeclaration = new PHPClassDeclaration(currentSegment,className.image,pos);
+      currentSegment.add(classDeclaration);
+      currentSegment = classDeclaration;
+    }
+  }
   ClassBody()
+  {
+    if (currentSegment != null) {
+      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() :
@@ -577,353 +658,894 @@ void ClassBodyDeclaration() :
 }
 
 void FieldDeclaration() :
-{}
 {
-  <VAR> VariableDeclarator() ( <COMMA> VariableDeclarator() )* <SEMICOLON>
+  PHPVarDeclaration variableDeclaration;
+}
+{
+  <VAR> variableDeclaration = VariableDeclarator()
+  {
+    if (currentSegment != null) {
+      currentSegment.add(variableDeclaration);
+    }
+  }
+  ( <COMMA>
+      variableDeclaration = VariableDeclarator()
+      {
+      if (currentSegment != null) {
+        currentSegment.add(variableDeclaration);
+      }
+      }
+  )*
+  try {
+    <SEMICOLON>
+  } catch (ParseException e) {
+    errorMessage = "';' expected after variable declaration";
+    errorLevel   = ERROR;
+    throw e;
+  }
 }
 
-void VariableDeclarator() :
-{}
+PHPVarDeclaration VariableDeclarator() :
 {
-  VariableDeclaratorId() [ <ASSIGN> VariableInitializer() ]
+  final String varName;
+  String varValue;
+  final int pos = jj_input_stream.bufpos;
+}
+{
+  varName = VariableDeclaratorId()
+  [
+    <ASSIGN>
+    try {
+      varValue = VariableInitializer()
+      {return new PHPVarDeclaration(currentSegment,varName,pos,varValue);}
+    } catch (ParseException e) {
+      errorMessage = "Literal expression expected in variable initializer";
+      errorLevel   = ERROR;
+      throw e;
+    }
+  ]
+  {return new PHPVarDeclaration(currentSegment,varName,pos);}
 }
 
-void VariableDeclaratorId() :
-{}
+String VariableDeclaratorId() :
 {
-  Variable() ( LOOKAHEAD(2) VariableSuffix() )*
+  String expr;
+  final StringBuffer buff = new StringBuffer();
+}
+{
+  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;
+  final 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;
+final Token token;
+}
 {
-  <LBRACE> Expression() <RBRACE>
+  <LBRACE> expr = Expression() <RBRACE>
+  {return "{"+expr+"}";}
 |
-  <IDENTIFIER> (<LBRACE> Expression() <RBRACE>) *
+  token = <IDENTIFIER> [<LBRACE> expr = Expression() <RBRACE>]
+  {
+    if (expr == null) {
+      return token.image;
+    }
+    return token + "{" + expr + "}";
+  }
 |
-  <DOLLAR> VariableName()
+  <DOLLAR> expr = VariableName()
+  {return "$" + expr;}
+|
+  token = <DOLLAR_ID> [expr = VariableName()]
+  {
+  if (expr == null) {
+    return token.image;
+  }
+  return token.image + expr;
+  }
 }
 
-void VariableInitializer() :
-{}
+String VariableInitializer() :
 {
-  Expression()
+  final String expr;
+  final Token token;
+}
+{
+  expr = Literal()
+  {return expr;}
+|
+  <MINUS> (token = <INTEGER_LITERAL> | token = <FLOATING_POINT_LITERAL>)
+  {return "-" + token.image;}
+|
+  <PLUS> (token = <INTEGER_LITERAL> | token = <FLOATING_POINT_LITERAL>)
+  {return "+" + token.image;}
+|
+  expr = ArrayDeclarator()
+  {return expr;}
+|
+  token = <IDENTIFIER>
+  {return token.image;}
 }
 
-void ArrayVariable() :
-{}
+String ArrayVariable() :
+{
+String expr;
+final 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;
+final 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()
-  ( Block() | <SEMICOLON> )
+  final PHPFunctionDeclaration functionDeclaration;
+}
+{
+  <FUNCTION> functionDeclaration = MethodDeclarator()
+  {
+    if (currentSegment != null) {
+      currentSegment.add(functionDeclaration);
+      currentSegment = functionDeclaration;
+    }
+  }
+  Block()
+  {
+    if (currentSegment != null) {
+      currentSegment = (PHPSegmentWithChildren) currentSegment.getParent();
+    }
+  }
 }
 
-void MethodDeclarator() :
-{}
+PHPFunctionDeclaration MethodDeclarator() :
 {
-  [<BIT_AND>] <IDENTIFIER> FormalParameters()
+  final Token identifier;
+  final StringBuffer methodDeclaration = new StringBuffer();
+  final String formalParameters;
+  final 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() :
 {
-  <LPAREN> [ FormalParameter() ( <COMMA> FormalParameter() )* ] <RPAREN>
+  String expr;
+  final StringBuffer buff = new StringBuffer("(");
+}
+{
+  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()
+  final PHPVarDeclaration variableDeclaration;
+  final 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";}
+|
+  <OBJECT>
+  {return "object";}
 }
 
-/*
- * 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()
+  final String expr;
+  final String assignOperator;
+  final String expr2;
+}
+{
+  expr = PrintExpression()
+  {return expr;}
+|
+  expr = ListExpression()
+  {return expr;}
 |
-  ConditionalExpression()
+  expr = ConditionalExpression()
   [
-    AssignmentOperator() Expression()
+    assignOperator = AssignmentOperator()
+    try {
+      expr2 = Expression()
+      {return expr + assignOperator + expr2;}
+    } catch (ParseException e) {
+      errorMessage = "expression expected";
+      errorLevel   = ERROR;
+      throw e;
+    }
   ]
+  {return expr;}
+}
+
+String AssignmentOperator() :
+{}
+{
+  <ASSIGN>
+{return "=";}
+| <STARASSIGN>
+{return "*=";}
+| <SLASHASSIGN>
+{return "/=";}
+| <REMASSIGN>
+{return "%=";}
+| <PLUSASSIGN>
+{return "+=";}
+| <MINUSASSIGN>
+{return "-=";}
+| <LSHIFTASSIGN>
+{return "<<=";}
+| <RSIGNEDSHIFTASSIGN>
+{return ">>=";}
+| <ANDASSIGN>
+{return "&=";}
+| <XORASSIGN>
+{return "|=";}
+| <ORASSIGN>
+{return "|=";}
+| <DOTASSIGN>
+{return ".=";}
+| <TILDEEQUAL>
+{return "~=";}
+}
+
+String ConditionalExpression() :
+{
+  final 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 AssignmentOperator() :
-{}
+String ConditionalOrExpression() :
 {
-  <ASSIGN> | <STARASSIGN> | <SLASHASSIGN> | <REMASSIGN> | <PLUSASSIGN> | <MINUSASSIGN> | <LSHIFTASSIGN> | <RSIGNEDSHIFTASSIGN> | <RUNSIGNEDSHIFTASSIGN> | <ANDASSIGN> | <XORASSIGN> | <ORASSIGN> | <DOTASSIGN>
+  String expr;
+  Token operator;
+  final StringBuffer buff = new StringBuffer();
 }
-
-void ConditionalExpression() :
-{}
 {
-  ConditionalOrExpression() [ <HOOK> Expression() <COLON> ConditionalExpression() ]
+  expr = ConditionalAndExpression()
+  {buff.append(expr);}
+  (
+    (operator = <SC_OR> | operator = <_ORL>) expr = ConditionalAndExpression()
+    {
+      buff.append(operator.image);
+      buff.append(expr);
+    }
+  )*
+  {
+    return buff.toString();
+  }
 }
 
-void ConditionalOrExpression() :
-{}
+String ConditionalAndExpression() :
 {
-  ConditionalAndExpression() ( (<SC_OR> | <_ORL>) ConditionalAndExpression() )*
+  String expr;
+  Token operator;
+  final StringBuffer buff = new StringBuffer();
 }
-
-void ConditionalAndExpression() :
-{}
 {
-  ConcatExpression() ( (<SC_AND> | <_ANDL>) ConcatExpression() )*
+  expr = ConcatExpression()
+  {buff.append(expr);}
+  (
+  (operator = <SC_AND> | operator = <_ANDL>) expr = ConcatExpression()
+    {
+      buff.append(operator.image);
+      buff.append(expr);
+    }
+  )*
+  {return buff.toString();}
 }
 
-void ConcatExpression() :
-{}
+String ConcatExpression() :
 {
-  InclusiveOrExpression() ( <DOT> InclusiveOrExpression() )*
+  String expr;
+  final StringBuffer buff = new StringBuffer();
 }
-
-void InclusiveOrExpression() :
-{}
 {
-  ExclusiveOrExpression() ( <BIT_OR> ExclusiveOrExpression() )*
+  expr = InclusiveOrExpression()
+  {buff.append(expr);}
+  (
+  <DOT> expr = InclusiveOrExpression()
+  {buff.append(".").append(expr);}
+  )*
+  {return buff.toString();}
 }
 
-void ExclusiveOrExpression() :
-{}
+String InclusiveOrExpression() :
+{
+  String expr;
+  final StringBuffer buff = new StringBuffer();
+}
 {
-  AndExpression() ( <XOR> AndExpression() )*
+  expr = ExclusiveOrExpression()
+  {buff.append(expr);}
+  (
+  <BIT_OR> expr = ExclusiveOrExpression()
+  {buff.append("|").append(expr);}
+  )*
+  {return buff.toString();}
 }
 
-void AndExpression() :
-{}
+String ExclusiveOrExpression() :
+{
+  String expr;
+  final StringBuffer buff = new StringBuffer();
+}
 {
-  EqualityExpression() ( <BIT_AND> EqualityExpression() )*
+  expr = AndExpression()
+  {
+    buff.append(expr);
+  }
+  (
+    <XOR> expr = AndExpression()
+  {
+    buff.append("^");
+    buff.append(expr);
+  }
+  )*
+  {
+    return buff.toString();
+  }
 }
 
-void EqualityExpression() :
-{}
+String AndExpression() :
+{
+  String expr;
+  final StringBuffer buff = new StringBuffer();
+}
 {
-  RelationalExpression() ( ( <EQ> | <NE> ) RelationalExpression() )*
+  expr = EqualityExpression()
+  {
+    buff.append(expr);
+  }
+  (
+    <BIT_AND> expr = EqualityExpression()
+  {
+    buff.append("&").append(expr);
+  }
+  )*
+  {return buff.toString();}
+}
+
+String EqualityExpression() :
+{
+  String expr;
+  Token operator;
+  final StringBuffer buff = new StringBuffer();
+}
+{
+  expr = RelationalExpression()
+  {buff.append(expr);}
+  (
+  (   operator = <EQ>
+    | operator = <DIF>
+    | operator = <NE>
+    | operator = <BANGDOUBLEEQUAL>
+    | operator = <TRIPLEEQUAL>
+  )
+  expr = RelationalExpression()
+  {
+    buff.append(operator.image);
+    buff.append(expr);
+  }
+  )*
+  {return buff.toString();}
 }
 
-void RelationalExpression() :
-{}
+String RelationalExpression() :
 {
-  ShiftExpression() ( ( <LT> | <GT> | <LE> | <GE> ) ShiftExpression() )*
+  String expr;
+  Token operator;
+  final StringBuffer buff = new StringBuffer();
+}
+{
+  expr = ShiftExpression()
+  {buff.append(expr);}
+  (
+  ( operator = <LT> | operator = <GT> | operator = <LE> | operator = <GE> ) expr = ShiftExpression()
+  {buff.append(operator.image).append(expr);}
+  )*
+  {return buff.toString();}
 }
 
-void ShiftExpression() :
-{}
+String ShiftExpression() :
 {
-  AdditiveExpression() ( ( <LSHIFT> | <RSIGNEDSHIFT> | <RUNSIGNEDSHIFT> ) AdditiveExpression() )*
+  String expr;
+  Token operator;
+  final StringBuffer buff = new StringBuffer();
+}
+{
+  expr = AdditiveExpression()
+  {buff.append(expr);}
+  (
+  (operator = <LSHIFT> | operator = <RSIGNEDSHIFT> | operator = <RUNSIGNEDSHIFT> ) expr = AdditiveExpression()
+  {
+    buff.append(operator.image);
+    buff.append(expr);
+  }
+  )*
+  {return buff.toString();}
 }
 
-void AdditiveExpression() :
-{}
+String AdditiveExpression() :
+{
+  String expr;
+  Token operator;
+  final StringBuffer buff = new StringBuffer();
+}
 {
-  MultiplicativeExpression() ( ( <PLUS> | <MINUS> ) MultiplicativeExpression() )*
+  expr = MultiplicativeExpression()
+  {buff.append(expr);}
+  (
+   ( operator = <PLUS> | operator = <MINUS> ) expr = MultiplicativeExpression()
+  {
+    buff.append(operator.image);
+    buff.append(expr);
+  }
+   )*
+  {return buff.toString();}
 }
 
-void MultiplicativeExpression() :
-{}
+String MultiplicativeExpression() :
+{
+  String expr;
+  Token operator;
+  final StringBuffer buff = new StringBuffer();}
 {
-  UnaryExpression() ( ( <STAR> | <SLASH> | <REM> ) UnaryExpression() )*
+  expr = UnaryExpression()
+  {buff.append(expr);}
+  (
+  ( operator = <STAR> | operator = <SLASH> | operator = <REM> ) expr = UnaryExpression()
+  {
+    buff.append(operator.image);
+    buff.append(expr);
+  }
+  )*
+  {return buff.toString();}
 }
 
-void UnaryExpression() :
-{}
+/**
+ * An unary expression starting with @, & or nothing
+ */
+String UnaryExpression() :
+{
+  final String expr;
+  final Token token;
+  final StringBuffer buff = new StringBuffer();
+}
 {
-  <AT> UnaryExpression()
+  token = <BIT_AND> expr = UnaryExpressionNoPrefix()
+  {
+    if (token == null) {
+      return expr;
+    }
+    return token.image + expr;
+  }
 |
-  ( <PLUS> | <MINUS> ) UnaryExpression()
+  (<AT> {buff.append("@");})* expr = UnaryExpressionNoPrefix()
+  {return buff.append(expr).toString();}
+}
+
+String UnaryExpressionNoPrefix() :
+{
+  final String expr;
+  final Token token;
+}
+{
+  ( token = <PLUS> | token = <MINUS> ) expr = UnaryExpression()
+  {
+    return token.image + expr;
+  }
 |
-  PreIncrementExpression()
+  expr = PreIncrementExpression()
+  {return expr;}
 |
-  PreDecrementExpression()
+  expr = PreDecrementExpression()
+  {return expr;}
 |
-  UnaryExpressionNotPlusMinus()
+  expr = UnaryExpressionNotPlusMinus()
+  {return expr;}
 }
 
-void PreIncrementExpression() :
-{}
+
+String PreIncrementExpression() :
+{
+final String expr;
+}
 {
-  <INCR> PrimaryExpression()
+  <INCR> expr = PrimaryExpression()
+  {return "++"+expr;}
 }
 
-void PreDecrementExpression() :
-{}
+String PreDecrementExpression() :
+{
+final String expr;
+}
 {
-  <DECR> PrimaryExpression()
+  <DECR> expr = PrimaryExpression()
+  {return "--"+expr;}
 }
 
-void UnaryExpressionNotPlusMinus() :
-{}
+String UnaryExpressionNotPlusMinus() :
 {
-  <BANG> UnaryExpression()
+  final 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()
+  try {
+    <RPAREN>
+  } catch (ParseException e) {
+    errorMessage = "')' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  {return "("+expr+")";}
 }
 
-void CastExpression() :
-{}
+String CastExpression() :
 {
-  <LPAREN> Type() <RPAREN> UnaryExpression()
+final String type, expr;
+}
+{
+  <LPAREN> type = Type() <RPAREN> expr = UnaryExpression()
+  {return "(" + type + ")" + expr;}
 }
 
-void PostfixExpression() :
-{}
+String PostfixExpression() :
 {
-  PrimaryExpression() [ <INCR> | <DECR> ]
+  final String expr;
+  Token operator = null;
+}
+{
+  expr = PrimaryExpression() [ operator = <INCR> | operator = <DECR> ]
+  {
+    if (operator == null) {
+      return expr;
+    }
+    return expr + operator.image;
+  }
 }
 
-void PrimaryExpression() :
-{}
+String PrimaryExpression() :
+{
+  final 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()
+  expr = ArrayDeclarator()
+  {return "array" + expr;}
 }
 
-void PrimaryPrefix() :
-{}
+String ArrayDeclarator() :
 {
-  <IDENTIFIER>
+  final String expr;
+}
+{
+  <ARRAY> expr = ArrayInitializer()
+  {return "array" + expr;}
+}
+
+String PrimaryPrefix() :
+{
+  final String expr;
+  final Token token;
+}
+{
+  token = <IDENTIFIER>
+  {return token.image;}
 |
-  <NEW> ClassIdentifier()
+  <NEW> expr = ClassIdentifier()
+  {
+    return "new " + expr;
+  }
 |  
-  VariableDeclaratorId()
+  expr = VariableDeclaratorId()
+  {return expr;}
 }
 
-void ClassIdentifier():
-{}
+String ClassIdentifier():
+{
+  final String expr;
+  final Token token;
+}
 {
-  <IDENTIFIER>
+  token = <IDENTIFIER>
+  {return token.image;}
 |
-  VariableDeclaratorId()
+  expr = VariableDeclaratorId()
+  {return expr;}
 }
 
-void PrimarySuffix() :
-{}
+String PrimarySuffix() :
 {
-  Arguments()
+  final String expr;
+}
+{
+  expr = Arguments()
+  {return expr;}
 |
-  VariableSuffix()
+  expr = VariableSuffix()
+  {return expr;}
 }
 
-void VariableSuffix() :
-{}
+String VariableSuffix() :
+{
+  String expr = null;
+}
 {
-  <CLASSACCESS> VariableName()
+  <CLASSACCESS>
+  try {
+    expr = VariableName()
+  } catch (ParseException e) {
+    errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', function call or field access expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  {return "->" + expr;}
 | 
-  <LBRACKET> [ Expression() ] <RBRACKET>
+  <LBRACKET> [ expr = Expression() ]
+  try {
+    <RBRACKET>
+  } catch (ParseException e) {
+    errorMessage = "']' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  {
+    if(expr == null) {
+      return "[]";
+    }
+    return "[" + expr + "]";
+  }
 }
 
-void Literal() :
-{}
+String Literal() :
 {
-  <INTEGER_LITERAL>
+  final String expr;
+  final Token token;
+}
+{
+  token = <INTEGER_LITERAL>
+  {return token.image;}
 |
-  <FLOATING_POINT_LITERAL>
+  token = <FLOATING_POINT_LITERAL>
+  {return token.image;}
 |
-  <STRING_LITERAL>
+  token = <STRING_LITERAL>
+  {return token.image;}
 |
-  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 = "unexpected token : '"+ e.currentToken.next.image +"', ')' 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;
+final 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();}
 }
 
-/*
- * Statement syntax follows.
+/**
+ * A Statement without break
  */
-
-void Statement() :
+void StatementNoBreak() :
 {}
 {
   LOOKAHEAD(2)
-  Expression()  (<SEMICOLON> | "?>")
+  Expression()
+  try {
+    (<SEMICOLON> | <PHPEND>)
+  } catch (ParseException e) {
+    errorMessage = "';' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
 |
   LOOKAHEAD(2)
   LabeledStatement()
@@ -951,7 +1573,7 @@ void Statement() :
 |
   ForStatement()
 |
-  BreakStatement()
+  ForeachStatement()
 |
   ContinueStatement()
 |
@@ -959,29 +1581,143 @@ void Statement() :
 |
   EchoStatement()
 |
-  IncludeStatement()
+  [<AT>] IncludeStatement()
 |
   StaticStatement()
 |
   GlobalStatement()
 }
 
-void IncludeStatement() :
+/**
+ * A Normal statement
+ */
+void Statement() :
 {}
 {
-  <REQUIRE> Expression() (<SEMICOLON> | "?>")
+  StatementNoBreak()
+|
+  BreakStatement()
+}
+
+void IncludeStatement() :
+{
+  final String expr;
+  final int pos = jj_input_stream.bufpos;
+}
+{
+  <REQUIRE>
+  expr = Expression()
+  {
+    if (currentSegment != null) {
+      currentSegment.add(new PHPReqIncDeclaration(currentSegment, "require",pos,expr));
+    }
+  }
+  try {
+    (<SEMICOLON> | "?>")
+  } catch (ParseException e) {
+    errorMessage = "';' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
 |
-  <REQUIRE_ONCE> Expression() (<SEMICOLON> | "?>")
+  <REQUIRE_ONCE>
+  expr = Expression()
+  {
+    if (currentSegment != null) {
+      currentSegment.add(new PHPReqIncDeclaration(currentSegment, "require_once",pos,expr));
+    }
+  }
+  try {
+    (<SEMICOLON> | "?>")
+  } catch (ParseException e) {
+    errorMessage = "';' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
 |
-  <INCLUDE> Expression() (<SEMICOLON> | "?>")
+  <INCLUDE>
+  expr = Expression()
+  {
+    if (currentSegment != null) {
+      currentSegment.add(new PHPReqIncDeclaration(currentSegment, "include",pos,expr));
+    }
+  }
+  try {
+    (<SEMICOLON> | "?>")
+  } catch (ParseException e) {
+    errorMessage = "';' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
 |
-  <INCLUDE_ONCE> Expression() (<SEMICOLON> | "?>")
+  <INCLUDE_ONCE>
+  expr = Expression()
+  {
+    if (currentSegment != null) {
+      currentSegment.add(new PHPReqIncDeclaration(currentSegment, "include_once",pos,expr));
+    }
+  }
+  try {
+    (<SEMICOLON> | "?>")
+  } catch (ParseException e) {
+    errorMessage = "';' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
 }
 
-void PrintExpression() :
-{}
+String PrintExpression() :
 {
-  <PRINT> Expression()
+  final StringBuffer buff = new StringBuffer("print ");
+  final String expr;
+}
+{
+  <PRINT> expr = Expression()
+  {
+    buff.append(expr);
+    return buff.toString();
+  }
+}
+
+String ListExpression() :
+{
+  final StringBuffer buff = new StringBuffer("list(");
+  String expr;
+}
+{
+  <LIST>
+  try {
+    <LPAREN>
+  } catch (ParseException e) {
+    errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', '(' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  [
+    expr = VariableDeclaratorId()
+    {buff.append(expr);}
+  ]
+  [
+    try {
+      <COMMA>
+    } catch (ParseException e) {
+      errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ',' expected";
+      errorLevel   = ERROR;
+      throw e;
+    }
+    expr = VariableDeclaratorId()
+    {buff.append(",").append(expr);}
+  ]
+  {buff.append(")");}
+  try {
+    <RPAREN>
+  } catch (ParseException e) {
+    errorMessage = "unexpected token : '"+ e.currentToken.next.image +"', ')' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  [ <ASSIGN> expr = Expression() {buff.append("(").append(expr);}]
+  {return buff.toString();}
 }
 
 void EchoStatement() :
@@ -1000,13 +1736,27 @@ void EchoStatement() :
 void GlobalStatement() :
 {}
 {
-  <GLOBAL> VariableDeclaratorId() (<COMMA> VariableDeclaratorId())* (<SEMICOLON> | "?>")
+  <GLOBAL> VariableDeclaratorId() (<COMMA> VariableDeclaratorId())*
+  try {
+    (<SEMICOLON> | "?>")
+  } catch (ParseException e) {
+    errorMessage = "';' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
 }
 
 void StaticStatement() :
 {}
 {
-  <STATIC> VariableDeclarator() (<COMMA> VariableDeclarator())* (<SEMICOLON> | "?>")
+  <STATIC> VariableDeclarator() (<COMMA> VariableDeclarator())*
+  try {
+    (<SEMICOLON> | "?>")
+  } catch (ParseException e) {
+    errorMessage = "';' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
 }
 
 void LabeledStatement() :
@@ -1018,7 +1768,21 @@ void LabeledStatement() :
 void Block() :
 {}
 {
-  <LBRACE> ( BlockStatement() )* <RBRACE>
+  try {
+    <LBRACE>
+  } catch (ParseException e) {
+    errorMessage = "'{' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  ( BlockStatement() )*
+  try {
+    <RBRACE>
+  } catch (ParseException e) {
+    errorMessage = "unexpected token : '"+ e.currentToken.image +"', '}' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
 }
 
 void BlockStatement() :
@@ -1031,10 +1795,29 @@ void BlockStatement() :
   MethodDeclaration()
 }
 
+/**
+ * A Block statement that will not contain any 'break'
+ */
+void BlockStatementNoBreak() :
+{}
+{
+  StatementNoBreak()
+|
+  ClassDeclaration()
+|
+  MethodDeclaration()
+}
+
 void LocalVariableDeclaration() :
 {}
 {
-  VariableDeclarator() ( <COMMA> VariableDeclarator() )*
+  LocalVariableDeclarator() ( <COMMA> LocalVariableDeclarator() )*
+}
+
+void LocalVariableDeclarator() :
+{}
+{
+  VariableDeclaratorId() [ <ASSIGN> Expression() ]
 }
 
 void EmptyStatement() :
@@ -1044,11 +1827,6 @@ void EmptyStatement() :
 }
 
 void StatementExpression() :
-/*
- * The last expansion of this production accepts more than the legal
- * Java expansions for StatementExpression.  This expansion does not
- * use PostfixExpression for performance reasons.
- */
 {}
 {
   PreIncrementExpression()
@@ -1066,33 +1844,113 @@ void StatementExpression() :
 }
 
 void SwitchStatement() :
-{}
 {
-  <SWITCH> <LPAREN> Expression() <RPAREN> <LBRACE>
-    ( SwitchLabel() ( BlockStatement() )* )*
-  <RBRACE>
+  Token breakToken = null;
+  int line;
+}
+{
+  <SWITCH>
+  try {
+    <LPAREN>
+  } catch (ParseException e) {
+    errorMessage = "'(' expected after 'switch'";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  Expression()
+  try {
+    <RPAREN>
+  } catch (ParseException e) {
+    errorMessage = "')' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  try {
+  <LBRACE>
+  } catch (ParseException e) {
+    errorMessage = "'{' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+    (
+      line = SwitchLabel()
+      ( BlockStatementNoBreak() )*
+      [ breakToken = <BREAK>
+        try {
+          <SEMICOLON>
+        } catch (ParseException e) {
+          errorMessage = "';' expected after 'break' keyword";
+          errorLevel   = ERROR;
+          throw e;
+        }
+      ]
+      {
+        try {
+          if (breakToken == null) {
+            setMarker(fileToParse,
+                      "You should use put a 'break' at the end of your statement",
+                      line,
+                      INFO,
+                      "Line " + line);
+          }
+        } catch (CoreException e) {
+          PHPeclipsePlugin.log(e);
+        }
+      }
+    )*
+  try {
+    <RBRACE>
+  } catch (ParseException e) {
+    errorMessage = "'}' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
 }
 
-void SwitchLabel() :
-{}
+int SwitchLabel() :
 {
-  <CASE> Expression() <COLON>
+  final Token token;
+}
+{
+  token = <CASE>
+  try {
+    Expression()
+  } catch (ParseException e) {
+    if (errorMessage != null) throw e;
+    errorMessage = "expression expected after 'case' keyword";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  try {
+    <COLON>
+  } catch (ParseException e) {
+    errorMessage = "':' expected after case expression";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  {return token.beginLine;}
 |
-  <_DEFAULT> <COLON>
+  token = <_DEFAULT>
+  try {
+    <COLON>
+  } catch (ParseException e) {
+    errorMessage = "':' expected after 'default' keyword";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  {return token.beginLine;}
 }
 
 void IfStatement() :
-/*
- * The disambiguating algorithm of JavaCC automatically binds dangling
- * else's to the innermost if statement.  The LOOKAHEAD specification
- * is to tell JavaCC that we know what we are doing.
- */
-{}
 {
-  <IF> Condition("if") Statement() [ LOOKAHEAD(1) ElseIfStatement() ] [ LOOKAHEAD(1) <ELSE> Statement() ]
+  final Token token;
+  final int pos = jj_input_stream.bufpos;
+}
+{
+  token = <IF> Condition("if") IfStatement0(pos,pos+token.image.length())
 }
 
-void Condition(String keyword) :
+void Condition(final String keyword) :
 {}
 {
   try {
@@ -1112,6 +1970,51 @@ void Condition(String keyword) :
   }
 }
 
+void IfStatement0(final int start,final int end) :
+{}
+{
+  <COLON> (Statement())* (ElseIfStatementColon())* [ElseStatementColon()]
+
+  {try {
+  setMarker(fileToParse,
+            "Ugly syntax detected, you should if () {...} instead of if (): ... endif;",
+            start,
+            end,
+            INFO,
+            "Line " + token.beginLine);
+  } catch (CoreException e) {
+    PHPeclipsePlugin.log(e);
+  }}
+  try {
+    <ENDIF>
+  } catch (ParseException e) {
+    errorMessage = "'endif' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  try {
+    <SEMICOLON>
+  } catch (ParseException e) {
+    errorMessage = "';' expected after 'endif' keyword";
+    errorLevel   = ERROR;
+    throw e;
+  }
+|
+  Statement() ( LOOKAHEAD(1) ElseIfStatement() )* [ LOOKAHEAD(1) <ELSE> Statement() ]
+}
+
+void ElseIfStatementColon() :
+{}
+{
+  <ELSEIF> Condition("elseif") <COLON> (Statement())*
+}
+
+void ElseStatementColon() :
+{}
+{
+  <ELSE> <COLON> (Statement())*
+}
+
 void ElseIfStatement() :
 {}
 {
@@ -1119,15 +2022,42 @@ void ElseIfStatement() :
 }
 
 void WhileStatement() :
-{}
 {
-  <WHILE> Condition("while") WhileStatement0()
+  final Token token;
+  final int pos = jj_input_stream.bufpos;
+}
+{
+  token = <WHILE> Condition("while") WhileStatement0(pos,pos + token.image.length())
 }
 
-void WhileStatement0() :
+void WhileStatement0(final int start, final int end) :
 {}
 {
-  <COLON> (Statement())* <ENDWHILE> (<SEMICOLON> | "?>")
+  <COLON> (Statement())*
+  {try {
+  setMarker(fileToParse,
+            "Ugly syntax detected, you should while () {...} instead of while (): ... endwhile;",
+            start,
+            end,
+            INFO,
+            "Line " + token.beginLine);
+  } catch (CoreException e) {
+    PHPeclipsePlugin.log(e);
+  }}
+  try {
+    <ENDWHILE>
+  } catch (ParseException e) {
+    errorMessage = "'endwhile' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  try {
+    (<SEMICOLON> | "?>")
+  } catch (ParseException e) {
+    errorMessage = "';' expected after 'endwhile' keyword";
+    errorLevel   = ERROR;
+    throw e;
+  }
 |
   Statement()
 }
@@ -1135,13 +2065,113 @@ void WhileStatement0() :
 void DoStatement() :
 {}
 {
-  <DO> Statement() <WHILE> Condition("while") (<SEMICOLON> | "?>")
+  <DO> Statement() <WHILE> Condition("while")
+  try {
+    (<SEMICOLON> | "?>")
+  } catch (ParseException e) {
+    errorMessage = "';' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
 }
 
-void ForStatement() :
+void ForeachStatement() :
 {}
 {
-  <FOR> <LPAREN> [ ForInit() ] <SEMICOLON> [ Expression() ] <SEMICOLON> [ ForUpdate() ] <RPAREN> Statement()
+  <FOREACH>
+    try {
+    <LPAREN>
+  } catch (ParseException e) {
+    errorMessage = "'(' expected after 'foreach' keyword";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  try {
+    Variable()
+  } catch (ParseException e) {
+    errorMessage = "variable expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  [ VariableSuffix() ]
+  try {
+    <AS>
+  } catch (ParseException e) {
+    errorMessage = "'as' expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  try {
+    Variable()
+  } catch (ParseException e) {
+    errorMessage = "variable expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  [ <ARRAYASSIGN> Expression() ]
+  try {
+    <RPAREN>
+  } catch (ParseException e) {
+    errorMessage = "')' expected after 'foreach' keyword";
+    errorLevel   = ERROR;
+    throw e;
+  }
+  try {
+    Statement()
+  } catch (ParseException e) {
+    if (errorMessage != null) throw e;
+    errorMessage = "statement expected";
+    errorLevel   = ERROR;
+    throw e;
+  }
+}
+
+void ForStatement() :
+{
+final Token token;
+final int pos = jj_input_stream.bufpos;
+}
+{
+  token = <FOR>
+  try {
+    <LPAREN>
+  } catch (ParseException e) {
+    errorMessage = "'(' expected after 'for' keyword";
+    errorLevel   = ERROR;
+    throw e;
+  }
+     [ ForInit() ] <SEMICOLON> [ Expression() ] <SEMICOLON> [ StatementExpressionList() ] <RPAREN>
+    (
+      Statement()
+    |
+      <COLON> (Statement())*
+      {
+        try {
+        setMarker(fileToParse,
+                  "Ugly syntax detected, you should for () {...} instead of for (): ... endfor;",
+                  pos,
+                  pos+token.image.length(),
+                  INFO,
+                  "Line " + token.beginLine);
+        } catch (CoreException e) {
+          PHPeclipsePlugin.log(e);
+        }
+      }
+      try {
+        <ENDFOR>
+      } catch (ParseException e) {
+        errorMessage = "'endfor' expected";
+        errorLevel   = ERROR;
+        throw e;
+      }
+      try {
+        <SEMICOLON>
+      } catch (ParseException e) {
+        errorMessage = "';' expected after 'endfor' keyword";
+        errorLevel   = ERROR;
+        throw e;
+      }
+    )
 }
 
 void ForInit() :
@@ -1159,26 +2189,41 @@ void StatementExpressionList() :
   StatementExpression() ( <COMMA> StatementExpression() )*
 }
 
-void ForUpdate() :
-{}
-{
-  StatementExpressionList()
-}
-
 void BreakStatement() :
 {}
 {
-  <BREAK> [ <IDENTIFIER> ] <SEMICOLON>
+  <BREAK> [ <IDENTIFIER> ]
+  try {
+    <SEMICOLON>
+  } catch (ParseException e) {
+    errorMessage = "';' expected after 'break' statement";
+    errorLevel   = ERROR;
+    throw e;
+  }
 }
 
 void ContinueStatement() :
 {}
 {
-  <CONTINUE> [ <IDENTIFIER> ] <SEMICOLON>
+  <CONTINUE> [ <IDENTIFIER> ]
+  try {
+    <SEMICOLON>
+  } catch (ParseException e) {
+    errorMessage = "';' expected after 'continue' statement";
+    errorLevel   = ERROR;
+    throw e;
+  }
 }
 
 void ReturnStatement() :
 {}
 {
-  <RETURN> [ Expression() ] <SEMICOLON>
+  <RETURN> [ Expression() ]
+  try {
+    <SEMICOLON>
+  } catch (ParseException e) {
+    errorMessage = "';' expected after 'return' statement";
+    errorLevel   = ERROR;
+    throw e;
+  }
 }
\ No newline at end of file