Skip Navigation
 
 

php 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  :: 

for


 
     
   | 

~=

 
     
   | 

bool

 
     
   | 

[

 
     
   | 

array

 
     
   | 

private

 
     
   | 

;

 
     
   | 

+=

 
     
   | 

__FILE__

 
     
   | 

final

 
     
   | 

list

 
     
   | 

catch

 
     
   | 

public

 
     
   | 

__LINE__

 
     
   | 

protected

 
     
   | 

@

 
     
   | 

print

 
     
   | 

boolean

 
     
   | 

++

 
     
   | 

object

 
     
   | 

!

 
     
   | 

AND

 
     
   | 

*=

 
     
   | 

]

 
     
   | 

.=

 
     
   | 

<=

 
     
   | 

-=

 
     
   | 

instanceof

 
     
   | 

continue

 
     
   | 

__METHOD__

 
     
   | 

global

 
     
   | 

+

 
     
   | 

break

 
     
   | 

string

 
     
   | 

return

 
     
   | 

*

 
     
   | 

enddeclare

 
     
   | 

const

 
     
   | 

>=

 
     
   | 

new

 
     
   | 

class

 
     
   | 

exit

 
     
   | 

abstract

 
     
   | 

__CLASS__

 
     
   | 

function

 
     
   | 

endswitch

 
     
   | 

<>

 
     
   | 

__FUNCTION__

 
     
   | 

case

 
     
   | 

!==

 
     
   | 

%=

 
     
   | 

%

 
     
   | 

>>=

 
     
   | 

&&

 
     
   | 

clone

 
     
   | 

!=

 
     
   | 

/=

 
     
   | 

/

 
     
   | 

die

 
     
   | 

extends

 
     
   | 

<<=

 
     
   | 

,

 
     
   | 

--

 
     
   | 

default

 
     
   | 

declare

 
     
   | 

endwhile

 
     
   | 

-

 
     
   | 

static

 
     
   | 

echo

 
     
   | 

isset

 
     
   | 

eval

 
     
   | 

use

 
     
   | 

===

 
     
   | 

implements

 
     
   | 

<<

 
     
   | 

&

 
     
   | 

include_once

 
     
   | 

==

 
     
   | 

endif

 
     
   | 

interface

 
     
   | 

<

 
     
   | 

>>

 
     
   | 

endfor

 
     
   | 

include

 
     
   | 

unset

 
     
   | 

~

 
     
   | 

$

 
     
   | 

try

 
     
   | 

->

 
     
   | 

^

 
     
   | 

||

 
     
   | 

empty

 
     
   | 

int

 
     
   | 

endforeach

 
     
   | 

>

 
     
   | 

elseif

 
     
   | 

|

 
     
   | 

integer

 
     
   | 

(

 
     
   | 

var

 
     
   | 

{

 
     
   | 

throw

 
     
   | 

::

 
     
   | 

foreach

 
     
   | 

if

 
     
   | 

require_once

 
     
   | 

.

 
     
   | 

|=

 
     
   | 

real

 
     
   | 

XOR

 
     
   | 

?

 
     
   | 

^=

 
     
   | 

double

 
     
   | 

require

 
     
   | 

else

 
     
   | 

=

 
     
   | 

OR

 
     
   | 

:

 
     
   | 

as

 
     
   | 

while

 
     
   | 

)

 
     
   | 

}

 
     
   | 

do

 
     
   | 

switch

 
     
   | 

float

 
     
   | 

&=

 
     
let  Key1  :: 

=>


 
     
   | 

Key

 
     
let  TopStms  :: 


 
     
   | 

HtmlStm TopStms

 
     
   | 

TopStms1

 
     
let  TopStms1  :: 

PhpOpen TopStms2


 
     
let  TopStms2  :: 

TopStms3


 
     
   | 

InStm TopStms2

 
     
let  TopStms3  :: 

PhpClose TopStms


 
     
let  PhpOpen  :: 

TOpenTag


 
     
let  PhpClose  :: 

TCloseTag


 
     
let  HtmlStm  :: 

THtmlComment


 
     
   | 

Key1

 
     
   | 

_other_

 
     
   | 

TInlineHtml

 
     
let  InStm  :: 

Stm


 
     
   | 

