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

// Token:
TERM: PUBLIC STATIC CLASS IDENTIFIER IDENTIFIER_MAIN SEMICOLON
TERM: L_BRACE R_BRACE L_BRACKET R_BRACKET L_PAREN R_PAREN
TERM: STRING_TYPE INTEGER_TYPE BOOLEAN_TYPE VOID_TYPE
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

// -------------------------------------------------------------------------------------------------

// class IDENTIFIER { CLASS_CNT }
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

// Stuff in {}
// TODO: Aneinanderreihen von Statements
BLOCK_CNT -> STATEMENT | L_BRACE BLOCK_CNT R_BRACE | LOOP | COND | EPS

// Statements ending with ;
STATEMENT -> STMT SEMICOLON
STMT -> PRINT | DECLARATION | PREDICATE | OPERATION | LOGIC

// Print
PRINT -> PRINTLN L_PAREN STRING_LIT R_PAREN

// 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

// 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

// 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

// 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