Skip Navigation
 
 

php52 Language Reference


Regular Grammar

( legend )
 Character Set
let  Byte  :: 

'\x00000000' .. '\x0000d7ff' | '\x0000e000' .. '\x0000fffd' | '\x00010000' .. '\x0010ffff'


'\00' .. '\ff' ; all extended ascii

 
     
let  Control  :: 

'\00' .. '\1f' | '\7f' | '\ff'


control DEL space-like extended ascii

 
     
 Basic elements of tokens
ign  Etx  :: 

"\1a" { Byte }


CPM / older DOS Versions

 
     
let  Space  :: 

'\t '


ASCII - Space / Tab

 
     
let  Line  :: 

'\n\r'


UNIX / CPM / DOS

 
     
let  Digit  :: 

'0' .. '9'


 
     
let  Hex  :: 

Digit | 'a' .. 'f' | 'A' .. 'F'


 
     
let  Letter  :: 

'a' .. 'z' | 'A' .. 'Z'


 
     
let  LabelChar  :: 

Letter | '_' | '\7f' .. '\ff'


 
     
let  LNumber  :: 

Digit +


 
     
let  DNumber  :: 

( { Digit } '.' Digit + ) | ( Digit + '.' { Digit } )


 
     
let  ENumber  :: 

( LNumber | DNumber ) 'eE' [ '+-' ] LNumber


 
     
let  HNumber  :: 

"0x" Hex +


 
     
let  Label  :: 

LabelChar { Digit | LabelChar }


 
     
let  White  :: 

( Space | Line ) +


 
     
let  TabSpace  :: 

{ Space }


 
     
let  Tokens  :: 

';:,.[]()|^&+-/*=%!~$<>?@'


 
     
let  Newline  :: 

"\r" | "\n" | "\r\n"


 
     
let  OpenTag  :: 

"<script" White "language" { White } "=" { White } ( "php" | "\'php\'" | "\"php\"" ) { White } ">" | "<?php" White


 
     
 Initial tokens
tok  TOpenTag:GScript  :: 

OpenTag


 
     
tok  TInlineHtml  :: 

( ( Byte - '<' ) + ) - Etx


 
     
tok  THtmlComment  :: 

"<!--" ( { Byte } - ( { Byte } "--" { Byte } ) ) "-->"


 
     
tok  THtmlElmOpr  :: 

"<"


 
     
 GScript tokens
tok  GScript:TCloseTag:[initial]  :: 

( "?>" | "</script" { White } ">" ) [ Newline ]


 
     
ign  GScript:TWhite  :: 

Space | Newline


 
     
com  GScript:TLineComment  :: 

( "#" | "//" ) ( { Byte } - ( { Byte } ( "?>" | Newline ) { Byte } ) ) [ Newline ]


 
     
com  GScript:TComment  :: 

"/*" ( { Byte } - ( { Byte } "*/" { Byte } ) ) "*/" - TDocComment


 
     
com  GScript:TDocComment  :: 

"/**" ( { Byte } - ( { Byte } "*/" { Byte } ) ) "*/"


 
     
tok  GScript:TOperator  :: 

"::" | "=>" | "++" | "--" | "==" | "!=" | "<>" | "===" | "!==" | "<=" | ">=" | "-=" | "+=" | "*=" | "/=" | ".=" | "%=" | "<<=" | ">>=" | "&=" | "|=" | "^=" | "||" | "&&" | "<<" | ">>" | Tokens


 
     
tok  GScript:TDouble  :: 

DNumber | ENumber


 
     
tok  GScript:TDoubleQuote  :: 

"\"" { ( Byte - '\\\"' ) | ( "\\" Byte ) } "\""


 
     
tok  GScript:TSingleQuote  :: 

"\'" { ( Byte - '\'\\' ) | ( "\\" Byte ) } "\'"


 
     
tok  GScript:TOpenCurly:[push], GScript  :: 

"{"


 
     
tok  GScript:TCloseCurly:[pop]  :: 

"}"


 
     
tok  GScript:TOpenDQuote:GDQuote  :: 

"\""


 
     
tok  GScript:TOpenBQuote:GBQuote  :: 

"\`"


 
     
