maiascript:

expression eof

maiascript
         ::= expression*
           | eof

no references


operation:

variableAssignment

operation
         ::= variableAssignment

referenced by:


variableAssignment:

logicalORExpression = := ?=

variableAssignment
         ::= logicalORExpression ( ( '=' | ':=' | '?=' ) logicalORExpression )*

referenced by:


logicalORExpression:

logicalXORExpression ||

logicalORExpression
         ::= logicalXORExpression ( '||' logicalXORExpression )*

referenced by:


logicalXORExpression:

logicalANDExpression ||||

logicalXORExpression
         ::= logicalANDExpression ( '||||' logicalANDExpression )*

referenced by:


logicalANDExpression:

bitwiseORExpression &&

logicalANDExpression
         ::= bitwiseORExpression ( '&&' bitwiseORExpression )*

referenced by:


bitwiseORExpression:

bitwiseXORExpression |

bitwiseORExpression
         ::= bitwiseXORExpression ( '|' bitwiseXORExpression )*

referenced by:


bitwiseXORExpression:

bitwiseANDExpression |||

bitwiseXORExpression
         ::= bitwiseANDExpression ( '|||' bitwiseANDExpression )*

referenced by:


bitwiseANDExpression:

equalityExpression &

bitwiseANDExpression
         ::= equalityExpression ( '&' equalityExpression )*

referenced by:


equalityExpression:

relationalExpression == !=

equalityExpression
         ::= relationalExpression ( ( '==' | '!=' ) relationalExpression )*

referenced by:


relationalExpression:

shiftExpression < > <= >=

relationalExpression
         ::= shiftExpression ( ( '<' | '>' | '<=' | '>=' ) shiftExpression )*

referenced by:


shiftExpression:

additiveExpression << >>

shiftExpression
         ::= additiveExpression ( ( '<<' | '>>' ) additiveExpression )*

referenced by:


additiveExpression:

multiplicativeExpression + -

additiveExpression
         ::= multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )*

referenced by:


multiplicativeExpression:

powerExpression * / %

multiplicativeExpression
         ::= powerExpression ( ( '*' | '/' | '%' ) powerExpression )*

referenced by:


powerExpression:

unaryExpression ^

powerExpression
         ::= unaryExpression ( '^' unaryExpression )*

referenced by:


unaryExpression:

~ ! primary

unaryExpression
         ::= ( '~' | '!' )? primary

referenced by:


primary:

member value parenthesizedExpression

primary  ::= member
           | value
           | parenthesizedExpression

referenced by:


statement:

namespace function include local if do while for foreach try test break continue return throw

statement
         ::= namespace
           | function
           | include
           | local
           | if
           | do
           | while
           | for
           | foreach
           | try
           | test
           | 'break'
           | 'continue'
           | return
           | throw

referenced by:


namespace:

namespace object identifier { expression }

namespace
         ::= ( 'namespace' | 'object' ) identifier '{' expression* '}'

referenced by:


function:

async constructor kernel function identifier ( arguments ) { expression }

function ::= ( 'async' | 'constructor' | 'kernel' | 'function' ) identifier '(' arguments? ')' '{' expression* '}'

referenced by:


include:

include ( expression )

include  ::= 'include' '(' expression ')'

referenced by:


local:

local expression

local    ::= 'local' expression

referenced by:


if:

if ( expression ) { expression } elseif else

if       ::= 'if' '(' expression ')' '{' expression* '}' elseif* else?

referenced by:


elseif:

elseif ( expression ) { expression }

elseif   ::= 'elseif' '(' expression ')' '{' expression* '}'

referenced by:


else:

else { expression }

else     ::= 'else' '{' expression* '}'

referenced by:


do:

do { expression } while ( expression )

do       ::= 'do' '{' expression* '}' 'while' '(' expression ')'

referenced by:


while:

while ( expression ) { expression }

while    ::= 'while' '(' expression ')' '{' expression* '}'

referenced by:


for:

for ( expression ; expression ; expression ) { expression }

for      ::= 'for' '(' expression? ';' expression? ';' expression? ')' '{' expression* '}'

referenced by:


foreach:

foreach ( expression ; expression ; expression ) { expression }

foreach  ::= 'foreach' '(' expression? ';' expression? ';' expression? ')' '{' expression* '}'

referenced by:


try:

try { expression } catch

try      ::= 'try' '{' expression* '}' catch?

referenced by:


test:

test ( expression ; expression ; expression ) { expression } catch

test     ::= 'test' '(' expression? ( ';' expression? ( ';' expression? )? )? ')' '{' expression* '}' catch?

referenced by:


catch:

catch ( expression ) { expression }

