%%
%% Module containing all statements shared by both PHP4 and PHP5.
%%
%% @author Eric Bouwers
module languages/php/common/Statements
exports

  sorts HiddenSemicolon Expr
  context-free syntax
    Expr HiddenSemicolon  -> Statement {cons("Expr")}
    Expr ";"              -> Statement {cons("Expr")}

  sorts TopStatement FunctionDecl ClassDecl
  context-free syntax
    FunctionDecl   -> TopStatement
    ClassDecl      -> TopStatement
    Statement      -> TopStatement

%% Block statement
  sorts Statement TopStatementBlock
  context-free syntax
  %% A list of statements. Used in alternative notation of statements.
   "{" Statement* "}"    -> Statement{cons("Block")}

  %% If we have a function within an if it has to be in a block
   "{" TopStatement* "}" -> TopStatementBlock{cons("Block"),prefer} %% prevent a choice between a list of statements
    Statement            -> TopStatementBlock   %% If and similar constructs can have a single statement as body

%% If statement
  sorts ElseIfStatement AltElseifStatement
  context-free syntax
  %% The if statement has two different notations
  %% Temp hack until real solution has been found for 'dangling enter'
     'if'     "(" Expr ")" TopStatementBlock  -> Statement {prefer, cons("If")}

     'if'     "(" Expr ")" TopStatementBlock
     ElseIfStatement+                         -> Statement {prefer, cons("If")}

     'if'     "(" Expr ")" TopStatementBlock
     ElseIfStatement*
     'else' Statement                         -> Statement {cons("If")}

    'elseif' "(" Expr ")" TopStatementBlock   -> ElseIfStatement {cons("ElseIf")}

%% Alternative syntax for the if
     'if'     "(" Expr ")" ":" TopStatement*
     'endif' ";"                              -> Statement {cons("AltIf")}

     'if'     "(" Expr ")" ":" TopStatement*
     AltElseifStatement+
     'endif' ";"                              -> Statement {cons("AltIf")}

     'if'     "(" Expr ")" ":" TopStatement*
     AltElseifStatement*
     'else' ":" Statement*  'endif' ";"       -> Statement {cons("AltIf")}


    'elseif' "(" Expr ")" ":" TopStatement*   -> AltElseifStatement {cons("AltElseIf")}

  lexical restrictions
    'else' -/- [i]

%% While statement
  context-free syntax
  %% The while has two notations
    'while' "(" Expr ")" TopStatementBlock              -> Statement {cons("While")}
    'while' "(" Expr ")" ":" TopStatement* "endwhile" ";"  -> Statement {cons("AltWhile")}

%% Do statement
  context-free syntax
  %% The do statement has only one notation
    'do' TopStatementBlock 'while' "(" Expr ")" ";" -> Statement {cons("DoWhile")}

%% For statement
  context-free syntax
  %% For statement also has two notations. Notice that there can be several expressions
  %% in the conditions
    'for' "(" {Expr ","}* ";"
              {Expr ","}* ";"
              {Expr ","}*
          ")"
          Statement                   -> Statement {cons("For")}
    'for' "(" {Expr ","}* ";"
              {Expr ","}* ";"
              {Expr ","}*
          ")"
          ":" Statement* 'endfor' ";" -> Statement {cons("AltFor")}

%% Switch statement
  sorts Case CaseSeperator
  lexical syntax
    ":" -> CaseSeperator
    ";" -> CaseSeperator
  context-free syntax
  %% Two different types of cases to be recognized

    'case' Expr CaseSeperator TopStatement* -> Case {cons("Case")}
    'default'   CaseSeperator TopStatement* -> Case {cons("DefaultCase")}

  %% Several notations for the switch
    'switch' "(" Expr ")" "{" Case* "}"                 -> Statement {cons("Switch")}
    'switch' "(" Expr ")" "{" ";" Case* "}"             -> Statement {cons("Switch")}
    'switch' "(" Expr ")" ":" Case* 'endswitch' ";"     -> Statement {cons("AltSwitch")}
    'switch' "(" Expr ")" ":" ";" Case* 'endswitch' ";" -> Statement {cons("AltSwitch")}