ClsDeclStm

 
     
   | 

FunDeclStm

 
     
let  InStms  :: 

InStm InStms


 
     
   | 

 
     
let  Stm  :: 

break OptExp ;


 
     
   | 

while ( Exp ) WhileStm

 
     
   | 

switch ( Exp ) Cases

 
     
   | 

if ( Exp ) IfStm

 
     
   | 

foreach ( ExpEach ) EachStm

 
     
   | 

do Stm while ( Exp ) ;

 
     
   | 

;

 
     
   | 

global GlobalVars ;

 
     
   | 

use UseFile ;

 
     
   | 

declare ( DeclArgs ) DeclStm

 
     
   | 

continue OptExp ;

 
     
   | 

throw Exp ;

 
     
   | 

return OptExp ;

 
     
   | 

unset Vars ;

 
     
   | 

static StaticVars ;

 
     
   | 

Exp ;

 
     
   | 

echo Exps ;

 
     
   | 

try { InStms } Catches

 
     
   | 

for ( ExpFor ; ExpFor ; ExpFor ) ForStm

 
     
   | 

{ InStms }

 
     
let  DeclArgs  :: 

DeclArg DeclArgs0


 
     
let  DeclArgs0  :: 


 
     
   | 

, DeclArg DeclArgs0

 
     
let  DeclArg  :: 

TString = StaticScalar


 
     
let  DeclStm  :: 

: InStms enddeclare ;


 
     
   | 

Stm

 
     
let  ExpEach  :: 

Exp as VarRef OptAs


 
     
let  OptAs  :: 


 
     
   | 

=> VarRef

 
     
let  EachStm  :: 

: InStms endforeach ;


 
     
   | 

Stm

 
     
let  Catches  :: 

Catch Catches0


 
     
let  Catches0  :: 


 
     
   | 

Catch Catches0

 
     
let  Catch  :: 

catch ( TString TVariable ) { InStms }


 
     
let  UseFile  :: 

TSingleQuote


 
     
   | 

( TDoubleQuote )

 
     
   | 

TDoubleQuote

 
     
   | 

( TSingleQuote )

 
     
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  :: 

TString


 
     
   | 

+ StaticScalar

 
     
   | 

array ( StaticArrayPairs )

 
     
   | 

- StaticScalar

 
     
   | 

CommonScalar

 
     
let  StaticArrayPairs  :: 


 
     
   | 

StaticArrayPair StaticArrayPairs1

 
     
let  StaticArrayPairs1  :: 

StaticArrayPairs0


 
     
   | 

, StaticArrayPairs0

 
     
   | 

, StaticArrayPair StaticArrayPairs1

 
     
let  StaticArrayPairs0  :: 


 
     
let  StaticArrayPair  :: 

StaticScalar


 
     
   | 

StaticScalar => StaticScalar

 
     
let  CommonScalar  :: 

__FUNCTION__


 
     
   | 

__LINE__

 
     
   | 

TString :: TString

 
     
   | 

__FILE__

 
     
   | 

TInteger

 
     
   | 

TDoubleQuote

 
     
   | 

TDouble

 
     
   | 

__METHOD__

 
     
   | 

__CLASS__

 
     
   | 

TSingleQuote

 
     
let  Cases  :: 

{ Cases0 }


 
     
   | 

{ ; Cases0 }

 
     
   | 

: ; Cases0 endswitch ;

 
     
   | 

: Cases0 endswitch ;

 
     
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  :: 

: InStms ElseIfs1 endif ;


 
     
   | 

Stm ElseIfs

 
     
let  ElseIfs0  :: 


 
     
let  ElseIfs  :: 

ElseIfs0


 
     
   | 

ElseIfs2

 
     
   | 

ElseIf ElseIfs

 
     
let  ElseIfs2  :: 

ElseIf2 ElseIfs0


 
     
let  ElseIfs1  :: 

ElseIfs3


 
     
   | 

ElseIf1 ElseIfs1

 
     
   | 

ElseIfs0

 
     
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  :: 

protected


 
     
   | 

static

 
     
   | 

public

 
     
   | 

abstract

 
     
   | 

private

 
     
   | 

final

 
     
let  Modifiers1  :: 

Modifier1 Modifiers0


 
     
let  Modifiers0  :: 


 
     
