source: java/Framclipse/com.framsticks.framclipse/src/com/framsticks/framclipse/FramScript.xtext @ 437

grammar com.framsticks.framclipse.FramScript with org.eclipse.xtext.common.Terminals

import "http://www.eclipse.org/emf/2002/Ecore" as ecore

generate framScript "http://www.framsticks.com/framclipse/FramScript"

Model :
        (Neuro|Expdef|Style|Show|Script|Include) ;
        
FramclipseClass :
        (Neuro|Expdef|Style|Show|Script|Property|State) ;
        
Neuro :
        'class:' 
//      'name:' name=ID
        headers+=NeuroHeader+
        code=CodeSection
        (propertyImports+=PropertyIncludeDeclaration |
        properties+=Property)*
        ;

Expdef :
        'expdef:' 
        headers+=Header+
        code=CodeSection
        (propertyImports+=PropertyIncludeDeclaration |
        properties+=Property |
        states+=State)*
        ;
        
Style :
        'style:'
        headers+=Header+
        code=CodeSection
        (propertyImports+=PropertyIncludeDeclaration |
        properties+=Property)*
        ;
        
Show :
        'show:'
        headers+=ShowHeader+
        code=CodeSection
        (propertyImports+=PropertyIncludeDeclaration |
        properties+=Property)*
        ;
        
Script :
        'script:'
        headers+=Header+
        code=CodeSection
        ;
        
Property :
        'prop:'
        headers += PropertyHeader*
        'id:' name=ID 
        headers += PropertyHeader+
        ;
        
State :
        'state:' 
        headers += PropertyHeader*
        'id:' name=ID 
        headers += PropertyHeader+
        ;
        
Include : {Include}
        code=Code?
        (properties+=Property |
        states+=State)*
;
        
Header :
        name=ID value=HEADER_VALUE ;
        
NeuroHeader returns Header :
{IntHeader}             name=('prefinputs:' | 'prefoutput:' | 'preflocation:' | 'vhints:') intValue=IntValue |
{IconHeader}    name='icon:' icon=Icon |
{IconHeader}    name='icon:~' icon=Icon '~' |
                                Header ;
                                
Icon : 
        INT (',' INT)+ ;
        
PropertyHeader returns Header :
        TypeHeader |
        FlagsHeader |
        Header ;
        
ShowHeader returns Header :
        name='expdef:' value=ID |
        Header ;
        
FlagsHeader returns Header :
{IntHeader}     name='flags:' intValue=INT ;
        
TypeHeader :
        name='type:' type=PropertyType ;
        
PropertyType :
        name=ID (min=Number (max=Number default=Number?)? enums+=ENUM_LITERAL* )? ;
        
terminal ENUM_LITERAL :
        '~' !('~'|'\r'|'\n')+ ;

Number :
        '-'? (INT | DOUBLE) ;
        
CodeSection returns Code :
        'code:~' Code '~' ;

Code :
        (includes += IncludeDeclaration |
        globals += Global |
        functions += Function)+;
        
Global returns VariableDeclarations :
        'global' vars+=VariableDeclaration (',' vars+=VariableDeclaration)* ';' ;
        
Function :
        'function' name=ID (',' aliases+=ID)* '(' (params+=VariableDeclaration (',' params+=VariableDeclaration)*)? ')' code=Block ;
        
IncludeDeclaration :
        '@include' importURI=STRING ;
        
PropertyIncludeDeclaration :
        '#include' importURI=STRING ;
        
Block :
{Block} '{' statements+=Statement* '}' ;
        
Statement :     
        ( VariableDeclarationStatement |
        ExpressionStatement |
        DoStatement |
        ContinueStatement |
        BreakStatement |
        ReturnStatement |
        GotoStatment ) ';' |
        IncludeDeclaration |
        Block |
        SwitchStatement |
        LabeledStatement |
        IfStatement |
        WhileStatement |
        ForStatement |
{EmptyStatement} ';' ;

VariableDeclarationStatement returns VariableDeclarations :
        'var' vars+=VariableDeclaration (',' vars+=VariableDeclaration)* ;

VariableDeclaration :
        name=ID ('=' value=Expression)?;
        
IfStatement :
        'if' '(' condition=Expression ')' if=Statement ('else' else=Statement)? ;
        
