Skip Navigation
 
 

lua Language Reference


Regular Grammar

( legend )
let  Byte  :: 

'\00' .. '\ff'


8-bit clean

 
     
let  Letter  :: 

LargeLetter | SmallLetter


 
     
let  LargeLetter  :: 

"A" .. "Z"


 
     
let  SmallLetter  :: 

"a" .. "z"


 
     
let  Digit  :: 

"0" .. "9"


 
     
let  Hex  :: 

Digit | "a" .. "f" | "A" .. "F"


 
     
let  Keep  :: 

'\\\'\"\n'


 
     
let  Char  :: 

Byte - Keep | "\\" 'abfnrtv' | "\\" Keep | "\\" "z" { White } | "\\" Digit [ Digit ] [ Digit ] | "\\" "x" Hex Hex


control keep ignore FIXME not working deccode hexcode

 
     
tok  PI  :: 

"#!" { Byte - '\n\r' }


 
     
tok  name  :: 

( Letter | '_' ) { Letter | Digit | "_" }


 
     
tok  string  :: 

"\"" { Char | "\'" } "\"" | "\'" { Char | "\"" } "\'"


 
     
tok  LongStringBlk  :: 

"[[" ( { Byte } - ( { Byte } "]]" { Byte } ) ) "]]"


 
     
tok  LongStringPat:GLongString  :: 

<= "[" > '=' < "[" >


 
     
tok  GLongString:LongStringEnd  :: 

<? "]" > LongStringPat < "]" >


 
     
tok  GLongString:LongStringAny  :: 

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


 
     
tok  number  :: 

Digit + [ "." { Digit } ] [ 'Ee' [ '+-' ] Digit + ] | "." Digit + [ 'Ee' [ '+-' ] Digit + ] | "0" 'Xx' Hex + [ "." { Hex } ] [ 'Pp' [ '+-' ] Digit + ] | "0" 'Xx' "." Hex + [ 'Pp' [ '+-' ] Digit + ]


 
     
com  Comment  :: 

"--" [ ( Byte - '[\n' ) { Byte - '\n' } ]


 
     
com  LongCommentBlk  :: 

"--[[" ( { Byte } - ( { Byte } "]]" { Byte } ) ) "]]"


 
     
com  LongCommentPat:GLongComment  :: 

<= "--[" > '=' < "[" >


 
     
com  GLongComment:LongCommentEnd  :: 

<? "]" > LongCommentPat < "]" >


 
     
com  GLongComment:LongCommentAny  :: 

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


 
     
ign White = '\20' ;| '\a\b\f\n\r\t\v'
ign  White  :: 

'\20' | '\07' | '\08' | '\0C' | '\0B' | '\n\r\t'


 
     
tok  sym  :: 

"(" | ")" | "[" | "]" | "{" | "}" | "=" | ";" | ":" | "," | "." | "..."


 
     
let  binop  :: 

"+" | "-" | "*" | "/" | "%" | ".." | "==" | "~=" | "<=" | ">=" | "<" | ">" | "^"


 
     
let  unop  :: 

"-" | "#"


 
     
tok  mixfix  :: 

"-"


 
     
tok  binfix  :: 

binop - mixfix


 
     
tok  prefix  :: 

unop - mixfix


 



Context-free Grammar

( legend )

 The Lua Grammar
start  Chunk  :: 

Block


 
     
   | 

PI Block

 

 
     
start  Block  :: 

XRetStat ; Block0


 
     
   | 

XRetStat Block0

 

 
     
   | 

 

 
     
   | 

Stat Block

 

 
     
let  Block0  :: 


 
     
let  XRetStat  :: 

return ExplistA


 
     
-- Statements ------------------------------------------------------------------
let  Stat  :: 

_List1 = Explist


 
     
   | 

:: name ::

 

 
     
   | 

while Exp do Block end

 

 
     
   | 

for name = Exp , Exp StepExp do Block end

 

 
     
   | 

local function name FunBody end

 

 
     
   | 

local Namelist ExplistB

 

 
     
   | 

break

 

 
     
   | 

;

 

 
     
   | 

do Block end

 

 
     
   | 

function FunName FunBody end

 

 
     
   | 

for Namelist in Explist do Block end

 

 
     
   | 

if ZifblkA end

 

 
     
   | 

goto name

 

 
     
   | 

FunCall

 

 
     
   | 

repeat Block until Exp

 

 
     
let  _List1  :: 

Var _List1_0

 

 
     
let  _List1_0  :: 

, Var _List1_0

 

 
     
   | 

 

 
     
let  ZifblkA  :: 

Exp then Block ZifblkB


 
     
let  ZifblkB  :: 

elseif ZifblkA


 
     
   | 

 

 
     
   | 

else Block

 

 
     
let  StepExp  :: 

LitOne


 
     
   | 

, Exp

 

 
     
-- Functions --------------------------------------------------------------------
let  FunLit  :: 

function FunBody end


 
     
