AddyScript Grammar

Here is the complete grammar for the AddyScript programming language, represented using railroad diagrams and Extended Backus-Naur Form (EBNF) notation.

Axiom

Program:

Program ::= StatementWithLabels*

Non-terminal symbols

StatementWithLabels:

StatementWithLabels ::= Label* Statement

Label:

Label ::= IDENTIFIER ':'

Statement:

Statement ::= ImportDirective
            | ClassDefinition
            | FunctionDecl
            | ExternalFunctionDecl
            | ConstantDecl
            | VariableDecl
            | Block
            | IfElse
            | SwitchBlock
            | ForLoop
            | ForEachLoop
            | WhileLoop
            | DoLoop
            | Continue
            | Break
            | Goto
            | Yield
            | Return
            | Throw
            | TryCatchFinally
            | AssignmentWithLet
            | Expression ';'

ImportDirective:

ImportDirective ::= 'import' QualifiedName ( 'as' IDENTIFIER )? ';'

QualifiedName:

QualifiedName ::= IDENTIFIER ( '::' IDENTIFIER )*

ClassDefinition:

ClassDefinition ::= Attributes? MODIFIER? 'class' IDENTIFIER ( ':' IDENTIFIER )? '{' ClassMember* '}'

Attributes:

Attributes ::= '[' Attribute ( ',' Attribute )* ']'

Attribute:

Attribute ::= IDENTIFIER ( '(' ( Expression | ( Expression ',' )? VariableSetterList )? ')' )?

ClassMember:

ClassMember ::= MemberPrefix? MemberSpec

MemberPrefix:

MemberPrefix ::= Attributes? ( SCOPE MODIFIER? | MODIFIER SCOPE? )?

MemberSpec:

MemberSpec ::= ConstructorSpec
             | FieldSpec
             | PropertySpec
             | MethodSpec
             | OperatorSpec
             | EventSpec

ConstructorSpec:

ConstructorSpec ::= 'constructor' ParameterList (':' 'super' ArgumentList)? Block

ParameterList:

ParameterList ::= '(' ( Parameter ( ',' Parameter )* )? ')'

Parameter:

Parameter ::= Attributes? ('&' | '..')? IDENTIFIER '!'? ('=' Literal)?

Literal:

Literal  ::= 'null'
           | BOOLEAN
           | INTEGER
           | BIG_INTEGER
           | FLOAT
           | BIG_DECIMAL
           | COMPLEX
           | DATE
           | STRING
           | BLOB

FieldSpec:

FieldSpec ::= IDENTIFIER ( '=' Expression )? ';'

PropertySpec:

PropertySpec ::= 'property' ( IDENTIFIER | '[]' ) (
    ( '=>' Expression )? ';'
    |
    '{' SCOPE? (
        'read' ( MethodBody SCOPE? 'write' )?
        |
        'write' ( MethodBody SCOPE? 'read' )?
    ) MethodBody '}'
)

MethodBody:

MethodBody ::= ( '=>' Expression )? ';' | Block

MethodSpec:

MethodSpec ::= 'function' IDENTIFIER ParameterList MethodBody

OperatorSpec:

OperatorSpec ::= 'operator' OverloadableOperator ParameterList MethodBody

OverloadableOperator:

OverloadableOperator ::= '+'
                       | '-'
                       | '++'
                       | '--'
                       | '~'
                       | '*'
                       | '/'
                       | '%'
                       | '#### '
                       | '&'
                       | '|'
                       | '^'
                       | '<<'
                       | '>>'
                       | '=='
                       | '!='
                       | '<'
                       | '>'
                       | '<='
                       | '>='
                       | 'startswith'
                       | 'endswith'
                       | 'contains'
                       | 'matches'

EventSpec:

EventSpec ::= 'event' ParameterList ';'

FunctionDecl:

FunctionDecl ::= Attributes? 'function' IDENTIFIER ParameterList FunctionBody

FunctionBody:

FunctionBody ::= '=>' Expression ';' | Block

ExternalFunctionDecl:

ExternalFunctionDecl ::= Attributes? 'extern' 'function' IDENTIFIER ParameterList ';'

