Syntax der Vehikel DSL
Syntaxdiagramme
In den Syntax Diagrammen der Vehikel-DSL stehen NEWLINE, IDENT und DEDENT für die Einrückung des
Quelltextes. Es handelt sich nicht um Schlüsselworte der
Programmiersprache. Da diese Programmiersprache ihre Anweisung
nicht über geschweiften Klammeren zu Blöcken zusammenfasst,
wird die Struktur des Programms aus der Einrückung des
Quelltextes ermittelt. NEWLINE steht für das Ende eine
Zeile, IDENT für
zusätzliches Einrücken und DEDENT dafür wieder eine Stufe nach
links zu gehen.
Systemteil
Funktionen und Sensorfunktionen
Regelgruppen
Definition von Variablen, Konstanten und
Verzögerungsgliedern
Anweisunngen
Arithmetische Ausdrücke
Grammatik der DSL
Die Grammatik der Vehikel-DSL als Backus-Naur-Form in der
Schreibweise von ANTLR.
// virtuelle Symbole
tokens {
INDENT;
DEDENT;
RULES;
CALL;
HEAD;
VARPARAM;
UNARYPLUS;
UNARYMINUS;
THENBLOCK;
ELSEBLOCK;
MEMBERACCESS;
ARRAYACCESS;
}
//----------------------------------------------------------------------------
// The Vehikel parser
//----------------------------------------------------------------------------
// Grobstruktur des Quelltextes
compilationUnit
: systemUnit sensorUnit functionUnit rulesUnit+
;
systemUnit
: SYSTEM^ COLON! NEWLINE! INDENT! configurationStatement
(statement)* DEDENT!
;
configurationStatement
: CONFIGURATION (IDENTIFIER (DOT IDENTIFIER)*) NEWLINE
-> ^(CONFIGURATION ^(MEMBERACCESS IDENTIFIER+))
;
// Definition virtueller Sensoren
sensorUnit
: singleSensorDef*
;
singleSensorDef
: SENSOR IDENTIFIER COLON NEWLINE INDENT (statement)* DEDENT
-> ^(SENSOR ^(HEAD IDENTIFIER) (statement)+ )
;
// Definition der Funktionen
functionUnit
: singleFunctionDef*
;
singleFunctionDef
: DEF IDENTIFIER functionHead COLON NEWLINE INDENT (statement)+
DEDENT
-> ^(DEF ^(HEAD IDENTIFIER functionHead?) (statement)+ )
;
functionHead
: LPAREN VAR IDENTIFIER? (COMMA VAR IDENTIFIER)* RPAREN
-> ^(VARPARAM IDENTIFIER+)
;
// Definition von Reglen und Koordinatoren
rulesUnit
: singleRuleUnit+ arbiterUnit
-> ^(RULES singleRuleUnit+ arbiterUnit)
;
singleRuleUnit
: RULE IDENTIFIER COLON NEWLINE INDENT (rulesUnit | statement)*
DEDENT
-> ^(RULE ^(HEAD IDENTIFIER) (statement)* (rulesUnit)* )
;
arbiterUnit
: ARBITER IDENTIFIER arbiterHead COLON NEWLINE INDENT
(statement)+ DEDENT
-> ^(ARBITER ^(HEAD IDENTIFIER arbiterHead?) (statement)+
)
;
arbiterHead
: LPAREN! ARRAY^ IDENTIFIER RPAREN!
;
// Statements
statement
: (varDef | assignStatement | callStatement | forStatement |
whileStatement |
ifStatement | assertStatement | messageStatement |
returnStatement |
passStatement)
;
forStatement
: FOR^ IDENTIFIER IN! IDENTIFIER COLON! NEWLINE!
INDENT! (statement)+ DEDENT!
;
whileStatement
: WHILE expression COLON NEWLINE
INDENT (statement)+ DEDENT
-> ^(WHILE expression (statement)+)
;
ifStatement
: IF expression COLON NEWLINE
thenBlock
(ELSE COLON NEWLINE
elseBlock)?
-> ^(IF expression thenBlock elseBlock?)
;
thenBlock
: INDENT statement+ DEDENT
-> ^(THENBLOCK statement+)
;
elseBlock
: INDENT statement+ DEDENT
-> ^(ELSEBLOCK statement+)
;
varDef
: (CONST^ typeDef? | VAR^ typeDef? | DELAY^) IDENTIFIER ASSIGN!
expression NEWLINE!
;
typeDef
: BOOL | INT
;
returnStatement
: RETURN^ expression NEWLINE!
;
assertStatement
: ASSERT^ expression NEWLINE!
;
messageStatement
: MESSAGE^ expressionList NEWLINE!
;
assignStatement
: (IDENTIFIER (DOT IDENTIFIER)*) ASSIGN expression NEWLINE
-> ^(ASSIGN ^(MEMBERACCESS IDENTIFIER+) expression)
;
callStatement
: (IDENTIFIER (DOT IDENTIFIER)*) LPAREN expressionList RPAREN
NEWLINE
-> ^(CALL ^(MEMBERACCESS IDENTIFIER+) expressionList)
;
passStatement
: PASS NEWLINE
->
;
// Arithmetische Ausdruecke
expressionList
: (expression)? (COMMA! expression)*
;
expression
: simpleExpression
( (EQUAL^ | NOT_EQUAL^ | LT^ | LE^ | GE^ | GT^) simpleExpression
)*
;
simpleExpression
: term ( (PLUS^ | MINUS^ | LOR^) term )*
;
term
: signedFactor ( (MULT^ | DIV^ | MOD^ | LAND^) signedFactor
)*
;
signedFactor
: (minusFactor | plusFactor | factor)
;
minusFactor
: MINUS factor
-> ^(UNARYMINUS factor)
;
plusFactor
: PLUS factor
-> ^(UNARYPLUS factor)
;
factor
: LPAREN expression RPAREN
-> expression
| constant
-> constant
| (IDENTIFIER (DOT IDENTIFIER)*)
-> ^(MEMBERACCESS IDENTIFIER+)
| IDENTIFIER LBRACK expression RBRACK (DOT IDENTIFIER)*
-> ^(ARRAYACCESS IDENTIFIER expression IDENTIFIER+)
| IDENTIFIER LPAREN expressionList RPAREN
-> ^(CALL ^(MEMBERACCESS IDENTIFIER) expressionList)
| LNOT factor
-> ^(LNOT factor)
;
constant
: NUM_INT
| BOOLEAN_FALSE
| BOOLEAN_TRUE
;