tok  GScript:TOpenSQuote:GSQuote  :: 

"\'"


 
     
tok  GScript:THeredoc:GHeredoc  :: 

<= "<<<" TabSpace > 'a..zA..Z0..9\7f..\ff_' < '\n\r' > / '\n\r'


 
     
 GHeredoc tokens
tok  GHeredoc:THeredocEnd  :: 

<? Newline > THeredoc < [ ';' ] Newline > / ';\n\r'


 
     
tok  GHeredoc:THLiteral  :: 

"\\" '0' .. '7' 1 , 3 | "\\x" Hex 1 , 2 | "\\" 'ntr\\${\"\'\`' | ( Byte - ( '\\${-' | Line | Digit | LabelChar ) ) + | '-${'


 
     
 Script & literal tokens
tok  GLitScript:TVariable  :: 

"$" Label


 
     
tok  GLitScript:TString  :: 

Label


 
     
tok  GLitScript:TObjOperator  :: 

"->"


 
     
tok  GLitScript:TInteger  :: 

LNumber | HNumber


 
     
tok  GLiteral:TDOpenCurly:[push], GScript  :: 

"${"


 
     
tok  GLiteral:TOpenCurlyD:[push], GScript  :: 

"{$" / "$"


 
     
tok  GBQuote:TBLiteral  :: 

"\\" '0' .. '7' 1 , 3 | "\\x" Hex 1 , 2 | "\\" 'ntr\\${\`\"\'' | ( Byte - ( '\\${-\`' | Digit | LabelChar ) ) + | '-${'


 
     
tok  GDQuote:TDLiteral  :: 

"\\" '0' .. '7' 1 , 3 | "\\x" Hex 1 , 2 | "\\" 'ntr\\${\"\'\`' | ( Byte - ( '\\${-\"' | Digit | LabelChar ) ) + | '-${'


 
     
tok  GSQuote:TSLiteral  :: 

( ( Byte - '\\\'' ) | "\\" ( Byte - '\\\'' ) ) + | "\\\'" | "\\\\"


 
     
tok  GDQuote:TCloseDQuote:GScript  :: 

"\""


 
     
tok  GBQuote:TCloseBQuote:GScript  :: 

"\`"


 
     
tok  GSQuote:TCloseSQuote:GScript  :: 

"\'"


 



Context-free Grammar

( legend )

start  Source  :: 

TopStms


 
     
let  Key  :: 

