[Language]
Name           = Lua
Extension      = lua
Keywords       = and, break , do, else, elseif, end, false, for, function, if,
               = in, local, nil, not, or,  repeat, return, then, true, until, while

Conflicts      = index
Case Sensitive = true
Options        =  
             
; =======================================================
; Literals    
; =======================================================              

[Types]
Integer      =  number
Real         =  number
Boolean      =  boolean
String       =  string

[Function ID]
Convention = camel
Normal     = {Name}
Conflict   = func_{Name}

[Variable ID]
Convention = camel
Normal     = {Name}
Conflict   = var_{Name}

[String Literal]
Text           = "{Characters}"
Replace Char 1 = "
Replace By 1   = \"
Replace Char 2 = \
Replace By 2   = \\

[Boolean Literal]
true     =  true
false    =  false

[Integer Literal]
Text     = {Integral}

[Real Literal]
Text     = {Integral}.{Fractional}

[Variable Access]
Precedence = 100
Text       = {Name}               | ~subscript
           = {Name}[{Subscript}]  | subscript      
           
; =======================================================
; Expressions      
; =======================================================
; Lua precedence: 
; 1. or 
; 2. and 
; 3. Relational ==, >, < ...
; 4. Concatenation: ..
; 5. Addition 
; 6. Multiply 
; 7. Unary: Not, -
; 8. ^
; 100. Atom, paranthesis
         
[Or]
Precedence   = 1
Needed 1     = 1
Needed 2     = 2
Text         = {1} or {2}

[And]
Precedence   = 2
Needed 1     = 2
Needed 2     = 3
Text         = {1} and {2}

[Equals]
Precedence   = 3                            
Needed 1     = 4      
Needed 2     = 4 
Text         = {1} == {2}

[Not Equals]
Precedence   = 3                            
Needed 1     = 4      
Needed 2     = 4 
Text         = {1} ~= {2}
             
[Less Than]
Precedence   = 3                            
Needed 1     = 4      
Needed 2     = 4 
Text         = {1} < {2}

[Less Equal Than]
Precedence   = 3                            
Needed 1     = 4      
Needed 2     = 4 
Text         = {1} <= {2}

[Greater Than]
Precedence   = 3                            
Needed 1     = 4      
Needed 2     = 4 
Text         = {1} > {2}

[Greater Equal Than]
Precedence   = 3                            
Needed 1     = 4      
Needed 2     = 4 
Text         = {1} >= {2}

[Concatenate]
Precedence   = 4
Needed 1     = 4
Needed 2     = 5
Text         = {1} .. {2}  

[Add]            
Precedence   = 5
Needed 1     = 5
Needed 2     = 6
Text         = {1} + {2}

[Subtract]
Precedence   = 5
Needed 1     = 5
Needed 2     = 6
Text         = {1} - {2}

[Multiply]
Precedence   = 6
Needed 1     = 6
Needed 2     = 7
Text         = {1} * {2}

[Divide]
Precedence   = 6
Needed 1     = 6
Needed 2     = 7
Text         = {1} / {2}  

[Modulus]
Precedence   = 1
Needed 1     = 1
Needed 2     = 1
Text         = math.fmod({1}, {2})

[Power]
Precedence   = 8
Needed 1     = 9
Needed 2     = 8
Text         = {1} ** {2}

[Not]
Precedence   = 7
Needed 1     = 7
Text         = not {1}

[Negate]
Precedence   = 7
Needed 1     = 7
Text         = -{1}

[Subexpression]
Precedence   = 100
Text         = ({Expression})

; =======================================================
; Intrinsic Functions      
; =======================================================

[Abs]
Precedence = 100
Needed 1   = 100
Text       =  math.abs{1} 

[ArcCos]
Precedence = 100
Needed 1   = 0 
Text       = math.acos({1})

[ArcSin]
Precedence = 100
Needed 1   = 0 
Text       = math.asin({1})

[ArcTan]
Precedence = 100
Needed 1   = 0 
Text       = math.atan({1})

