christoph/lecture-compilers
1
Fork 0
Code Actions Activity

update grammar to accept entire? language?

Browse Source
This commit is contained in:
Christoph
2020-12-10 19:17:26 +01:00
parent 4683924b46
commit 336a94d8a3
1 changed files with 41 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
src/test/resources/exampleGrammars/Grammar.grammar
View File

@ -2,22 +2,35 @@ START: S
EPS: epsilon
// Structures:
NTERM: S CLASS_CNT BLOCK_CNT STATEMENT STMT PRINT
NTERM: DECLARATION DECLARE_INT DECLARE_STRING DECLARE_BOOLEAN
NTERM: PREDICATE LESS_THAN LESS_EQUAL_THAN GREATER_THAN GREATER_EQUAL_THAN IS_EQUAL IS_NOT_EQUAL
NTERM: OPERATION ADDOP SUBOP MULOP DIVOP MODOP
NTERM: LOGIC ANDOP OROP NOTOP
NTERM: LOOP COND
NTERM: VAL TYPE OP ARITH_OP LOGIC_OP COMPARE_OP
NTERM: S CLASS_CNT BLOCK_CNT
NTERM: STATEMENT STMT PRINT
NTERM: DECLARATION ASSIGNMENT
NTERM: PAR_EXPR EXPR EXPR_2 EXPR_F
NTERM: LOOP COND COND_ELSE SINGLE_OR_BRACED
// Token:
TERM: PUBLIC STATIC CLASS IDENTIFIER IDENTIFIER_MAIN SEMICOLON
TERM: L_BRACE R_BRACE L_BRACKET R_BRACKET L_PAREN R_PAREN
TERM: CLASS PUBLIC STATIC
TERM: STRING_TYPE INTEGER_TYPE BOOLEAN_TYPE VOID_TYPE
TERM: WHILE IF ELSE
TERM: PRINTLN
TERM: LESS LESS_EQUAL GREATER GREATER_EQUAL EQUAL NOT_EQUAL
TERM: ADD MUL SUB DIV MOD
TERM: AND OR NOT
TERM: WHILE IF
TERM: LESS LESS_EQUAL GREATER GREATER_EQUAL EQUAL NOT_EQUAL
TERM: ASSIGN
TERM: L_BRACE R_BRACE L_BRACKET R_BRACKET L_PAREN R_PAREN SEMICOLON COMMA DOT
TERM: INTEGER_LIT STRING_LIT BOOLEAN_LIT
TERM: IDENTIFIER IDENTIFIER_MAIN
// General -----------------------------------------------------------------------------------------
VAL -> INTEGER_LIT | STRING_LIT | BOOLEAN_LIT | IDENTIFIER
TYPE -> INTEGER_TYPE | STRING_TYPE | BOOLEAN_TYPE
OP -> ARITH_OP | LOGIC_OP | COMPARE_OP
ARITH_OP -> ADD | SUB | MUL | DIV | MOD
LOGIC_OP -> AND | OR | NOT
COMPARE_OP -> LESS | LESS_EQUAL | GREATER | GREATER_EQUAL | EQUAL | NOT_EQUAL
// -------------------------------------------------------------------------------------------------
@ -25,56 +38,29 @@ TERM: WHILE IF
S -> CLASS IDENTIFIER L_BRACE CLASS_CNT R_BRACE | EPS
// public static void main(String[] args) { BLOCK_CNT }
CLASS_CNT -> PUBLIC STATIC VOID_TYPE IDENTIFIER_MAIN L_PAREN STRING_TYPE L_BRACKET R_BRACKET IDENTIFIER R_PAREN L_BRACE BLOCK_CNT R_BRACE
// Control-Flow
// TODO: Dangling else
LOOP -> WHILE L_PAREN PREDICATE R_PAREN L_BRACE BLOCK_CNT R_BRACE
COND -> IF L_PAREN PREDICATE R_PAREN L_BRACE BLOCK_CNT R_BRACE
CLASS_CNT -> PUBLIC STATIC VOID_TYPE IDENTIFIER_MAIN L_PAREN STRING_TYPE L_BRACKET R_BRACKET IDENTIFIER R_PAREN L_BRACE BLOCK_CNT R_BRACE | EPS
// Stuff in {}
// TODO: Aneinanderreihen von Statements
BLOCK_CNT -> STATEMENT | L_BRACE BLOCK_CNT R_BRACE | LOOP | COND | EPS
BLOCK_CNT -> STATEMENT BLOCK_CNT | L_BRACE BLOCK_CNT R_BRACE | EPS
// Statements ending with ;
STATEMENT -> STMT SEMICOLON
STMT -> PRINT | DECLARATION | PREDICATE | OPERATION | LOGIC
// Print
PRINT -> PRINTLN L_PAREN STRING_LIT R_PAREN
STATEMENT -> STMT SEMICOLON | LOOP | COND
STMT -> PRINT | DECLARATION | ASSIGNMENT
PRINT -> PRINTLN PAR_EXPR
// Declaration with Assignment: TYPE IDENTIFIER = LITERAL;
// TODO: Verkettung: int a = 3 + 5; boolean b = a < b;
DECLARATION -> DECLARE_INT | DECLARE_STRING | DECLARE_BOOLEAN
DECLARE_INT -> INTEGER_TYPE IDENTIFIER ASSIGN INTEGER_LIT
DECLARE_STRING -> STRING_TYPE IDENTIFIER ASSIGN STRING_LIT
DECLARE_BOOLEAN -> BOOLEAN_TYPE IDENTIFIER ASSIGN BOOLEAN_LIT
DECLARATION -> TYPE ASSIGNMENT
ASSIGNMENT -> IDENTIFIER ASSIGN EXPR
// Predicate
// TODO: Klammern: (1 < 3)
// TODO: Verkettung: 1 < (3 + 4)
// TODO: Literale: a < 5
PREDICATE -> LESS_THAN | LESS_EQUAL | GREATER_THAN | GREATER_EQUAL | EQUAL | NOT_EQUAL
LESS_THAN -> IDENTIFIER LESS IDENTIFIER
LESS_EQUAL_THAN -> IDENTIFIER LESS_EQUAL IDENTIFIER
GREATER_THAN -> IDENTIFIER GREATER IDENTIFIER
GREATER_EQUAL_THAN -> IDENTIFIER GREATER_EQUAL IDENTIFIER
IS_EQUAL -> IDENTIFIER EQUAL IDENTIFIER
IS_NOT_EQUAL -> IDENTIFIER NOT_EQUAL IDENTIFIER
// Stuff that returns something
PAR_EXPR -> L_PAREN EXPR R_PAREN
EXPR -> EXPR_F EXPR_2
EXPR_2 -> ARITH_OP EXPR_F EXPR_2 | LOGIC_OP EXPR_F EXPR_2 | COMPARE_OP EXPR_F EXPR_2 | EPS
EXPR_F -> SUB EXPR_F | NOT EXPR_F | L_PAREN EXPR R_PAREN | VAL
// Operation
// TODO: Literale: a + 5
OPERATION -> ADDOP | SUBOP | MULOP | DIVOP | MODOP
ADDOP -> IDENTIFIER ADD IDENTIFIER
SUBOP -> IDENTIFIER SUB IDENTIFIER
MULOP -> IDENTIFIER MUL IDENTIFIER
DIVOP -> IDENTIFIER DIV IDENTIFIER
MODOP -> IDENTIFIER MOD IDENTIFIER
// Control-Flow
LOOP -> WHILE PAR_EXPR SINGLE_OR_BRACED
// Logic
// TODO: Prädikate: 1 < 2 && 2 < 3
// TODO: Literale: a < b
LOGIC -> ANDOP | OROP | NOTOP
ANDOP -> IDENTIFIER AND IDENTIFIER
OROP -> IDENTIFIER OR IDENTIFIER
NOTOP -> NOT IDENTIFIER
COND -> IF PAR_EXPR SINGLE_OR_BRACED COND_ELSE
COND_ELSE -> ELSE SINGLE_OR_BRACED | EPS
SINGLE_OR_BRACED -> L_BRACE BLOCK_CNT R_BRACE | STMT SEMICOLON