[


 
     
   | 

*=

 

 
     
   | 

as

 

 
     
   | 

string

 

 
     
   | 

global

 

 
     
   | 

===

 

 
     
   | 

protected

 

 
     
   | 

XOR

 

 
     
   | 

double

 

 
     
   | 

<<

 

 
     
   | 

const

 

 
     
   | 

continue

 

 
     
   | 

;

 

 
     
   | 

%=

 

 
     
   | 

^=

 

 
     
   | 

require_once

 

 
     
   | 

endswitch

 

 
     
   | 

|

 

 
     
   | 

class

 

 
     
   | 

--

 

 
     
   | 

throw

 

 
     
   | 

public

 

 
     
   | 

integer

 

 
     
   | 

foreach

 

 
     
   | 

/

 

 
     
   | 

>

 

 
     
   | 

extends

 

 
     
   | 

float

 

 
     
   | 

__FILE__

 

 
     
   | 

(

 

 
     
   | 

>=

 

 
     
   | 

final

 

 
     
   | 

array

 

 
     
   | 

try

 

 
     
   | 

private

 

 
     
   | 

enddeclare

 

 
     
   | 

unset

 

 
     
   | 

>>=

 

 
     
   | 

->

 

 
     
   | 

include

 

 
     
   | 

while

 

 
     
   | 

&&

 

 
     
   | 

~=

 

 
     
   | 

list

 

 
     
   | 

instanceof

 

 
     
   | 

||

 

 
     
   | 

=

 

 
     
   | 

die

 

 
     
   | 

__METHOD__

 

 
     
   | 

switch

 

 
     
   | 

<=

 

 
     
   | 

.

 

 
     
   | 

-

 

 
     
   | 

var

 

 
     
   | 

!

 

 
     
   | 

*

 

 
     
   | 

case

 

 
     
   | 

static

 

 
     
   | 

^

 

 
     
   | 

int

 

 
     
   | 

endwhile

 

 
     
   | 

==

 

 
     
   | 

exit

 

 
     
   | 

__LINE__

 

 
     
   | 

.=

 

 
     
   | 

<>

 

 
     
   | 

if

 

 
     
   | 

::

 

 
     
   | 

-=

 

 
     
   | 

function

 

 
     
   | 

empty

 

 
     
   | 

break

 

 
     
   | 

/=

 

 
     
   | 

endfor

 

 
     
   | 

OR

 

 
     
   | 

catch

 

 
     
   | 

?

 

 
     
   | 

!=

 

 
     
   | 

default

 

 
     
   | 

new

 

 
     
   | 

__halt_compiler

 

 
     
   | 

$

 

 
     
   | 

endif

 

 
     
   | 

else

 

 
     
   | 

require

 

 
     
   | 

<<=

 

 
     
   | 

,

 

 
     
   | 

clone

 

 
     
   | 

for

 

 
     
   | 

:

 

 
     
   | 

+

 

 
     
   | 

__CLASS__

 

 
     
   | 

]

 

 
     
   | 

do

 

 
     
   | 

AND

 

 
     
   | 

__FUNCTION__

 

 
     
   | 

return

 

 
     
   | 

>>

 

 
     
   | 

<

 

 
     
   | 

isset

 

 
     
   | 

%

 

 
     
   | 

+=

 

 
     
   | 

real

 

 
     
   | 

echo

 

 
     
   | 

!==

 

 
     
   | 

~

 

 
     
   | 

include_once

 

 
     
   | 

|=

 

 
     
   | 

@

 

 
     
   | 

object

 

 
     
   | 

boolean

 

 
     
   | 

print

 

 
     
   | 

abstract

 

 
     
   | 

{

 

 
     
   | 

&

 

 
     
   | 

++

 

 
     
   | 

bool

 

 
     
   | 

implements

 

 
     
   | 

endforeach

 

 
     
   | 

declare

 

 
     
   | 

)

 

 
     
   | 

eval

 

 
     
   | 

elseif

 

 
     
   | 

use

 

 
     
   | 

}

 

 
     
   | 

interface

 

 
     
   | 

&=

 

 
     
let  Key1  :: 

=>


 
     
   | 

Key

 

 
     
let  TopStms  :: 

TopStms1


 
     
   | 

 

 
     
   | 

HtmlStm TopStms

 

 
     
let  TopStms1  :: 

PhpOpen TopStms2


 
     
let  TopStms2  :: 

TopStms3


 
     
   | 

InStm TopStms2

 

 
     
let  TopStms3  :: 

PhpClose TopStms


 
     
let  PhpOpen  :: 

TOpenTag


 
     
let  PhpClose  :: 

TCloseTag


 
     
let  HtmlStm  :: 

Key1


 
     
   | 

TInlineHtml

 

 
     
   | 

_other_

 

 
     
   | 

THtmlComment

 

 
     
let  InStm  :: 

ClsDeclStm


 
     
   | 

FunDeclStm

 

 
     
   | 

Stm

 

 
     
   | 

__halt_compiler ( ) ;

 

 
     
let  InStms  :: 


 
     
   | 

InStm InStms

 

 
     
let  Stm  :: 

do Stm while ( Exp ) ;


 
     
   | 

foreach ( ExpEach ) EachStm

 

 
     
   | 

if ( Exp ) IfStm

 

 
     
   | 

;

 

 
     
   | 

echo Exps ;

 

 
     
   | 

unset Vars ;

 

 
     
   | 

Exp ;

 

 
     
   | 

break OptExp ;

 

 
     
   | 

static StaticVars ;

 

 
     
   | 

return OptExp ;

 

 
     
   | 

declare ( DeclArgs ) DeclStm

 

 
     
   | 

{ InStms }

 

 
     
   | 

try { InStms } Catches

 

 
     
   | 

for ( ExpFor ; ExpFor ; ExpFor ) ForStm

 

 
     
   | 

use UseFile ;

 

 
     
   | 

throw Exp ;

 

 
     
   | 

