Formal Reference

This page is a compact lookup for Expr syntax.

It is not a tutorial. For explanations and examples, use the linked reference chapters.

Expr source is a sequence of statements.

Normal expression statements require a semicolon. Block-style statements and declarations can omit the trailing semicolon, but a semicolon is accepted after them.

a = 1;
 
if(a > 0)
{
    print('positive');
};
 
function Add(a, b)
{
    return a + b;
}

Recommended style is one statement per line, semicolons after ordinary expressions, and braces for blocks.

See Lexical basics.

G-code hash variables, wrapper markers, named operators, and modifiable comments are host compatibility features. They are not normal strict Expr syntax.

See Host integration.

Core keywords:

if
else
loop
while
for
return
break
continue
include
as
set
function
class
true
false

Reserved contextual names:

this

Do not use keywords as ordinary variable, function, class, parameter, method, or property names.

Built-in function names are not hard-reserved. A user-defined function can shadow a built-in function in the active session. Avoid this unless it is deliberate and clearly documented.

Built-in global object names such as `settings`, `controller`, `session`, and `python` are protected global names and cannot be overwritten.

See Variables and assignment and Built-in objects.

This grammar is intentionally compact. It describes normal strict Expr source. Host compatibility syntax is not included.

program             = { top_statement } ;
 
top_statement       = include_statement [ ";" ]
                    | function_declaration [ ";" ]
                    | class_declaration [ ";" ]
                    | statement ;
 
statement           = block [ ";" ]
                    | if_expression [ ";" ]
                    | loop_expression [ ";" ]
                    | while_expression [ ";" ]
                    | for_expression [ ";" ]
                    | return_statement ";"
                    | break_statement ";"
                    | continue_statement ";"
                    | expression ";" ;
 
block               = "{" { statement } "}" ;
 
include_statement   = "include" string_literal [ "as" identifier ] ;
function_declaration= "function" qualified_identifier "(" [ parameter_list ] ")" block ;
class_declaration   = "class" qualified_identifier "(" [ parameter_list ] ")" class_block ;
 
class_block         = "{" { field_statement | method_declaration } "}" ;
field_statement     = expression ";" ;
method_declaration  = "function" identifier "(" [ parameter_list ] ")" block ;
 
parameter_list      = identifier { "," identifier } ;
argument_list       = expression { "," expression } ;
qualified_identifier= identifier [ "::" identifier ] ;
 
if_expression       = "if" "(" expression ")" statement_or_block [ "else" statement_or_block ] ;
loop_expression     = "loop" "(" expression ")" statement_or_block ;
while_expression    = "while" "(" expression ")" statement_or_block ;
for_expression      = "for" "(" [ expression ] ";" [ expression ] ";" [ expression ] ")" statement_or_block ;
 
statement_or_block  = block | statement ;
return_statement    = "return" [ expression ] ;
break_statement     = "break" ;
continue_statement  = "continue" ;
 
expression          = assignment ;
assignment          = conditional_expression
                    | assignable assignment_operator assignment ;
conditional_expression
                    = logical_or [ "?" expression ":" expression ] ;
logical_or          = logical_xor { "||" logical_xor } ;
logical_xor         = logical_and { "^^" logical_and } ;
logical_and         = bitwise_or { "&&" bitwise_or } ;
bitwise_or          = bitwise_xor { "|" bitwise_xor } ;
bitwise_xor         = bitwise_and { "^" bitwise_and } ;
bitwise_and         = equality { "&" equality } ;
equality            = relational { ( "==" | "!=" ) relational } ;
relational          = shift { ( ">" | ">=" | "<" | "<=" ) shift } ;
shift               = additive { ( "<<" | ">>" ) additive } ;
additive            = multiplicative { ( "+" | "-" ) multiplicative } ;
multiplicative      = power { ( "*" | "/" | "%" ) power } ;
power               = unary { "**" unary } ;
unary               = [ "+" | "-" | "!" | "~" | "++" | "--" ] postfix ;
postfix             = primary { "++" | "--" | member_access } ;
member_access       = "." identifier [ "(" [ argument_list ] ")" ] ;
 
primary             = literal
                    | identifier
                    | qualified_identifier "(" [ argument_list ] ")"
                    | "this"
                    | "(" expression ")"
                    | block
                    | if_expression
                    | loop_expression
                    | while_expression
                    | for_expression ;
 
assignable          = identifier
                    | "set" identifier
                    | primary "." identifier ;
 
assignment_operator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**="
                    | "&=" | "|=" | "^=" | "<<=" | ">>=" ;
 
literal             = number_literal | string_literal | "true" | "false" ;

Notes:

• This grammar is simplified for documentation. Parser diagnostics are the authority for exact invalid forms.
• `include` is valid only at top level.
• `class` is valid only at top level.
• `function` is valid at top level or inside a class body as a method.
• `set` creates a local variable and is not valid at top level.
• `else if` is parsed as `else` followed by another `if` expression.
• Included files are parsed with strict default options.

See Include system, Functions, and Classes and user-defined objects.

Higher rows bind before lower rows.

Named operators are accepted only when the host enables named-operator compatibility mode. Prefer symbolic operators in normal Expr scripts.

Logical compound assignment forms are not part of Expr syntax:

a &&= b;        // not supported
a ||= b;        // not supported
a ^^= b;        // not supported

See Operators and Expression rules.

Expr runtime values are grouped into these core categories:

`true` and `false` are boolean-style numeric values, not a separate boolean type.

See Type system and Objects.

See Scope and set and Variables and assignment.

Included files do not inherit these compatibility options.

See Host integration and Lexical basics.

Previous: Limits and performance

Next: Glossary