let  Modifiers  :: 

Modifiers0


 
     
   | 

Modifier Modifiers

 
     
let  Constants  :: 

Constant Constants0


 
     
let  Constants0  :: 


 
     
   | 

Constant Constants0

 
     
let  Constant  :: 

TString OptVal


 
     
   | 

const TString OptVal

 
     
let  ClsStm  :: 

Modifiers function FunId ( FunPars ) FunBody


 
     
   | 

Constants ;

 
     
   | 

Modifiers1 StaticVars ;

 
     
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  :: 

final class


 
     
   | 

abstract 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

 
     
let  OptVal  :: 

= StaticScalar


 
     
   | 

 
     
let  FunId  :: 

TString


 
     
   | 

& TString

 
     
let  Var  :: 

VarCall VarProps


 
     
let  VarProps  :: 


 
     
   | 

VarProp VarProps

 
     
let  VarProp  :: 

-> ObjProp FunArgs1


 
     
let  VarCall  :: 

BaseVar


 
     
   | 

FunCall

 
     
let  FunCall  :: 

RefVar FunArgs


 
     
   | 

TString FunArgs

 
     
   | 

TString :: MethodCall

 
     
let  MethodCall  :: 

RefVar FunArgs


 
     
   | 

TString FunArgs

 
     
let  FunArgs0  :: 

, FunArg FunArgs0


 
     
   | 

 
     
let  FunArgs2  :: 

FunArg FunArgs0


 
     
   | 

 
     
let  FunArgs  :: 

( FunArgs2 )


 
     
let  FunArgs1  :: 


 
     
   | 

FunArgs

 
     
let  FunArg  :: 

& Var


 
     
   | 

Exp

 
     
let  BaseVar  :: 

TString :: RefVar


 
     
   | 

RefVar

 
     
let  VarRef  :: 

Var


 
     
   | 

& Var

 
     
let  ExpRef  :: 

Exp0


 
     
   | 

& Var

 
     
let  RefVar  :: 

RefVar { Exp }


 
     
   | 

CompVar

 
     
   | 

RefVar [ OptExp ]

 
     
let  CompVar  :: 

$ CompVar


 
     
   | 

TVariable

 
     
   | 

{ Exp }

 
     
let  CompVar1  :: 

CompVar


 
     
   | 

TString

 
     
let  OptExp  :: 


 
     
   | 

Exp

 
     
let  OptExp1  :: 


 
     
   | 

( OptExp )

 
     
let  Exp  :: 

include Exp


 
     
   | 

Exp0

 
     
   | 

require_once Exp

 
     
   | 

include_once Exp

 
     
   | 

require Exp

 
     
let  Exp0  :: 

Exp0 OR Exp1


 
     
   | 

Exp1

 
     
let  Exp1  :: 

Exp1 XOR Exp2


 
     
   | 

Exp2

 
     
let  Exp2  :: 

Exp3


 
     
   | 

Exp2 AND Exp3

 
     
let  Exp3  :: 

Exp4


 
     
   | 

print Exp3

 
     
let  Exp4  :: 

Var -= Exp4


 
     
   | 

Var &= Exp4

 
     
   | 

Var >>= Exp4

 
     
   | 

Var /= Exp4

 
     
   | 

list ( AsgElms ) = Exp4

 
     
   | 

Var = VarAsg

 
     
   | 

Var *= Exp4

 
     
   | 

Var %= Exp4

 
     
   | 

Var += Exp4

 
     
   | 

Var ^= Exp4

 
     
   | 

Var .= Exp4

 
     
   | 

Exp5

 
     
   | 

Var <<= Exp4

 
     
   | 

Var |= Exp4

 
     
let  Exp5  :: 

Exp5 ? Exp5 : Exp6


 
     
   | 

Exp6

 
     
let  Exp6  :: 

Exp6 || Exp7


 
     
   | 

Exp7

 
     
let  Exp7  :: 

Exp8


 
     
   | 

Exp7 && Exp8

 
     
let  Exp8  :: 

Exp9


 
     
   | 

Exp8 | Exp9

 
     
let  Exp9  :: 

Exp10


 
     
   | 

Exp9 ^ 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  :: 

Exp14


 
     
   | 