global GlobalVars ;

 

 
     
   | 

while ( Exp ) WhileStm

 

 
     
   | 

continue OptExp ;

 

 
     
   | 

switch ( Exp ) Cases

 

 
     
let  DeclArgs  :: 

DeclArg DeclArgs0


 
     
let  DeclArgs0  :: 

, DeclArg DeclArgs0


 
     
   | 

 

 
     
let  DeclArg  :: 

TString = StaticScalar


 
     
let  DeclStm  :: 

Stm


 
     
   | 

: InStms enddeclare ;

 

 
     
let  ExpEach  :: 

Exp as VarRef OptAs


 
     
let  OptAs  :: 

=> VarRef


 
     
   | 

 

 
     
let  EachStm  :: 

Stm


 
     
   | 

: InStms endforeach ;

 

 
     
let  Catches  :: 

Catch Catches0


 
     
let  Catches0  :: 


 
     
   | 

Catch Catches0

 

 
     
let  Catch  :: 

catch ( TString TVariable ) { InStms }


 
     
let  UseFile  :: 

( TDoubleQuote )


 
     
   | 

( TSingleQuote )

 

 
     
   | 

TSingleQuote

 

 
     
   | 

TDoubleQuote

 

 
     
let  Vars  :: 

Var Vars0


 
     
let  Vars0  :: 


 
     
   | 

, Var Vars0

 

 
     
let  Exps  :: 

Exp Exps0


 
     
let  Exps0  :: 


 
     
   | 

, Exp Exps0

 

 
     
let  GlobalVars  :: 

GlobalVar GlobalVars0


 
     
let  GlobalVars0  :: 


 
     
   | 

, GlobalVar GlobalVars0

 

 
     
let  StaticVars  :: 

StaticVar StaticVars0


 
     
let  StaticVars0  :: 


 
     
   | 

, StaticVar StaticVars0

 

 
     
let  GlobalVar  :: 

$ Var


 
     
   | 

TVariable

 

 
     
let  StaticVar  :: 

TVariable OptVal


 
     
let  StaticScalar  :: 

CommonScalar


 
     
   | 

TString

 

 
     
   | 

- StaticScalar

 

 
     
   | 

+ StaticScalar

 

 
     
   | 

array ( StaticArrayPairs )

 

 
     
let  StaticArrayPairs  :: 


 
     
   | 

StaticArrayPair StaticArrayPairs1

 

 
     
let  StaticArrayPairs1  :: 

StaticArrayPairs0


 
     
   | 

, StaticArrayPairs0

 

 
     
   | 

, StaticArrayPair StaticArrayPairs1

 

 
     
let  StaticArrayPairs0  :: 


 
     
let  StaticArrayPair  :: 

StaticScalar


 
     
   | 

StaticScalar => StaticScalar

 

 
     
let  CommonScalar  :: 

__CLASS__


 
     
   | 

TInteger

 

 
     
   | 

__LINE__

 

 
     
   | 

__FUNCTION__

 

 
     
   | 

TString :: TString

 

 
     
   | 

__FILE__

 

 
     
   | 

TSingleQuote

 

 
     
   | 

TDoubleQuote

 

 
     
   | 

__METHOD__

 

 
     
   | 

TDouble

 

 
     
let  Cases  :: 

{ Cases0 }


 
     
   | 

: Cases0 endswitch ;

 

 
     
   | 

: ; Cases0 endswitch ;

 

 
     
   | 

{ ; Cases0 }

 

 
     
let  Cases0  :: 


 
     
   | 

Case Cases0

 

 
     
let  Case  :: 

case Exp CaseSep InStms


 
     
   | 

default CaseSep InStms

 

 
     
let  CaseSep  :: 

:


 
     
   | 

;

 

 
     
let  ForStm  :: 

Stm


 
     
   | 

: InStms endfor ;

 

 
     
let  ExpFor  :: 

Exp ExpFor0


 
     
   | 

 

 
     
let  ExpFor0  :: 


 
     
   | 

, Exp ExpFor0

 

 
     
let  WhileStm  :: 

: InStms endwhile ;


 
     
   | 

Stm

 

 
     
let  IfStm  :: 

Stm ElseIfs


 
     
   | 