%% Control flow statements
  context-free syntax
  %% break, continue and return statements
    'break'    Expr? ";"    -> Statement {cons("Break")}
    'continue' Expr? ";"    -> Statement {cons("Continue")}
    'return'   Expr? ";"    -> Statement {cons("Return")}

%% Global variable statements
  sorts CVar
  context-free syntax
  %% Declaration of global variables
    'global' {CVar ","}+ ";" -> Statement {cons("DeclareGlobal")}

%% Static variable statements
  sorts StaticVariable StaticScalar TVariable
  context-free syntax
    TVariable                    -> StaticVariable {cons("StaticVariable")}
    TVariable "=" StaticScalar   -> StaticVariable {cons("StaticVariable")}

    'static' {StaticVariable ","}+ ";" -> Statement {cons("DeclareStatic")}

%% Unset variable statement
  sorts ObjectCVar
  context-free syntax
  %% Unsetting of variables
    'unset' "(" {ObjectCVar ","}+ ")" ";" -> Statement {cons("Unset")}

%% Echo statement
  context-free syntax
    'echo' {Expr ","}+ HiddenSemicolon -> Statement {cons("Echo")}
    'echo' {Expr ","}+ ";"             -> Statement {cons("Echo")}

%% InlineHTML statement
  sorts InlineEcho PHPCloseTag PHPOpenTag PHPEchoOpenTag InlineHTML
  syntax
  %% Maybe seperate HTML parsing file?
    <PHPCloseTag-CF> <InlineHTML-CF> <PHPOpenTag-CF> -> <Statement-CF> {cons("InlineHTML")}

%% Foreach statement
  sorts ForEachVar ForEachKey ForEachPattern
  context-free syntax
  %% The foreach has two notations, but the subject of the
  %% foreach can be an expression or a variable
    CVar                          -> ForEachVar
    ForEachVar "=>"               -> ForEachKey {cons("Key")}
    ForEachKey? ForEachVar -> ForEachPattern {cons("Pattern")}

    'foreach' "(" Expr 'as' ForEachPattern ")"
              Statement                            -> Statement {cons("ForEach")}
    'foreach' "(" Expr 'as' ForEachPattern ")"
              ':' Statement* 'endforeach' ";"      -> Statement {cons("AltForEach")}

%% Empty statement
  context-free syntax
    ";" -> Statement{cons("Empty")}

%% Declare statement
  sorts Directive
  context-free syntax
  String "=" StaticScalar          ->  Directive{cons("Directive")} 
 
 'declare' "(" Directive*  ")"
     Statement                     -> Statement{cons("Declare")}

%% Function decleration statement
  sorts Param
  context-free syntax
  %% We should define parameters to be given to function.
  %% Notice that we use TVariable. Just plain $variablename
    TVariable                  -> Param{cons("Param")}
    "&" TVariable              -> Param{cons("ParamRef")}
    'const' TVariable          -> Param{cons("ParamConstant")}
    TVariable "=" StaticScalar -> Param{cons("ParamDefault")}

   'function'     String "("{Param ","}* ")" "{" TopStatement* "}" -> FunctionDecl{cons("FunctionDecl")}
   'function' "&" String "("{Param ","}* ")" "{" TopStatement* "}" -> FunctionDecl{cons("FunctionDeclRef")}

%% Class decleration statement
  sorts ClassType ExtendsClause String ClassMember
  context-free syntax
  %% This is not complete. There are big differences between the class declarations of version
  %% 4 and version 5. The difference is captured in modules for the specific modules

  %% Both versions can extend a certain class
    'extends' String -> ExtendsClause {cons("Extends")}

  %% Both versions have function declarations
    FunctionDecl    -> ClassMember 

  %% There are several class types which are different for different versions
  %% This is the only one in common
    'class'    -> ClassType {cons("Normal")}

  sorts InstanceVariable
  context-free syntax
  %% An instance variable can be declared with and without a default value.
  %% In both versions
    TVariable                   -> InstanceVariable {cons("Normal")}
    TVariable "=" StaticScalar  -> InstanceVariable {cons("Default")}

  context-free syntax
  %% supported in both version 4 and 5
    'var' {InstanceVariable ","}+ ";"           -> ClassMember {cons("InstanceVariable")}