VariableSetterList:

VariableSetterList ::= VariableSetter ( ',' VariableSetter )*

VariableSetter:

VariableSetter ::= IDENTIFIER '=' Expression

ConstantDecl:

ConstantDecl ::= 'const' VariableSetterList ';'

VariableDecl:

VariableDecl ::= 'var' VariableSetterList ';'

Block:

Block ::= '{' StatementWithLabels* '}'

IfElse:

IfElse ::= 'if' '(' Expression ')' Statement ( 'else' Statement )?

SwitchBlock:

SwitchBlock ::= 'switch' '(' Expression ')' '{' ( CaseLabel ':' StatementWithLabels* )* ( 'default' ':' StatementWithLabels* )? '}'

CaseLabel:

CaseLabel ::= 'case' ( BOOLEAN | INTEGER | STRING )

ForLoop:

ForLoop  ::= 'for' '(' ( VariableDecl | ExpressionList )? ';' Expression? ';' ExpressionList? ')' Statement

ExpressionList:

ExpressionList ::= Expression ( ',' Expression )*

ForEachLoop:

ForEachLoop ::= 'foreach' '(' IDENTIFIER ( '=>' IDENTIFIER )? 'in' Expression ')' Statement

WhileLoop:

WhileLoop ::= 'while' '(' Expression ')' Statement

DoLoop:

DoLoop   ::= 'do' Statement 'while' '(' Expression ')' ';'

Continue:

Continue ::= 'continue' ';'

Break:

Break ::= 'break' ';'

Goto:

Goto ::= 'goto' ( IDENTIFIER | 'case' ( BOOLEAN | INTEGER | STRING ) | 'default' ) ';'

Yield:

Yield ::= 'yield' Expression ';'

Return:

Return ::= 'return' Expression? ';'

Throw:

Throw ::= 'throw' Expression ';'

TryCatchFinally:

TryCatchFinally ::= 'try' ( '(' Expression ')' )? Block ( 'catch' '(' IDENTIFIER ')' Block )? ( 'finally' Block )?

AssignmentWithLet:

AssignmentWithLet ::= 'let' Reference '=' Expression ';'

Reference:

Reference ::= VariableRef
            | ItemRef
            | SliceRef
            | PropertyRef
            | StaticPropertyRef
            | ParentPropertyRef
            | ParentIndexerRef
            | TupleInitializer
            | SetInitializer

Expression:

Expression ::= Assignment

Note: Expression is an axiom to the expressions sublanguage (which is recognized by the ExpressionParser).

Assignment:

Assignment ::= TernaryExpression ( AssignmentOperator Assignment )*

AssignmentOperator:

AssignmentOperator ::= '='
                     | '+='
                     | '-='
                     | '*='
                     | '/='
                     | '%='
                     | '#### ='
                     | '&='
                     | '|='
                     | '^='
                     | '<<='
                     | '>>='
                     | '??='

TernaryExpression:

TernaryExpression ::= Condition ( '?' Expression ':' Expression )?

Condition:

Condition ::= Relation ( LogicalOperator Relation )*

LogicalOperator:

LogicalOperator ::= '&'
                  | '&&'
                  | '|'
                  | '||'
                  | '^'
                  | '??'

Relation:

Relation ::= Term ( RelationalOperator Term | 'is' 'not'? Pattern )?

RelationalOperator:

RelationalOperator ::= '=='
                     | '!='
                     | '<'
                     | '>'
                     | '<='
                     | '>='
                     | '==='
                     | '!=='
                     | 'startswith'
                     | 'endswith'
                     | 'contains'
                     | 'matches'
                     | 'not'? 'in'

Term:

Term ::= Factor ( ( '+' | '-' ) Factor )*

Factor:

Factor ::= Exponentiation ( ( '*' | '/' | '%' | '<<' | '>>' ) Exponentiation )*

Exponentiation:

Exponentiation ::= PostfixUnaryExpression ( '#### ' Exponentiation )*

PostfixUnaryExpression:

PostfixUnaryExpression ::= PrefixUnaryExpression ( '++' | '--' | '!' )*