: InStms ElseIfs1 endif ;

 

 
     
let  ElseIfs0  :: 


 
     
let  ElseIfs  :: 

ElseIfs0


 
     
   | 

ElseIf ElseIfs

 

 
     
   | 

ElseIfs2

 

 
     
let  ElseIfs2  :: 

ElseIf2 ElseIfs0


 
     
let  ElseIfs1  :: 

ElseIfs3


 
     
   | 

ElseIfs0

 

 
     
   | 

ElseIf1 ElseIfs1

 

 
     
let  ElseIfs3  :: 

ElseIf3 ElseIfs0


 
     
let  ElseIf  :: 

elseif ( Exp ) Stm


 
     
let  ElseIf2  :: 

else Stm


 
     
let  ElseIf1  :: 

elseif ( Exp ) : InStms


 
     
let  ElseIf3  :: 

else : InStms


 
     
let  ClsDeclStm  :: 

interface TString Extends { ClsStms }


 
     
   | 

ClsTyp TString OptBase Implements { ClsStms }

 

 
     
let  Modifier1  :: 

var


 
     
let  Modifier  :: 

private


 
     
   | 

protected

 

 
     
   | 

static

 

 
     
   | 

public

 

 
     
   | 

final

 

 
     
   | 

abstract

 

 
     
let  Modifiers1  :: 

Modifier1 Modifiers0


 
     
let  Modifiers0  :: 


 
     
let  Modifiers  :: 

Modifier Modifiers


 
     
   | 

Modifiers0

 

 
     
let  Constants  :: 

const Constant Constants0


 
     
let  Constants0  :: 


 
     
   | 

, Constant Constants0

 

 
     
let  Constant  :: 

TString OptVal


 
     
let  ClsStm  :: 

Modifiers function FunId ( FunPars ) FunBody


 
     
   | 

Modifiers1 StaticVars ;

 

 
     
   | 

Constants ;

 

 
     
let  FunBody  :: 

{ InStms }


 
     
   | 

;

 

 
     
let  ClsStms  :: 


 
     
   | 

ClsStm ClsStms

 

 
     
let  Extends  :: 

extends TString Extends0


 
     
   | 

 

 
     
let  Extends0  :: 


 
     
   | 

, TString Extends0

 

 
     
let  Implements  :: 


 
     
   | 

implements TString Implements0

 

 
     
let  Implements0  :: 

, TString Implements0


 
     
   | 

 

 
     
let  OptBase  :: 


 
     
   | 

extends TString

 

 
     
let  ClsTyp  :: 

abstract class


 
     
   | 

final class

 

 
     
   | 

class

 

 
     
let  FunDeclStm  :: 

function FunId ( FunPars ) { InStms }


 
     
let  FunPars0  :: 


 
     
   | 

, FunPar FunPars0

 

 
     
let  FunPars  :: 


 
     
   | 

FunPar FunPars0

 

 
     
let  FunPar  :: 

OptTyp TVariable OptVal


 
     
   | 

OptTyp & TVariable OptVal

 

 
     
let  OptTyp  :: 

TString


 
     
   | 

array

 

 
     
   | 

 

 
     
let  OptVal  :: 

= StaticScalar


 
     
   | 

 

 
     
let  FunId  :: 

& TString


 
     
   | 

TString

 

 
     
let  Var  :: 

VarCall VarProps


 
     
let  VarProps  :: 

VarProp VarProps


 
     
   | 

 

 
     
let  VarProp  :: 

-> ObjProp FunArgs1


 
     
let  VarCall  :: 

FunCall


 
     
   | 

BaseVar

 

 
     
let  FunCall  :: 

TString FunArgs


 
     
   | 

TString :: MethodCall

 

 
     
   | 

RefVar FunArgs

 

 
     
let  MethodCall  :: 

TString FunArgs


 
     
   | 

RefVar FunArgs

 

 
     
let  FunArgs0  :: 


 
     
   | 

, FunArg FunArgs0

 

 
     
let  FunArgs2  :: 

FunArg FunArgs0


 
     
   | 

 

 
     
let  FunArgs  :: 

( FunArgs2 )


 
     
let  FunArgs1  :: 