catch    ::= 'catch' '(' expression ')' '{' expression* '}'

referenced by:


return:

return ( expression )

return   ::= 'return' '(' expression? ')'

referenced by:


throw:

throw ( expression )

throw    ::= 'throw' '(' expression? ')'

referenced by:


expression:

statement operation comment

expression
         ::= statement
           | operation
           | comment

referenced by:


arguments:

expression ,

arguments
         ::= expression ( ',' expression )*

referenced by:


member:

identifier . ( arguments ) [ arguments ]

member   ::= identifier ( '.' identifier )* ( '(' arguments* ')' | ( '[' arguments ']' )* )

referenced by:


array:

{ element , }

array    ::= '{' element ( ',' element )* '}'

referenced by:


matrix:

[ row ; row ]

matrix   ::= '[' row? ( ';' row )* ']'

referenced by:


element:

key : expression

element  ::= ( key ':' )? expression

referenced by:


key:

string

key      ::= string

referenced by:


row:

column ,

row      ::= column ( ',' column )*

referenced by:


column:

expression

column   ::= expression

referenced by:


parenthesizedExpression:

( expression )

parenthesizedExpression
         ::= '(' expression ')'

referenced by:


value:

real complex string array matrix null true false

value    ::= real
           | complex
           | string
           | array
           | matrix
           | 'null'
           | 'true'
           | 'false'

referenced by:


whitespace:

whitespace

whitespace
         ::= whitespace^token
          /* ws: definition */

referenced by:


eof:

$

eof      ::= $

referenced by:


identifier:

( firstIdentifierChar identifierChar* ) - reservedWord

identifier
         ::= ( firstIdentifierChar identifierChar* ) - reservedWord

referenced by:


reservedWord:

keyword null booleanLiteral

reservedWord
         ::= keyword
           | 'null'
           | booleanLiteral

referenced by:


keyword:

namespace object async constructor kernel function include local if elseif else do while for foreach try catch test break continue return throw

keyword  ::= 'namespace'
           | 'object'
           | 'async'
           | 'constructor'
           | 'kernel'
           | 'function'
           | 'include'
           | 'local'
           | 'if'
           | 'elseif'
           | 'else'
           | 'do'
           | 'while'
           | 'for'
           | 'foreach'
           | 'try'
           | 'catch'
           | 'test'
           | 'break'
           | 'continue'
           | 'return'
           | 'throw'

referenced by:


booleanLiteral:

true false

booleanLiteral
         ::= 'true'
           | 'false'

referenced by:


firstIdentifierChar:

$ _ [A-Z] [a-z]

firstIdentifierChar
         ::= [$_A-Za-z]

referenced by:


identifierChar:

$ _ [0-9] [A-Z] [a-z]

identifierChar
         ::= [$_0-9A-Za-z]

referenced by:


string:

" unicode \" \\ \/ \b \f \n \r \t "

string   ::= '"' ( unicode | '\"' | '\\' | '\/' | '\b' | '\f' | '\n' | '\r' | '\t' )* '"'

referenced by:


unicode:

alphabet - ["#x005C]

unicode  ::= alphabet - ["#x005C]

referenced by:


alphabet:

[#x0009] [#x000A] [#x000D] [#x0020-#xD7FF] [#xE000-#xFFFD] [#x10000-#x10FFFF]

alphabet ::= [#x0009#x000A#x000D#x0020-#xD7FF#xE000-#xFFFD#x10000-#x10FFFF]

referenced by:


complex:

real imaginary

complex  ::= real? imaginary

referenced by:


real:

- digit . digit e E + - digit

real     ::= '-'? digit+ ( '.' digit+ )? ( ( 'e' | 'E' ) ( '+' | '-' )? digit+ )?

referenced by:


imaginary:

+ - real * i

imaginary
         ::= ( '+' | '-' )? real '*' 'i'

referenced by:


digit:

[0-9]

digit    ::= [0-9]

referenced by:


comment:

singleLineComment

comment  ::= singleLineComment

referenced by:


singleLineComment:

// # sourceCharacter - lineTerminator

singleLineComment
         ::= ( '//' | '#' ) ( sourceCharacter - lineTerminator )*

referenced by:


sourceCharacter:

.

sourceCharacter
         ::= .

referenced by:


lineTerminator:

[#x000A] [#x000D] [#x2028] [#x2029]

lineTerminator
         ::= [#x000A#x000D#x2028#x2029]

referenced by:


whitespace:

[#x0009] [#x000A] [#x000D] [#x0020]

whitespace
         ::= [#x0009#x000A#x000D#x0020]+

referenced by:


  ... generated by RR - Railroad Diagram Generator R R