christoph/lecture-compilers
1
Fork 0
Code Actions Activity

rework grammar to use new actions + distinguish between term, nterm

Browse Source
This commit is contained in:
ChUrl
2020-12-15 16:24:30 +01:00
parent d86eaa9b9d
commit 4f45a57294
1 changed files with 67 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,14 +1,21 @@
START: S START: s
EPS: epsilon EPS: eps
// Structures: // START, EPS, NTERM, TERM are reserved
NTERM: VAL TYPE
NTERM: OP UNARY ARITH_OP LOGIC_OP COMPARE_OP // Some Grammar-Symbols have to be named this way:
NTERM: S CLASS_CNT BLOCK_CNT // assignment, declaration (for TypeTable creation)
NTERM: STATEMENT STMT PRINT // IDENTIFIER, NOT, ADD, SUB (for TypeChecking)
NTERM: DECLARATION ASSIGNMENT // expr, par_expr, assignment (for TypeChecking)
NTERM: PAR_EXPR EXPR EXPR_2 EXPR_F
NTERM: LOOP COND COND_ELSE SINGLE_OR_BRACED // Nonterminals:
NTERM: val type
NTERM: op unary 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: // Token:
TERM: CLASS PUBLIC STATIC TERM: CLASS PUBLIC STATIC
@ -23,49 +30,67 @@ TERM: L_BRACE R_BRACE L_BRACKET R_BRACKET L_PAREN R_PAREN SEMICOLON COMMA DOT
TERM: INTEGER_LIT STRING_LIT BOOLEAN_LIT TERM: INTEGER_LIT STRING_LIT BOOLEAN_LIT
TERM: IDENTIFIER IDENTIFIER_MAIN TERM: IDENTIFIER IDENTIFIER_MAIN
// Actions: compact - Value hochreichen // Actions: promote - Information "hochreichen": Ersetzt Node mit Child, wenn es nur ein Child gibt
// nullable - Kann entfernt werden, wenn keine value und keine children // - val[promote] :: --val--INTEGER_LIT: 5 => --INTEGER_LIT: 5
// delifempty - Kann Node löschen, wenn dieser keinen Inhalt hat, normalerweise bei eps
// - block_cnt[delifempty] :: --block_cnt => --
// delchild= - Entfernt bestimmte Child-Nodes eines Parents
// - cond[delchild=IF] :: --cond--IF => --cond
// - assignment[delchild=ASSIGN] :: --assignment--ASSIGN => --assignment
// valtoval= - Verschiebt eine Child-Value in die Parent-Value und entfernt das Child
// - assignment[valtoval=IDENTIFIER] :: --assignment--IDENTIFIER: a => --assignment: a
// nametoval= - Verschiebt einen Child-Name in die Parent-Value und entfernt das Child
// - expr_2[nametoval=ADD] :: --expr_2--ADD => --expr_2: ADD
// renameto= - Führt Umbenennung eines Nodes durch
// - expr_2[renameto=expr] :: --expr_2: ADD => --expr: ADD
// General ----------------------------------------------------------------------------------------- // General -----------------------------------------------------------------------------------------
VAL[compact] -> INTEGER_LIT | STRING_LIT | BOOLEAN_LIT | IDENTIFIER val[promote] -> INTEGER_LIT | STRING_LIT | BOOLEAN_LIT | IDENTIFIER
TYPE[compact] -> INTEGER_TYPE | STRING_TYPE | BOOLEAN_TYPE type[promote] -> INTEGER_TYPE | STRING_TYPE | BOOLEAN_TYPE
OP[compact] -> ARITH_OP | LOGIC_OP | COMPARE_OP // OP-List: ADD,SUB,MUL,DIV,MOD,AND,OR,NOT,LESS,LESS_EQUAL,GREATER,GREATER_EQUAL,EQUAL,NOT_EQUAL
UNARY[compact] -> ADD | SUB | NOT op[promote] -> arith_op | logic_op | compare_op
ARITH_OP[compact] -> ADD | SUB | MUL | DIV | MOD unary[promote] -> ADD | SUB | NOT
LOGIC_OP[compact] -> AND | OR | NOT arith_op[promote] -> ADD | SUB | MUL | DIV | MOD
COMPARE_OP[compact] -> LESS | LESS_EQUAL | GREATER | GREATER_EQUAL | EQUAL | NOT_EQUAL logic_op[promote] -> AND | OR | NOT
compare_op[promote] -> LESS | LESS_EQUAL | GREATER | GREATER_EQUAL | EQUAL | NOT_EQUAL
// ------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------
// class IDENTIFIER { CLASS_CNT } // START -> class IDENTIFIER { class_cnt }
S[compact] -> CLASS IDENTIFIER L_BRACE CLASS_CNT R_BRACE | EPS s[promote] -> CLASS IDENTIFIER L_BRACE class_cnt R_BRACE | eps
// public static void main(String[] args) { BLOCK_CNT } // class_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[promote delifempty] -> PUBLIC STATIC VOID_TYPE IDENTIFIER_MAIN L_PAREN STRING_TYPE L_BRACKET R_BRACKET IDENTIFIER R_PAREN L_BRACE block_cnt R_BRACE | eps
CLASS_CNT[compact nullable] -> EPS
// Stuff in {} // block_ccnt -> stuff in {} | list of statements
BLOCK_CNT[compact nullable] -> STATEMENT BLOCK_CNT | L_BRACE BLOCK_CNT R_BRACE | EPS block_cnt[promote delifempty] -> statement block_cnt | L_BRACE block_cnt R_BRACE | eps
STATEMENT -> STMT SEMICOLON // statement -> stuff ending with ; | loop | condition
STATEMENT[compact] -> LOOP | COND statement[promote] -> stmt SEMICOLON | loop | cond
STMT[compact] -> PRINT | DECLARATION | ASSIGNMENT stmt[promote] -> print | declaration | assignment
PRINT -> PRINTLN PAR_EXPR print -> PRINTLN par_expr
// Declaration with Assignment: TYPE IDENTIFIER = LITERAL; // declaration -> type IDENTIFIER = expr;
DECLARATION -> TYPE ASSIGNMENT declaration[nametoval=INTEGER_TYPE,BOOLEAN_TYPE,STRING_TYPE] -> type assignment
ASSIGNMENT -> IDENTIFIER ASSIGN EXPR assignment[delchild=ASSIGN valtoval=IDENTIFIER] -> IDENTIFIER ASSIGN expr
// Stuff that returns something // par_expr -> ( expr )
PAR_EXPR -> L_PAREN EXPR R_PAREN par_expr -> L_PAREN expr R_PAREN
EXPR[compact] -> EXPR_F EXPR_2
EXPR_2[compact nullable] -> OP EXPR_F EXPR_2 | EPS // expr -> expression that returns something | literal
EXPR_F[compact] -> UNARY EXPR_F | PAR_EXPR | VAL expr[promote nametoval=ADD,SUB,MUL,DIV,MOD,AND,OR,NOT,LESS,LESS_EQUAL,GREATER,GREATER_EQUAL,EQUAL,NOT_EQUAL] -> expr_f expr_2
expr_2[promote delifempty renameto=expr] -> op expr_f expr_2 | eps
expr_f[promote renameto=expr] -> unary expr_f | par_expr | val
// Control-Flow // Control-Flow
SINGLE_OR_BRACED -> L_BRACE BLOCK_CNT R_BRACE | STMT SEMICOLON loop[delchild=WHILE] -> WHILE par_expr single_or_braced
LOOP -> WHILE PAR_EXPR SINGLE_OR_BRACED cond[delchild=IF] -> IF par_expr single_or_braced cond_else
COND -> IF PAR_EXPR SINGLE_OR_BRACED COND_ELSE cond_else[delifempty delchild=ELSE] -> ELSE single_or_braced | eps
COND_ELSE[nullable] -> ELSE SINGLE_OR_BRACED | EPS single_or_braced -> L_BRACE block_cnt R_BRACE | stmt SEMICOLON