FunArgs


 
     
   | 

 

 
     
let  FunArg  :: 

& Var


 
     
   | 

Exp

 

 
     
let  BaseVar  :: 

RefVar


 
     
   | 

TString :: RefVar

 

 
     
let  VarRef  :: 

Var


 
     
   | 

& Var

 

 
     
let  ExpRef  :: 

Exp0


 
     
   | 

& Var

 

 
     
let  RefVar  :: 

RefVar [ OptExp ]


 
     
   | 

CompVar

 

 
     
   | 

RefVar { Exp }

 

 
     
let  CompVar  :: 

TVariable


 
     
   | 

{ Exp }

 

 
     
   | 

$ CompVar

 

 
     
let  CompVar1  :: 

CompVar


 
     
   | 

TString

 

 
     
let  OptExp  :: 

Exp


 
     
   | 

 

 
     
let  OptExp1  :: 

( OptExp )


 
     
   | 

 

 
     
let  Exp  :: 

@ ExpX


 
     
   | 

ExpX

 

 
     
   | 

Exp0

 

 
     
let  ExpX  :: 

include_once Exp


 
     
   | 

include Exp

 

 
     
   | 

require_once Exp

 

 
     
   | 

require Exp

 

 
     
let  Exp0  :: 

Exp0 OR Exp1


 
     
   | 

Exp1

 

 
     
let  Exp1  :: 

Exp1 XOR Exp2


 
     
   | 

Exp2

 

 
     
let  Exp2  :: 

Exp2 AND Exp3


 
     
   | 

Exp3

 

 
     
let  Exp3  :: 

@ ExpX3


 
     
   | 

ExpX3

 

 
     
   | 

Exp4

 

 
     
let  ExpX3  :: 

print Exp3


 
     
let  Exp4  :: 

@ ExpX4


 
     
   | 

ExpX4

 

 
     
   | 

Exp5

 

 
     
let  ExpX4  :: 

Var += Exp4


 
     
   | 

Var %= Exp4

 

 
     
   | 

Var -= Exp4

 

 
     
   | 

Var &= Exp4

 

 
     
   | 

Var |= Exp4

 

 
     
   | 

Var ^= Exp4

 

 
     
   | 

Var /= Exp4

 

 
     
   | 

Var *= Exp4

 

 
     
   | 

Var .= Exp4

 

 
     
   | 

list ( AsgElms ) = Exp4

 

 
     
   | 

Var = VarAsg

 

 
     
   | 

Var >>= Exp4

 

 
     
   | 

Var <<= Exp4

 

 
     
let  Exp5  :: 

Exp6


 
     
   | 

Exp5 ? Exp5 : Exp6

 

 
     
let  Exp6  :: 

Exp6 || Exp7


 
     
   | 

Exp7

 

 
     
let  Exp7  :: 

Exp7 && Exp8


 
     
   | 

Exp8

 

 
     
let  Exp8  :: 

Exp9


 
     
   | 

Exp8 | Exp9

 

 
     
let  Exp9  :: 

Exp9 ^ Exp10


 
     
   | 

Exp10

 

 
     
let  Exp10  :: 

Exp11


 
     
   | 

Exp10 & Exp11

 

 
     
let  Exp11  :: 

Exp12 <> Exp12


 
     
   | 

Exp12 != Exp12

 

 
     
   | 

Exp12 === Exp12

 

 
     
   | 

Exp12 == Exp12

 

 
     
   | 

Exp12 !== Exp12

 

 
     
   | 

Exp12

 

 
     
let  Exp12  :: 

Exp13 > Exp13


 
     
   | 

Exp13 < Exp13

 

 
     
   | 

Exp13

 

 
     
   | 

Exp13 >= Exp13

 

 
     
   | 

Exp13 <= Exp13

 

 
     
let  Exp13  :: 

Exp13 >> Exp14


 
     
   | 

Exp13 << Exp14

 

 
     
   | 

Exp14

 

 
     
let  Exp14  :: 

Exp14 . Exp15


 
     
   | 

Exp14 + Exp15

 

 
     
   | 

Exp15

 

 
     
   | 

Exp14 - Exp15

 

 
     
let  Exp15  :: 