let  FunBody  :: 

( ParList ) Block


 
     
let  FunName  :: 

_List2 : name


 
     
   | 

_List2

 

 
     
let  _List2  :: 

name _List2_0

 

 
     
let  _List2_0  :: 

 

 
     
   | 

. name _List2_0

 

 
     
let  ParList0  :: 


 
     
let  ParList  :: 


 
     
   | 

Par0 ParList0

 

 
     
   | 

ParList2

 

 
     
let  ParList2  :: 

Par ParList1


 
     
let  ParList1  :: 

, Par0 ParList0


 
     
   | 

 

 
     
   | 

, Par ParList1

 

 
     
let  Par0  :: 

...


 
     
let  Par  :: 

name


 
     
-- Various lists ---------------------------------------------------------------
let  Namelist0  :: 


 
     
   | 

, name Namelist0

 

 
     
let  Namelist  :: 

name Namelist0


 
     
-- Expressions -----------------------------------------------------------------
let  LongStringBody  :: 

LongStringEnd LongStringBody


 
     
   | 

 

 
     
   | 

LongStringAny LongStringBody

 

 
     
let  LongString  :: 

LongStringBlk


 
     
   | 

LongStringPat LongStringBody LongStringPat

 

 
     
let  Xargs  :: 

( ExplistA )


 
     
   | 

Yarg Explist2

 

 
     
let  Yarg  :: 

TableLit


 
     
   | 

LitStr

 

 
     
let  LitStr  :: 

LongString


 
     
   | 

string

 

 
     
let  LitOne  :: 


 
     
let  Lit  :: 

false


 
     
   | 

nil

 

 
     
   | 

true

 

 
     
   | 

number

 

 
     
   | 

LitStr

 

 
     
let  Exp  :: 

Exp1


 
     
let  Exp1  :: 

Exp2


 
     
   | 

Exp1 or Exp2

 

 
     
let  Exp2  :: 

Exp3


 
     
   | 

Exp2 and Exp3

 

 
     
let  Exp3  :: 

Exp3 < Exp4


 
     
   | 

Exp3 ~= Exp4

 

 
     
   | 

Exp3 <= Exp4

 

 
     
   | 

Exp3 == Exp4

 

 
     
   | 

Exp3 >= Exp4

 

 
     
   | 

Exp3 > Exp4

 

 
     
   | 

Exp4

 

 
     
let  Exp4  :: 

Exp5


 
     
   | 

Exp5 .. Exp4

 

 
     
let  Exp5  :: 

Exp5 + Exp6


 
     
   | 

Exp6

 

 
     
   | 

Exp5 - Exp6

 

 
     
let  Exp6  :: 

Exp7


 
     
   | 

Exp6 * Exp7

 

 
     
   | 

Exp6 % Exp7

 

 
     
   | 

Exp6 / Exp7

 

 
     
let  Exp7  :: 

# Exp7


 
     
   | 

Exp8

 

 
     
   | 

- Exp7

 

 
     
   | 

not Exp7

 

 
     
let  Exp8  :: 

Exp9 ^ Exp8


 
     
   | 

Exp9

 

 
     
let  Exp9  :: 

PrefixExp0


 
     
   | 

FunCall

 

 
     
   | 

TableLit

 

 
     
   | 

FunLit

 

 
     
   | 

...

 

 
     
   | 

Lit

 

 
     
let  PrefixExp0  :: 

Var


 
     
   | 

( Exp )

 

 
     
let  PrefixExp  :: 

PrefixExp0


 
     
   | 

FunCall

 

 
     
let  Var  :: 

name


 
     
   | 

PrefixExp . name

 

 
     
   | 

PrefixExp [ Exp ]

 

 
     
let  FunCall  :: 

PrefixExp Xargs


 
     
   | 

PrefixExp : name Xargs

 

 
     
-- Expression Lists ------------------------------------------------------------
let  Explist2  :: 


 
     
let  Explist0  :: 


 
     
   | 

, Exp Explist0

 

 
     
let  Explist  :: 

Exp Explist0


 
     
let  ExplistB  :: 

= Explist


 
     
   | 

Explist2

 

 
     
let  ExplistA  :: 

Explist2


 
     
   | 

Explist

 

 
     
-- Tables ----------------------------------------------------------------------
let  TableLit  :: 

{ Fieldlist }


 
     
-- Field Lists -----------------------------------------------------------------
let  Fieldlist0  :: 

;


 
     
   | 

, Field Fieldlist0

 

 
     
   | 

 

 
     
   | 

; Field Fieldlist0

 

 
     
   | 

,

 

 
     
let  Fieldlist  :: 

,


 
     
   | 

Field Fieldlist0

 

 
     
   | 

;

 

 
     
   | 

 

 
     
let  Field  :: 

[ Exp ] = Exp


 
     
   | 

name = Exp

 

 
     
   | 

Exp

 

 

----------------------------------------------------------------------------------------------- Conflict rules