ForStatement : 
        'for' '(' init=Assignment? ';' condition=Expression? ';' step=Assignment? ')' body=Statement ;
        
WhileStatement :
        'while' '(' condition=Expression ')' body=Statement ;
        
DoStatement :
        'do' body=Statement 'while' condition=ParExpression ;
        
LabeledStatement :
        name=ID ':' body=Statement ;
        
GotoStatment :
        'goto' dest=[LabeledStatement] ;
        
ReturnStatement :
{ReturnStatement} 'return' (expr=Expression)? ;
        
ContinueStatement :
{ContinueStatement}     'continue' (dest=[LabeledStatement])? ;
        
BreakStatement :
{BreakStatement} 'break' (dest=[LabeledStatement])? ;
        
SwitchStatement :
        'switch' condition=ParExpression '{' labels+=SwitchGroup* '}' ;
        
SwitchGroup : 
        label=SwitchLabel body=SwitchBlock ;
        
SwitchBlock returns Block :
{Block} statements+=Statement* ;

SwitchLabel:
        'case' expr = Expression ':' |
{DefaultSwitchLabel} 'default' ':' ;
        
ExpressionStatement :
        Assignment ;
        
AssignmentOperator :
        '=' | '+=' | '-=' | '*=' | '/=' ;
        
ParExpression returns Expression:
        '(' Expression ')' ;
        
Assignment :
        Expression ( {Assignment.left=current} op=AssignmentOperator right=Assignment)? ;

Expression :
        UnaryExpression ({Expression.left=current} op=Operator right=Expression)? | 
        WildcardExpression ;
        
UnaryExpression  :
        QualifiedExpression2 ({UnaryExpression.arg=current} op = IncrementOperator)? |
        op = (IncrementOperator | UnaryOperator) arg = QualifiedExpression2 |
        Literal ;
        
QualifiedExpression2 returns QualifiedExpression :
        QualifiedExpression |
        (PropertyAccess|StateAccess) ({QualifiedExpression.parent=current}'.' child=QualifiedExpression )? ;
        
QualifiedExpression :
        ArrayElementExpression ({QualifiedExpression.parent=current}'.' child=QualifiedExpression )? ;
        
ArrayElementExpression :
        TerminalExpression ({ArrayElementExpression.array=current} ('[' indexes+=Expression ']')+ )? ;
 
TerminalExpression:
                                Invocation |
                                Array |
                                Vector | 
{VariableRef}   var=[VariableDeclaration];
                                
Invocation :
        function=[Function] '(' (args+=Expression (',' args+=Expression)*)? ')' ;
        
WildcardExpression :
        value=ID '.*' ;
        
PropertyAccess returns QualifiedExpression :
        ('Fields.'|'ExpParams.'|'ShowParams.'|'VisParams.') property=[Property] ;
        
StateAccess returns QualifiedExpression :
        'ExpState.' state=[State] ;
        
Literal:
{IntLiteral}    value=IntValue | 
{DoubleLiteral} value=DoubleValue | 
{StringLiteral} value=STRING | 
{HexLiteral}    value=HEX | 
{NullLiteral}   'null' ;

Array :
        '[' elements+=Expression (',' elements+=Expression)* ']' ;

Vector  :
        '(' elements+=Expression (',' elements+=Expression)* ')' ;

Operator : 
        '+' | '-' | '*'| '/' | 
        '&'| '|' | '%' |
        '==' | '!=' | '>=' | '<=' | '<' | '>' |
        '&&' | '||' ;
        
UnaryOperator :
        '!' | '+' | '-' | 'typeof';
        
IncrementOperator :
        '++' | '--' ;
        
IntValue returns ecore::EInt hidden() :
        ('+'|'-')? INT ;
        
DoubleValue hidden() :
        ('+'|'-')? DOUBLE ;
        
terminal DOUBLE : 
        ('0'..'9')*'.'('0'..'9')+ ('e' INT)? |
        INT 'e' INT ;
        
terminal HEX : 
        '0x' (('0'..'9')|('a'..'f')|('A'..'F'))+ ;
        
terminal HEADER_VALUE : 
        ':' !('~'|' '|'\t'|'\r'|'\n') !('\n'|'\r')* ('\r'? '\n') |
        ':~' -> '~'('\r'? '\n') 
        ;
        
terminal SL_COMMENT : ('//' | '# ')  !('\n'|'\r')* ('\r'? '\n')?;