Exp15 / Exp16


 
     
   | 

Exp15 % Exp16

 

 
     
   | 

Exp16

 

 
     
   | 

Exp15 * Exp16

 

 
     
let  Exp16  :: 

! Exp16


 
     
   | 

- Exp16

 

 
     
   | 

Var ++

 

 
     
   | 

Cast Exp16

 

 
     
   | 

clone Exp16

 

 
     
   | 

Exp17 instanceof ClsIdRef

 

 
     
   | 

++ Var

 

 
     
   | 

+ Exp16

 

 
     
   | 

@ Exp16

 

 
     
   | 

Var --

 

 
     
   | 

new ClsIdRef FunArgs1

 

 
     
   | 

-- Var

 

 
     
   | 

Exp17

 

 
     
   | 

~ Exp16

 

 
     
let  Exp17  :: 

Scalar


 
     
   | 

BuiltIn

 

 
     
   | 

Var

 

 
     
   | 

array ( ArrayPairs )

 

 
     
   | 

die OptExp1

 

 
     
   | 

exit OptExp1

 

 
     
   | 

( Exp )

 

 
     
   | 

TOpenBQuote Encapses TCloseBQuote

 

 
     
let  VarAsg  :: 

& new ClsIdRef FunArgs1


 
     
   | 

Exp5

 

 
     
   | 

& Var

 

 
     
let  BuiltIn  :: 

eval ( Exp )


 
     
   | 

empty ( Var )

 

 
     
   | 

isset ( Vars )

 

 
     
let  Cast  :: 

( real )


 
     
   | 

( string )

 

 
     
   | 

( array )

 

 
     
   | 

( integer )

 

 
     
   | 

( double )

 

 
     
   | 

( int )

 

 
     
   | 

( object )

 

 
     
   | 

( unset )

 

 
     
   | 

( boolean )

 

 
     
   | 

( float )

 

 
     
   | 

( bool )

 

 
     
let  ArrayPairs  :: 


 
     
   | 

ArrayPair ArrayPairs1

 

 
     
let  ArrayPairs1  :: 

, ArrayPairs0


 
     
   | 

ArrayPairs0

 

 
     
   | 

, ArrayPair ArrayPairs1

 

 
     
let  ArrayPairs0  :: 


 
     
let  ArrayPair  :: 

ExpRef


 
     
   | 

Exp => ExpRef

 

 
     
let  Scalar  :: 

CommonScalar


 
     
   | 

TOpenDQuote Encapses TCloseDQuote

 

 
     
   | 

TString

 

 
     
   | 

THeredoc Encapses THeredoc

 

 
     
   | 

TOpenSQuote Encapses TCloseSQuote

 

 
     
let  Encapses  :: 

Encaps Encapses


 
     
   | 

 

 
     
let  Encaps  :: 

TBLiteral


 
     
   | 

TDLiteral

 

 
     
   | 

TDOpenCurly TString [ Exp ] }

 

 
     
   | 

THeredocEnd

 

 
     
   | 

TSLiteral

 

 
     
   | 

THLiteral

 

 
     
   | 

TString

 

 
     
   | 

TVariable

 

 
     
   | 

TInteger

 

 
     
   | 

TOpenCurlyD Var }

 

 
     
   | 

_other_

 

 
     
   | 

TDOpenCurly Exp }

 

 
     
   | 

Key1

 

 
     
let  AsgElms0  :: 


 
     
   | 

, AsgElm AsgElms0

 

 
     
let  AsgElms  :: 

AsgElm AsgElms0


 
     
let  AsgElm  :: 

list ( AsgElms )


 
     
   | 

 

 
     
   | 

Var

 

 
     
let  ClsIdRef  :: 

TString


 
     
   | 

DynClsIdRef

 

 
     
let  DynClsIdRef  :: 

BaseVar


 
     
   | 

BaseVar -> ObjProps

 

 
     
let  ObjProps  :: 

ObjProp ObjProps0


 
     
let  ObjProps0  :: 

-> ObjProp ObjProps0


 
     
   | 

 

 
     
let  ObjProp  :: 

ObjProp { Exp }


 
     
   | 

ObjProp [ OptExp ]

 

 
     
   | 

CompVar1