PrefixUnaryExpression:

PrefixUnaryExpression ::= ( '+' | '-' | '~' | '!' | '++' | '--' )* Composite

Composite:

Composite ::= Atom ( '[' ( Expression | Expression? '..' Expression? ) ']' | '.' IDENTIFIER ArgumentList? | ArgumentList | ( 'switch' '{' MatchCaseList | 'with' '{' VariableSetterList ) '}' )*

ArgumentList:

ArgumentList ::= '(' ( Arguments ( ',' NamedArgList )? | NamedArgList )? ')'

Arguments:

Arguments ::= Argument ( ',' Argument )*

Argument:

Argument ::= '..'? Expression

NamedArgList:

NamedArgList ::= NamedArg ( ',' NamedArg )*

NamedArg:

NamedArg ::= IDENTIFIER ':' Expression

MatchCaseList:

MatchCaseList ::= MatchCase ( ',' MatchCase )*

MatchCase:

MatchCase ::= Pattern ( 'when' Expression )? '=>' MatchCaseExpression

Pattern:

Pattern  ::= '_'
           | 'null'
           | ( '>' | '<' | '>=' | '<=' )? ValuePattern
           | 'matches' STRING
           | TYPE_NAME ( '(' IDENTIFIER ( ',' IDENTIFIER )* ')' | ObjectPattern )?
           | ObjectPattern
           | NegativePattern
           | LogicalPattern
           | GroupingPattern
           | MUTABLE_STRING

ValuePattern:

ValuePattern ::= [+#x2D]? ( INTEGER | BIG_INTEGER | FLOAT | BIG_DECIMAL )
               | BOOLEAN
               | DATE
               | STRING

ObjectPattern:

ObjectPattern ::= '{' IDENTIFIER ':' Pattern ( ',' IDENTIFIER ':' Pattern )* '}'

NegativePattern:

NegativePattern ::= 'not' Pattern

LogicalPattern:

LogicalPattern ::= Pattern ( ( 'or' | 'and' ) Pattern )+

GroupingPattern:

GroupingPattern ::= '(' Pattern ')'

MatchCaseExpression:

MatchCaseExpression ::= Block | 'throw'? Expression

Atom:

Atom   ::= Literal
         | MUTABLE_STRING
         | 'this'
         | AtomStartingWithSuper
         | AtomStartingWithTypeOf
         | AtomStartingWithTypeName
         | AtomStartingWithId
         | AtomStartingWithNew
         | AtomStartingWithLParen
         | AtomStartingWithLBrace
         | ListInitializer
         | Lambda
         | InlineFunction

AtomStartingWithSuper:

AtomStartingWithSuper ::= 'super' ( '::' IDENTIFIER ArgumentList? | '[' Expression ']' )

AtomStartingWithTypeOf:

AtomStartingWithTypeOf ::= 'typeof' '(' ( TYPE_NAME | IDENTIFIER ) ')'

AtomStartingWithTypeName:

AtomStartingWithTypeName ::= TYPE_NAME '::' IDENTIFIER ArgumentList?

AtomStartingWithId:

AtomStartingWithId ::= QualifiedName ArgumentList?

AtomStartingWithNew:

AtomStartingWithNew ::= ObjectInitializer | ConstructorCall

ObjectInitializer:

ObjectInitializer ::= 'new' '{' VariableSetterList? '}'

ConstructorCall:

ConstructorCall ::= 'new' QualifiedName ( ArgumentList ( '{' VariableSetterList? '}' )? | '{' VariableSetterList? '}' )

AtomStartingWithLParen:

AtomStartingWithLParen ::= Conversion | TupleInitializer | ParenthesizedExpression

Conversion:

Conversion ::= '(' TYPE_NAME ')' Expression

TupleInitializer:

TupleInitializer ::= '(' Arguments ','? ')'

ParenthesizedExpression:

ParenthesizedExpression ::= '(' Expression ')'

AtomStartingWithLBrace:

AtomStartingWithLBrace ::= SetInitializer | MapInitializer

SetInitializer:

SetInitializer ::= '{' Arguments? '}'

MapInitializer:

MapInitializer ::= '{' ( MapItemInitializerList | '=>' ) '}'

MapItemInitializerList:

MapItemInitializerList ::= MapItemInitializer ( ',' MapItemInitializer )*

MapItemInitializer:

MapItemInitializer ::= Expression '=>' Expression

ListInitializer:

ListInitializer ::= '[' Arguments? ']'

Lambda:

Lambda   ::= '|' ( Parameter ( ',' Parameter )* )? '|' '=>' ( Expression ';' | Block )

InlineFunction:

InlineFunction ::= 'function' ParameterList Block

Terminal symbols

LETTER:

LETTER ::= 'A' - 'Z' | 'a' - 'z'

LETTER_EXTENDED:

LETTER_EXTENDED ::= LETTER
                  | '_'
                  | '\xc0' - '\xd6'
                  | '\xd8' - '\xf6'
                  | '\xf8' - '\xff'

DIGIT:

DIGIT ::= '0' - '9'

HEXDIGIT:

HEXDIGIT ::= DIGIT | 'A' - 'F' | 'a' - 'f'

IDENTIFIER:

IDENTIFIER ::= STANDARD_IDENTIFIER | SPECIAL_IDENTIFIER

STANDARD_IDENTIFIER:

STANDARD_IDENTIFIER ::= LETTER_EXTENDED ( LETTER_EXTENDED | DIGIT )*

SPECIAL_IDENTIFIER:

SPECIAL_IDENTIFIER ::= '$' ( LETTER_EXTENDED | DIGIT | ESCAPE_SEQ )+

ESCAPE_SEQ:

ESCAPE_SEQ ::= '\a'
             | '\b'
             | '\f'
             | '\n'
             | '\r'
             | '\t'
             | '\v'
             | ( '\x' | '\u' HEXDIGIT HEXDIGIT ) HEXDIGIT HEXDIGIT

BOOLEAN:

BOOLEAN ::= 'true' | 'false'

INTEGER:

INTEGER ::= DECIMAL_INTEGER | HEX_INTEGER

DECIMAL_INTEGER:

DECIMAL_INTEGER ::= ( DIGIT ( '_' DIGIT )* )+

HEX_INTEGER:

HEX_INTEGER ::= '0' [Xx] HEXDIGIT+

BIG_INTEGER:

BIG_INTEGER ::= INTEGER [Ll]

REAL:

REAL ::= ( DECIMAL_INTEGER? '.' )? DECIMAL_INTEGER ( ( 'e' | 'E' ) ( '+' | '-' )? DECIMAL_INTEGER )?

FLOAT:

FLOAT ::= REAL [Ff]?

BIG_DECIMAL:

BIG_DECIMAL ::= REAL [Dd]

COMPLEX:

COMPLEX ::= REAL [iI]

DATE:

DATE ::= '`' [^`]* '`'

MUTABLE_STRING:

MUTABLE_STRING ::= '$' STRING

STRING:

STRING ::= '@'? ( SINGLE_QUOTED | DOUBLE_QUOTED )

BLOB:

BLOB ::= [bB] ( SINGLE_QUOTED | DOUBLE_QUOTED )

SINGLE_QUOTED:

SINGLE_QUOTED ::= "'" ( [^'] | ESCAPE_SEQ )* "'"

DOUBLE_QUOTED:

DOUBLE_QUOTED ::= '"' ( [^"] | ESCAPE_SEQ )* '"'

TYPE_NAME:

TYPE_NAME ::= 'void'
            | 'bool'
            | 'int'
            | 'long'
            | 'rational'
            | 'float'
            | 'decimal'
            | 'complex'
            | 'date'
            | 'duration'
            | 'string'
            | 'list'
            | 'map'
            | 'set'
            | 'queue'
            | 'stack'
            | 'object'
            | 'resource'
            | 'closure'

MODIFIER:

MODIFIER ::= 'final' | 'static' | 'abstract'

SCOPE:

SCOPE ::= 'private' | 'protected' | 'public'

^{generated by RR - Railroad Diagram Generator}

Home | Previous | Next