Exp13 >> Exp14

 
     
   | 

Exp13 << Exp14

 
     
let  Exp14  :: 

Exp15


 
     
   | 

Exp14 . Exp15

 
     
   | 

Exp14 - Exp15

 
     
   | 

Exp14 + Exp15

 
     
let  Exp15  :: 

Exp15 % Exp16


 
     
   | 

Exp15 / Exp16

 
     
   | 

Exp16

 
     
   | 

Exp15 * Exp16

 
     
let  Exp16  :: 

Var ++


 
     
   | 

- Exp16

 
     
   | 

new ClsIdRef FunArgs1

 
     
   | 

Exp17

 
     
   | 

Exp17 instanceof ClsIdRef

 
     
   | 

clone Exp16

 
     
   | 

++ Var

 
     
   | 

@ Exp16

 
     
   | 

~ Exp16

 
     
   | 

+ Exp16

 
     
   | 

Cast Exp16

 
     
   | 

-- Var

 
     
   | 

Var --

 
     
   | 

! Exp16

 
     
let  Exp17  :: 

array ( ArrayPairs )


 
     
   | 

die OptExp1

 
     
   | 

BuiltIn

 
     
   | 

Var

 
     
   | 

TOpenBQuote Encapses TCloseBQuote

 
     
   | 

( Exp )

 
     
   | 

exit OptExp1

 
     
   | 

Scalar

 
     
let  VarAsg  :: 

Exp5


 
     
   | 

& Var

 
     
   | 

& new ClsIdRef FunArgs1

 
     
let  BuiltIn  :: 

isset ( Vars )


 
     
   | 

eval ( Exp )

 
     
   | 

empty ( Var )

 
     
let  Cast  :: 

( real )


 
     
   | 

( integer )

 
     
   | 

( boolean )

 
     
   | 

( unset )

 
     
   | 

( float )

 
     
   | 

( string )

 
     
   | 

( bool )

 
     
   | 

( object )

 
     
   | 

( array )

 
     
   | 

( double )

 
     
   | 

( int )

 
     
let  ArrayPairs  :: 


 
     
   | 

ArrayPair ArrayPairs1

 
     
let  ArrayPairs1  :: 

, ArrayPair ArrayPairs1


 
     
   | 

ArrayPairs0

 
     
   | 

, ArrayPairs0

 
     
let  ArrayPairs0  :: 


 
     
let  ArrayPair  :: 

Exp => ExpRef


 
     
   | 

ExpRef

 
     
let  Scalar  :: 

TString


 
     
   | 

CommonScalar

 
     
   | 

THeredoc Encapses THeredoc

 
     
   | 

TOpenSQuote Encapses TCloseSQuote

 
     
   | 

TOpenDQuote Encapses TCloseDQuote

 
     
let  Encapses  :: 

Encaps Encapses


 
     
   | 

 
     
let  Encaps  :: 

TVariable


 
     
   | 

THLiteral

 
     
   | 

TDOpenCurly Exp }

 
     
   | 

THeredocEnd

 
     
   | 

TDOpenCurly TString [ Exp ] }

 
     
   | 

TInteger

 
     
   | 

TOpenCurlyD Var }

 
     
   | 

TString

 
     
   | 

TDLiteral

 
     
   | 

_other_

 
     
   | 

TBLiteral

 
     
   | 

Key1

 
     
   | 

TSLiteral

 
     
let  AsgElms0  :: 

, AsgElm AsgElms0


 
     
   | 

 
     
let  AsgElms  :: 

AsgElm AsgElms0


 
     
let  AsgElm  :: 

Var


 
     
   | 

 
     
   | 

list ( AsgElms )

 
     
let  ClsIdRef  :: 

TString


 
     
   | 

DynClsIdRef

 
     
let  DynClsIdRef  :: 

BaseVar


 
     
   | 

BaseVar -> ObjProps

 
     
let  ObjProps  :: 

ObjProp ObjProps0


 
     
let  ObjProps0  :: 

-> ObjProp ObjProps0


 
     
   | 

 
     
let  ObjProp  :: 

ObjProp [ OptExp ]


 
     
   | 

ObjProp { Exp }

 
     
   | 

CompVar1

 


Last update on 06 September 2010 . Authors & Credits . Feedback & Support