[Char]
Precedence = 100
Needed 1   = 100
Needed 2   = 0
Text       = string.sub({1}, index({1}), index({1})

[Cos]
Precedence = 100
Needed 1   = 0 
Text       = math.cos({1})

[Int]
Precedence = 100
Needed 1   = 100 
Text       =  math.floor({1})

[Len]
Precedence = 100
Needed 1   = 100 
Text       = string.len({1})

[Log]
Precedence = 100
Needed 1   = 0 
Text       = math.log({1})

[Log10]
Precedence = 100
Needed 1   = 0 
Text       = math.log10({1})

[Pi]
Precedence = 100
Text       = math.pi

[Random]
Precedence = 100
Needed 1   = 0
Text       = (math.random({1}) - 1)

[Sin]
Precedence = 100
Needed 1   = 0 
Text       = math.sin({1})

[Sgn]
Precedence = 100
Needed 1   = 0 
Text       = sgn({1})

[Size]
Precedence = 100
Needed 1   = 100 
Text       = size({1})

[Sqrt]
Precedence = 100
Needed 1   = 0 
Text       = math.sqrt({1})

[Tan]
Precedence = 100
Needed 1   = 0 
Text       = math.tan({1})

[ToChar]
Precedence = 100
Needed 1   = 0
Text       = string.char({1})

[ToCode]
Precedence = 100
Needed 1   = 0
Text       = string.byte({1})

[ToInteger]
Precedence = 100
Needed 1   = 0
Text       = math.floor(tonumber({1}))

[ToFixed]
Precedence = 100
Needed 1   = 0 
Needed 2   = 0 
Text       = toFixed({1}, {2})

[ToReal]
Precedence = 100
Needed 1   = 0
Text       = tonumber({1})

[ToString]
Precedence = 100
Needed 1   = 0
Text       = tostring({1})

; =======================================================
; Function call      
; =======================================================

[Function Call]
Precedence = 100
Text       = {name}({arguments}) 

[Argument]
Separator  = ,{space}
Text       = {expression}

; =======================================================
; Program
; =======================================================

[Program]
Text      = -- Gets the size of the array (by using the max index)  | size  
          = function size(values)                                   | size 
          = return table.maxn(values) + 1                           | size | 1
          = end                                                     | size
          =                                                         | size
          
          = -- Lua lacks a sign function. This code implements it.    | sgn
          = function sgn(n)                                           | sgn    
          = if n == 0 then                                            | sgn   |  1
          = return 0                                                  | sgn   |  2
          = elseif n < 0 then                                         | sgn   |  1
          = return -1                                                 | sgn   |  2
          = else                                                      | sgn   |  1
          = return 1                                                  | sgn   |  1
          = end                                                       | sgn   |  1
          = end                                                       | sgn   |
          =                                                           | sgn
                    
          = def toFixed(value, digits)                                | tofixed 
          = return string.format("%0." .. digits .. "f", value)       | tofixed  | 1 
          = end                                                       | tofixed 
          =                                                           | tofixed
          
          = -->FUNCTIONS 
          = -->MAIN

[Main]
Text      = -- Main                         | functions  
          = math.randomseed(os.time ())  -- Prepare the random number generator | random   
          =                                                                     | random   
          = -->BLOCK

; =======================================================
; Function  
; =======================================================
          
[Function]
Text      = function {name}({parameters})   
          = -->BLOCK                                          |        | 1 
          =                                                   | return | 1
          = return {return}                                   | return | 1          
          = end
          = 

[Parameter]
Separator = ,{space}
Text      = {name}        
               
; =======================================================
; Statements      
; =======================================================

[Assign]         
Text       = {Variable} = {Expression}            

[Call]
Text       = {Name} ({Arguments})

[Comment]
Text       = -- {Text} 

[Declare Name]
Separator  = ,{space}       
Text       = {name}         | ~array
           = {Name} = {{}   | array

[Declare]
Text       = local {variables}            

[Do]
Text       = repeat
           = -->BLOCK                              | | 1   
           = until not ({condition}) 
          
[For]
Text       = for {Variable} = {start}, {end} do             | inc, ~step
           = for {Variable} = {start}, {end}, {step} do     | inc, step
           = for {Variable} = {start}, {end}, -{step} do    | ~inc
           = -->BLOCK                                       |           | 1              
           = end 
           
[Input]
Text       = {Variable} = tonumber(io.read())                 | integer
           = {Variable} = tonumber(io.read())                 | real
           = {Variable} = string.lower(io.read()) == "true")  | boolean
           = {Variable} = io.read()                           | string
           = {Variable} = io.read()                           | none
           
[If]
Text       = if {condition} then
           = -->TRUEBLOCK                  |        | 1
           = else                          | else 
           = -->FALSEBLOCK                 | else   | 1 
           = end

[Output]
Separator = ,{space}
Text       = io.write({List}, "\n")      | newline     
           = io.write({List})            | ~newline       
          
[While]
Text       = while {condition} do
           = -->BLOCK                   | | 1
           = end