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