From 54d6ea874e5819908ad76cf197493925e38b8af7 Mon Sep 17 00:00:00 2001 From: Humenius Date: Sat, 13 Jun 2020 19:16:35 +0200 Subject: [PATCH] [12 - Tree Grammar] Add type check --- .idea/workspace.xml | 78 +- .../antlrxcompiler/AntlrXCompiler.java | 2 + .../src/de/dhbw/compiler/antlrxcompiler/X.g | 2 +- .../dhbw/compiler/antlrxcompiler/XOptimizer.g | 6 +- .../dhbw/compiler/antlrxcompiler/XTypeCheck.g | 170 +- .../compiler/antlrxcompiler/XTypeCheck.java | 1618 ++++++++++++++++- .../compiler/antlrxcompiler/XTypeCheck.tokens | 2 - .../antlrxcompiler/test/OptimizerTest.java | 10 +- .../antlrxcompiler/test/ParseTreeTest.java | 2 +- .../antlrxcompiler/test/TypeCheckTest.java | 9 +- 10 files changed, 1726 insertions(+), 173 deletions(-) diff --git a/.idea/workspace.xml b/.idea/workspace.xml index 8b3c4ff..32288a9 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -2,22 +2,16 @@ - - - - - - - - - - - - - - - + + + + + + + + + - + - - + + + - - @@ -166,17 +163,17 @@ - + + - @@ -197,7 +194,8 @@ - + + @@ -213,11 +211,11 @@ - + - + @@ -232,38 +230,38 @@ - + - + - + - + - + - + - + - + - + - + @@ -280,9 +278,9 @@ - + - + \ No newline at end of file diff --git a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/AntlrXCompiler.java b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/AntlrXCompiler.java index 667e783..300e1e0 100644 --- a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/AntlrXCompiler.java +++ b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/AntlrXCompiler.java @@ -90,6 +90,8 @@ public class AntlrXCompiler { // Type check XTypeCheck typeCheck = new XTypeCheck(new CommonTreeNodeStream(xTreeAdaptor, tree)); CommonTree typeCheckedTree = typeCheck.program().getTree(); + + // X to Java XtoJava javaConverter = new XtoJava(new CommonTreeNodeStream(xTreeAdaptor, typeCheckedTree)); diff --git a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/X.g b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/X.g index 9c12dd6..5f84cfc 100644 --- a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/X.g +++ b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/X.g @@ -60,7 +60,7 @@ decl: ID ':' (type='int' | type='float' | type='string') ';' -> ^(DECL ID decllist: decl* -> ^(DECLLIST decl*); // Ausdr�cke -expr: multexpr (('+'^ | '-'^) multexpr)*; +expr: multexpr (('+'^ | '-'^) multexpr)*; multexpr: simpleexpr (('*'^ | '/'^) simpleexpr)*; simpleexpr: '('! expr ')'! | INTCONST | '-' INTCONST -> ^(UMINUS INTCONST) diff --git a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XOptimizer.g b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XOptimizer.g index e5784be..9ef5949 100644 --- a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XOptimizer.g +++ b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XOptimizer.g @@ -18,7 +18,7 @@ options { private String addString(String first, String last) { return first.substring(0, first.length()-1)+last.substring(1); } - + private String opInt(String first, String last, char op) { int firstValue = 0; int lastValue = 0; @@ -36,7 +36,7 @@ options { default: return ""; } } - + private String opFloat(String first, String last, char op) { double firstValue = 0.0; double lastValue = 0.0; @@ -54,7 +54,7 @@ options { default: return ""; } } - + } diff --git a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.g b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.g index b936ba0..376968a 100644 --- a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.g +++ b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.g @@ -1,14 +1,3 @@ -/* ********************************************** - * Duale Hochschule Baden-Württemberg Karlsruhe - * Prof. Dr. Jörn Eisenbiegler - * - * Vorlesung Übersetzerbau - * Praxis ANTLR-Übersetzer für X - * - Typ-Prüfung - * - * ********************************************** - */ - tree grammar XTypeCheck; options { @@ -23,108 +12,105 @@ tokens{ } @header { -package de.dhbw.compiler.antlrxcompiler; + package de.dhbw.compiler.antlrxcompiler; -import java.util.HashMap; + import java.util.HashMap; } @members { - private SymbolTable symbols = SymbolTable.getInstance(); + private SymbolTable symbols = SymbolTable.getInstance(); - private void error(XTree tree, String message) { - System.err.println("Error at "+tree.getLine()+","+tree.getCharPositionInLine()+": "+message); - } + private void logError(XTree tree, String message) { + System.err.println(message + "\n\t" + tree); + } } -// Deklarationen decl: - ^(DECL ID 'int' r='read'? p='print'?) - { symbols.put($ID.text, new Symbol($ID.text, XType.IntType, $r!=null, $p!=null)); } -| ^(DECL ID 'float' r='read'? p='print'?) - { symbols.put($ID.text, new Symbol($ID.text, XType.FloatType, $r!=null, $p!=null)); } -| ^(DECL ID 'string' r='read'? p='print'?) - { symbols.put($ID.text, new Symbol($ID.text, XType.StringType, $r!=null, $p!=null)); } ; + ^(DECL ID type='int' read='read'? print='print'?) + { symbols.put($ID.text, new Symbol($ID.text, XType.IntType, ($read != null), ($print != null))); } + | ^(DECL ID type='float' read='read'? print='print'?) + { symbols.put($ID.text, new Symbol($ID.text, XType.FloatType, ($read != null), ($print != null))); } + | ^(DECL ID type='string' read='read'? print='print'?) + { symbols.put($ID.text, new Symbol($ID.text, XType.StringType, ($read != null), ($print != null))); } + ; -decllist: ^(DECLLIST decl*); +decllist: ^(DECLLIST decl*); -// Expr und Cond!! expr: - - ^(op=('+' | '-' | '/' | '*') l=expr r=expr) - { - if ($l.tree.exprType==XType.IntType && $r.tree.exprType==XType.IntType) { - $op.tree.exprType=XType.IntType; - } else if (($l.tree.exprType==XType.IntType || $l.tree.exprType==XType.FloatType) && - ($r.tree.exprType==XType.IntType || $r.tree.exprType==XType.FloatType)) { - $op.tree.exprType=XType.FloatType; - } else if ($l.tree.exprType==XType.StringType && $r.tree.exprType==XType.StringType && $op.type==PLUS) { - $op.tree.exprType=XType.StringType; - } else { - $op.tree.exprType=XType.InvalidType; - error($op,$op.text+" is not valid for operands "+$l.tree.exprType+" and "+$r.tree.exprType+"."); + ^(op=('+' | '-' | '/' | '*') left=expr right=expr) + { + if ($left.tree.exprType == XType.IntType && $right.tree.exprType == XType.IntType) { + $op.tree.exprType = XType.IntType; + } else if (($left.tree.exprType == XType.FloatType || $left.tree.exprType == XType.IntType) && + ($right.tree.exprType == XType.FloatType || $right.tree.exprType == XType.IntType)) { + $op.tree.exprType = XType.FloatType; + } else if ($left.tree.exprType == XType.StringType && $right.tree.exprType == XType.StringType && $op.type == PLUS) { + $op.tree.exprType = XType.StringType; + } else { + $op.tree.exprType = XType.InvalidType; + logError($op, "Invalid operator '" + $op.text + "' for '" + $left.tree.exprType + "' and '" + $right.tree.exprType + "'"); + } } - } + | ^(op=UMINUS e=expr) { $op.tree.exprType = $e.tree.exprType; } + | INTCONST { $INTCONST.tree.exprType = XType.IntType; } + | FLOATCONST { $FLOATCONST.tree.exprType = XType.FloatType; } + | STRINGCONST { $STRINGCONST.tree.exprType = XType.StringType; } + | ID { + if (symbols.containsKey($ID.text)) { + $ID.tree.exprType = symbols.get($ID.text).type; + } else { + $ID.tree.exprType = XType.InvalidType; + logError($ID, "'" + $ID.text + "' is not defined."); + } + } + ; -| ^(op=UMINUS e=expr) - { - $op.tree.exprType=$e.tree.exprType; - } +assignstat: + ^(op=':=' ID e=expr) + { + if (!symbols.containsKey($ID.text)) { + $ID.tree.exprType = XType.InvalidType; + $op.tree.exprType = XType.InvalidType; + logError($ID, "Undeclared var '" + $ID.text + "'"); + } else { + $ID.tree.exprType = symbols.get($ID.text).type; -| INTCONST { $INTCONST.tree.exprType=XType.IntType; } -| FLOATCONST { $FLOATCONST.tree.exprType=XType.FloatType; } -| STRINGCONST { $STRINGCONST.tree.exprType=XType.StringType; } -| ID { if (!symbols.containsKey($ID.text)) { - $ID.tree.exprType=XType.InvalidType; - error($ID,"Variable "+$ID.text+" is not defined."); - } else { - $ID.tree.exprType=symbols.get($ID.text).type; - } - }; - -// Zuweisungen -assignstat: ^(op=':=' ID expr) - { if (!symbols.containsKey($ID.text)) { - $ID.tree.exprType=XType.InvalidType; - $op.tree.exprType=XType.InvalidType; - error($ID,"Variable "+$ID.text+" is not defined."); - } else { - $ID.tree.exprType=symbols.get($ID.text).type; - if ($ID.tree.exprType==XType.FloatType && $expr.tree.exprType==XType.IntType) { - $op.tree.exprType=XType.FloatType; - } else if ($ID.tree.exprType!=$expr.tree.exprType) { - $op.tree.exprType=XType.InvalidType; - error($op,"An expression of type "+$expr.tree.exprType+ - " cannot be assigned to a variable of type "+$ID.tree.exprType+"."); - } else { - $op.tree.exprType=$ID.tree.exprType; - } + // float <- int + if ($ID.tree.exprType == XType.FloatType && $e.tree.exprType == XType.IntType) { + $op.tree.exprType = XType.FloatType; + } else if ($ID.tree.exprType != $expr.tree.exprType) { + $op.tree.exprType = XType.InvalidType; + logError($op, "Cannot assign <" + $expr.tree.exprType + "> to <" + $ID.tree.exprType + ">"); + } else { + $op.tree.exprType = $ID.tree.exprType; + } + } } - }; + ; -// Bedingungen -cond: ^(op=('<' |'>' |'=') l=expr r=expr) - { if ($l.tree.exprType==XType.StringType || $r.tree.exprType==XType.StringType) { - error($op,$op.text+" is not valid for string operands."); - } else if ($l.tree.exprType==XType.IntType && $r.tree.exprType==XType.IntType) { - $op.tree.exprType=XType.IntType; - } else { - $op.tree.exprType=XType.FloatType; +cond: + ^(op=('<' | '>' | '=') left=expr right=expr) + { + if ($left.tree.exprType == XType.StringType || $right.tree.exprType == XType.StringType) { + $op.tree.exprType = XType.InvalidType; + logError($op, "Cannot use operator '" + $op.text + "' on '" + $left.text + "' and '" + $right.text + "'"); + } else if ($left.tree.exprType == XType.IntType && $right.tree.exprType == XType.IntType) { + $op.tree.exprType = XType.IntType; + } else { + $op.tree.exprType = XType.FloatType; + } } - }; + ; -// Bedingte Zuweisung -condstat: ^('if' cond stat stat?); +condstat: ^(op='if' cond stat stat?); -// Schleifen -whilestat: ^('while' cond stat); -forstat: ^('for' assignstat cond assignstat stat); +whilestat: ^('while' cond stat); +forstat: ^('for' assignstat cond assignstat stat); -// Anweisungen -stat: assignstat | condstat | whilestat | forstat | statlist; +stat: assignstat | condstat | whilestat | forstat | statlist; -statlist: ^(STATLIST stat*); +statlist: ^(STATLIST stat*); -// Programme -program: { symbols.clear(); } ^('program' ID decllist statlist); +program: { symbols.clear(); } ^('program' ID decllist statlist); diff --git a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.java b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.java index b7eb887..0d29ee8 100644 --- a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.java +++ b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.java @@ -1,8 +1,8 @@ -// $ANTLR 3.5.2 /Users/kreis/git/gitea.humenius.me/dhbw-compilerbau/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.g 2020-06-10 10:16:11 +// $ANTLR 3.5.2 C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g 2020-06-13 19:14:21 -package de.dhbw.compiler.antlrxcompiler; - -import java.util.HashMap; + package de.dhbw.compiler.antlrxcompiler; + + import java.util.HashMap; import org.antlr.runtime.*; @@ -20,8 +20,7 @@ public class XTypeCheck extends TreeParser { "POSDIGIT", "STATLIST", "STRINGCONST", "UMINUS", "WS", "ZERO", "'('", "')'", "'*'", "'+'", "'-'", "'.'", "'/'", "':'", "':='", "';'", "'<'", "'='", "'>'", "'begin'", "'else'", "'end'", "'float'", "'for'", "'if'", - "'int'", "'print'", "'program'", "'read'", "'string'", "'then'", "'while'", - "'todo'" + "'int'", "'print'", "'program'", "'read'", "'string'", "'then'", "'while'" }; public static final int EOF=-1; public static final int T__20=20; @@ -66,7 +65,6 @@ public class XTypeCheck extends TreeParser { public static final int UMINUS=17; public static final int WS=18; public static final int ZERO=19; - public static final int T__46=46; public static final int PLUS=23; // delegates @@ -93,12 +91,1502 @@ public class XTypeCheck extends TreeParser { return adaptor; } @Override public String[] getTokenNames() { return XTypeCheck.tokenNames; } - @Override public String getGrammarFileName() { return "/Users/kreis/git/gitea.humenius.me/dhbw-compilerbau/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.g"; } + @Override public String getGrammarFileName() { return "C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g"; } - private SymbolTable symbols = SymbolTable.getInstance(); - + private SymbolTable symbols = SymbolTable.getInstance(); + + private void logError(XTree tree, String message) { + System.err.println(message + "\n\t" + tree); + } + + + public static class decl_return extends TreeRuleReturnScope { + XTree tree; + @Override + public XTree getTree() { return tree; } + }; + + + // $ANTLR start "decl" + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:29:1: decl : ( ^( DECL ID type= 'int' (read= 'read' )? (print= 'print' )? ) | ^( DECL ID type= 'float' (read= 'read' )? (print= 'print' )? ) | ^( DECL ID type= 'string' (read= 'read' )? (print= 'print' )? ) ); + public final XTypeCheck.decl_return decl() throws RecognitionException { + XTypeCheck.decl_return retval = new XTypeCheck.decl_return(); + retval.start = input.LT(1); + + XTree root_0 = null; + + XTree _first_0 = null; + XTree _last = null; + + + XTree type=null; + XTree read=null; + XTree print=null; + XTree DECL1=null; + XTree ID2=null; + XTree DECL3=null; + XTree ID4=null; + XTree DECL5=null; + XTree ID6=null; + + XTree type_tree=null; + XTree read_tree=null; + XTree print_tree=null; + XTree DECL1_tree=null; + XTree ID2_tree=null; + XTree DECL3_tree=null; + XTree ID4_tree=null; + XTree DECL5_tree=null; + XTree ID6_tree=null; + + try { + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:29:5: ( ^( DECL ID type= 'int' (read= 'read' )? (print= 'print' )? ) | ^( DECL ID type= 'float' (read= 'read' )? (print= 'print' )? ) | ^( DECL ID type= 'string' (read= 'read' )? (print= 'print' )? ) ) + int alt7=3; + int LA7_0 = input.LA(1); + if ( (LA7_0==DECL) ) { + int LA7_1 = input.LA(2); + if ( (LA7_1==DOWN) ) { + int LA7_2 = input.LA(3); + if ( (LA7_2==ID) ) { + switch ( input.LA(4) ) { + case 39: + { + alt7=1; + } + break; + case 36: + { + alt7=2; + } + break; + case 43: + { + alt7=3; + } + break; + default: + int nvaeMark = input.mark(); + try { + for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) { + input.consume(); + } + NoViableAltException nvae = + new NoViableAltException("", 7, 3, input); + throw nvae; + } finally { + input.rewind(nvaeMark); + } + } + } + + else { + int nvaeMark = input.mark(); + try { + for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) { + input.consume(); + } + NoViableAltException nvae = + new NoViableAltException("", 7, 2, input); + throw nvae; + } finally { + input.rewind(nvaeMark); + } + } + + } + + else { + int nvaeMark = input.mark(); + try { + input.consume(); + NoViableAltException nvae = + new NoViableAltException("", 7, 1, input); + throw nvae; + } finally { + input.rewind(nvaeMark); + } + } + + } + + else { + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); + throw nvae; + } + + switch (alt7) { + case 1 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:30:5: ^( DECL ID type= 'int' (read= 'read' )? (print= 'print' )? ) + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + _last = (XTree)input.LT(1); + DECL1=(XTree)match(input,DECL,FOLLOW_DECL_in_decl81); + DECL1_tree = (XTree)adaptor.dupNode(DECL1); + + + root_1 = (XTree)adaptor.becomeRoot(DECL1_tree, root_1); + + match(input, Token.DOWN, null); + _last = (XTree)input.LT(1); + ID2=(XTree)match(input,ID,FOLLOW_ID_in_decl83); + ID2_tree = (XTree)adaptor.dupNode(ID2); + + + adaptor.addChild(root_1, ID2_tree); + + _last = (XTree)input.LT(1); + type=(XTree)match(input,39,FOLLOW_39_in_decl87); + type_tree = (XTree)adaptor.dupNode(type); + + + adaptor.addChild(root_1, type_tree); + + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:30:30: (read= 'read' )? + int alt1=2; + int LA1_0 = input.LA(1); + if ( (LA1_0==42) ) { + alt1=1; + } + switch (alt1) { + case 1 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:30:30: read= 'read' + { + _last = (XTree)input.LT(1); + read=(XTree)match(input,42,FOLLOW_42_in_decl91); + read_tree = (XTree)adaptor.dupNode(read); + + + adaptor.addChild(root_1, read_tree); + + } + break; + + } + + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:30:44: (print= 'print' )? + int alt2=2; + int LA2_0 = input.LA(1); + if ( (LA2_0==40) ) { + alt2=1; + } + switch (alt2) { + case 1 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:30:44: print= 'print' + { + _last = (XTree)input.LT(1); + print=(XTree)match(input,40,FOLLOW_40_in_decl96); + print_tree = (XTree)adaptor.dupNode(print); + + + adaptor.addChild(root_1, print_tree); + + } + break; + + } + + match(input, Token.UP, null); + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + + + symbols.put((ID2!=null?ID2.getText():null), new Symbol((ID2!=null?ID2.getText():null), XType.IntType, (read != null), (print != null))); + } + break; + case 2 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:32:5: ^( DECL ID type= 'float' (read= 'read' )? (print= 'print' )? ) + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + _last = (XTree)input.LT(1); + DECL3=(XTree)match(input,DECL,FOLLOW_DECL_in_decl111); + DECL3_tree = (XTree)adaptor.dupNode(DECL3); + + + root_1 = (XTree)adaptor.becomeRoot(DECL3_tree, root_1); + + match(input, Token.DOWN, null); + _last = (XTree)input.LT(1); + ID4=(XTree)match(input,ID,FOLLOW_ID_in_decl113); + ID4_tree = (XTree)adaptor.dupNode(ID4); + + + adaptor.addChild(root_1, ID4_tree); + + _last = (XTree)input.LT(1); + type=(XTree)match(input,36,FOLLOW_36_in_decl117); + type_tree = (XTree)adaptor.dupNode(type); + + + adaptor.addChild(root_1, type_tree); + + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:32:32: (read= 'read' )? + int alt3=2; + int LA3_0 = input.LA(1); + if ( (LA3_0==42) ) { + alt3=1; + } + switch (alt3) { + case 1 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:32:32: read= 'read' + { + _last = (XTree)input.LT(1); + read=(XTree)match(input,42,FOLLOW_42_in_decl121); + read_tree = (XTree)adaptor.dupNode(read); + + + adaptor.addChild(root_1, read_tree); + + } + break; + + } + + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:32:46: (print= 'print' )? + int alt4=2; + int LA4_0 = input.LA(1); + if ( (LA4_0==40) ) { + alt4=1; + } + switch (alt4) { + case 1 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:32:46: print= 'print' + { + _last = (XTree)input.LT(1); + print=(XTree)match(input,40,FOLLOW_40_in_decl126); + print_tree = (XTree)adaptor.dupNode(print); + + + adaptor.addChild(root_1, print_tree); + + } + break; + + } + + match(input, Token.UP, null); + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + + + symbols.put((ID4!=null?ID4.getText():null), new Symbol((ID4!=null?ID4.getText():null), XType.FloatType, (read != null), (print != null))); + } + break; + case 3 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:34:5: ^( DECL ID type= 'string' (read= 'read' )? (print= 'print' )? ) + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + _last = (XTree)input.LT(1); + DECL5=(XTree)match(input,DECL,FOLLOW_DECL_in_decl141); + DECL5_tree = (XTree)adaptor.dupNode(DECL5); + + + root_1 = (XTree)adaptor.becomeRoot(DECL5_tree, root_1); + + match(input, Token.DOWN, null); + _last = (XTree)input.LT(1); + ID6=(XTree)match(input,ID,FOLLOW_ID_in_decl143); + ID6_tree = (XTree)adaptor.dupNode(ID6); + + + adaptor.addChild(root_1, ID6_tree); + + _last = (XTree)input.LT(1); + type=(XTree)match(input,43,FOLLOW_43_in_decl147); + type_tree = (XTree)adaptor.dupNode(type); + + + adaptor.addChild(root_1, type_tree); + + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:34:33: (read= 'read' )? + int alt5=2; + int LA5_0 = input.LA(1); + if ( (LA5_0==42) ) { + alt5=1; + } + switch (alt5) { + case 1 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:34:33: read= 'read' + { + _last = (XTree)input.LT(1); + read=(XTree)match(input,42,FOLLOW_42_in_decl151); + read_tree = (XTree)adaptor.dupNode(read); + + + adaptor.addChild(root_1, read_tree); + + } + break; + + } + + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:34:47: (print= 'print' )? + int alt6=2; + int LA6_0 = input.LA(1); + if ( (LA6_0==40) ) { + alt6=1; + } + switch (alt6) { + case 1 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:34:47: print= 'print' + { + _last = (XTree)input.LT(1); + print=(XTree)match(input,40,FOLLOW_40_in_decl156); + print_tree = (XTree)adaptor.dupNode(print); + + + adaptor.addChild(root_1, print_tree); + + } + break; + + } + + match(input, Token.UP, null); + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + + + symbols.put((ID6!=null?ID6.getText():null), new Symbol((ID6!=null?ID6.getText():null), XType.StringType, (read != null), (print != null))); + } + break; + + } + retval.tree = (XTree)adaptor.rulePostProcessing(root_0); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + // do for sure before leaving + } + return retval; + } + // $ANTLR end "decl" + + + public static class decllist_return extends TreeRuleReturnScope { + XTree tree; + @Override + public XTree getTree() { return tree; } + }; + + + // $ANTLR start "decllist" + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:38:1: decllist : ^( DECLLIST ( decl )* ) ; + public final XTypeCheck.decllist_return decllist() throws RecognitionException { + XTypeCheck.decllist_return retval = new XTypeCheck.decllist_return(); + retval.start = input.LT(1); + + XTree root_0 = null; + + XTree _first_0 = null; + XTree _last = null; + + + XTree DECLLIST7=null; + TreeRuleReturnScope decl8 =null; + + XTree DECLLIST7_tree=null; + + try { + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:38:9: ( ^( DECLLIST ( decl )* ) ) + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:38:17: ^( DECLLIST ( decl )* ) + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + _last = (XTree)input.LT(1); + DECLLIST7=(XTree)match(input,DECLLIST,FOLLOW_DECLLIST_in_decllist183); + DECLLIST7_tree = (XTree)adaptor.dupNode(DECLLIST7); + + + root_1 = (XTree)adaptor.becomeRoot(DECLLIST7_tree, root_1); + + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:38:28: ( decl )* + loop8: + while (true) { + int alt8=2; + int LA8_0 = input.LA(1); + if ( (LA8_0==DECL) ) { + alt8=1; + } + + switch (alt8) { + case 1 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:38:28: decl + { + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_decl_in_decllist185); + decl8=decl(); + state._fsp--; + + adaptor.addChild(root_1, decl8.getTree()); + + } + break; + + default : + break loop8; + } + } + + match(input, Token.UP, null); + } + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + + + } + + retval.tree = (XTree)adaptor.rulePostProcessing(root_0); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + // do for sure before leaving + } + return retval; + } + // $ANTLR end "decllist" + + + public static class expr_return extends TreeRuleReturnScope { + XTree tree; + @Override + public XTree getTree() { return tree; } + }; + + + // $ANTLR start "expr" + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:40:1: expr : ( ^(op= ( '+' | '-' | '/' | '*' ) left= expr right= expr ) | ^(op= UMINUS e= expr ) | INTCONST | FLOATCONST | STRINGCONST | ID ); + public final XTypeCheck.expr_return expr() throws RecognitionException { + XTypeCheck.expr_return retval = new XTypeCheck.expr_return(); + retval.start = input.LT(1); + + XTree root_0 = null; + + XTree _first_0 = null; + XTree _last = null; + + + XTree op=null; + XTree INTCONST9=null; + XTree FLOATCONST10=null; + XTree STRINGCONST11=null; + XTree ID12=null; + TreeRuleReturnScope left =null; + TreeRuleReturnScope right =null; + TreeRuleReturnScope e =null; + + XTree op_tree=null; + XTree INTCONST9_tree=null; + XTree FLOATCONST10_tree=null; + XTree STRINGCONST11_tree=null; + XTree ID12_tree=null; + + try { + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:40:5: ( ^(op= ( '+' | '-' | '/' | '*' ) left= expr right= expr ) | ^(op= UMINUS e= expr ) | INTCONST | FLOATCONST | STRINGCONST | ID ) + int alt9=6; + switch ( input.LA(1) ) { + case 22: + case 23: + case 24: + case 26: + { + alt9=1; + } + break; + case UMINUS: + { + alt9=2; + } + break; + case INTCONST: + { + alt9=3; + } + break; + case FLOATCONST: + { + alt9=4; + } + break; + case STRINGCONST: + { + alt9=5; + } + break; + case ID: + { + alt9=6; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + throw nvae; + } + switch (alt9) { + case 1 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:41:5: ^(op= ( '+' | '-' | '/' | '*' ) left= expr right= expr ) + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + op=(XTree)input.LT(1); + if ( (input.LA(1) >= 22 && input.LA(1) <= 24)||input.LA(1)==26 ) { + input.consume(); + op_tree = (XTree)adaptor.dupNode(op); + + + root_1 = (XTree)adaptor.becomeRoot(op_tree, root_1); + + state.errorRecovery=false; + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + match(input, Token.DOWN, null); + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_expr_in_expr219); + left=expr(); + state._fsp--; + + adaptor.addChild(root_1, left.getTree()); + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_expr_in_expr223); + right=expr(); + state._fsp--; + + adaptor.addChild(root_1, right.getTree()); + + match(input, Token.UP, null); + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + + + + if ((left!=null?((XTree)left.getTree()):null).exprType == XType.IntType && (right!=null?((XTree)right.getTree()):null).exprType == XType.IntType) { + op_tree.exprType = XType.IntType; + } else if (((left!=null?((XTree)left.getTree()):null).exprType == XType.FloatType || (left!=null?((XTree)left.getTree()):null).exprType == XType.IntType) && + ((right!=null?((XTree)right.getTree()):null).exprType == XType.FloatType || (right!=null?((XTree)right.getTree()):null).exprType == XType.IntType)) { + op_tree.exprType = XType.FloatType; + } else if ((left!=null?((XTree)left.getTree()):null).exprType == XType.StringType && (right!=null?((XTree)right.getTree()):null).exprType == XType.StringType && (op!=null?op.getType():0) == PLUS) { + op_tree.exprType = XType.StringType; + } else { + op_tree.exprType = XType.InvalidType; + logError(op, "Invalid operator '" + (op!=null?op.getText():null) + "' for '" + (left!=null?((XTree)left.getTree()):null).exprType + "' and '" + (right!=null?((XTree)right.getTree()):null).exprType + "'"); + } + + } + break; + case 2 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:55:7: ^(op= UMINUS e= expr ) + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + _last = (XTree)input.LT(1); + op=(XTree)match(input,UMINUS,FOLLOW_UMINUS_in_expr241); + op_tree = (XTree)adaptor.dupNode(op); + + + root_1 = (XTree)adaptor.becomeRoot(op_tree, root_1); + + match(input, Token.DOWN, null); + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_expr_in_expr245); + e=expr(); + state._fsp--; + + adaptor.addChild(root_1, e.getTree()); + + match(input, Token.UP, null); + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + + + op_tree.exprType = (e!=null?((XTree)e.getTree()):null).exprType; + } + break; + case 3 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:56:7: INTCONST + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + INTCONST9=(XTree)match(input,INTCONST,FOLLOW_INTCONST_in_expr258); + INTCONST9_tree = (XTree)adaptor.dupNode(INTCONST9); + + + adaptor.addChild(root_0, INTCONST9_tree); + + INTCONST9_tree.exprType = XType.IntType; + } + break; + case 4 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:57:7: FLOATCONST + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + FLOATCONST10=(XTree)match(input,FLOATCONST,FOLLOW_FLOATCONST_in_expr281); + FLOATCONST10_tree = (XTree)adaptor.dupNode(FLOATCONST10); + + + adaptor.addChild(root_0, FLOATCONST10_tree); + + FLOATCONST10_tree.exprType = XType.FloatType; + } + break; + case 5 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:58:7: STRINGCONST + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + STRINGCONST11=(XTree)match(input,STRINGCONST,FOLLOW_STRINGCONST_in_expr302); + STRINGCONST11_tree = (XTree)adaptor.dupNode(STRINGCONST11); + + + adaptor.addChild(root_0, STRINGCONST11_tree); + + STRINGCONST11_tree.exprType = XType.StringType; + } + break; + case 6 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:59:7: ID + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + ID12=(XTree)match(input,ID,FOLLOW_ID_in_expr322); + ID12_tree = (XTree)adaptor.dupNode(ID12); + + + adaptor.addChild(root_0, ID12_tree); + + + if (symbols.containsKey((ID12!=null?ID12.getText():null))) { + ID12_tree.exprType = symbols.get((ID12!=null?ID12.getText():null)).type; + } else { + ID12_tree.exprType = XType.InvalidType; + logError(ID12, "'" + (ID12!=null?ID12.getText():null) + "' is not defined."); + } + + } + break; + + } + retval.tree = (XTree)adaptor.rulePostProcessing(root_0); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + // do for sure before leaving + } + return retval; + } + // $ANTLR end "expr" + + + public static class assignstat_return extends TreeRuleReturnScope { + XTree tree; + @Override + public XTree getTree() { return tree; } + }; + + + // $ANTLR start "assignstat" + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:69:1: assignstat : ^(op= ':=' ID e= expr ) ; + public final XTypeCheck.assignstat_return assignstat() throws RecognitionException { + XTypeCheck.assignstat_return retval = new XTypeCheck.assignstat_return(); + retval.start = input.LT(1); + + XTree root_0 = null; + + XTree _first_0 = null; + XTree _last = null; + + + XTree op=null; + XTree ID13=null; + TreeRuleReturnScope e =null; + + XTree op_tree=null; + XTree ID13_tree=null; + + try { + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:69:11: ( ^(op= ':=' ID e= expr ) ) + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:70:5: ^(op= ':=' ID e= expr ) + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + _last = (XTree)input.LT(1); + op=(XTree)match(input,28,FOLLOW_28_in_assignstat362); + op_tree = (XTree)adaptor.dupNode(op); + + + root_1 = (XTree)adaptor.becomeRoot(op_tree, root_1); + + match(input, Token.DOWN, null); + _last = (XTree)input.LT(1); + ID13=(XTree)match(input,ID,FOLLOW_ID_in_assignstat364); + ID13_tree = (XTree)adaptor.dupNode(ID13); + + + adaptor.addChild(root_1, ID13_tree); + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_expr_in_assignstat368); + e=expr(); + state._fsp--; + + adaptor.addChild(root_1, e.getTree()); + + match(input, Token.UP, null); + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + + + + if (!symbols.containsKey((ID13!=null?ID13.getText():null))) { + ID13_tree.exprType = XType.InvalidType; + op_tree.exprType = XType.InvalidType; + logError(ID13, "Undeclared var '" + (ID13!=null?ID13.getText():null) + "'"); + } else { + ID13_tree.exprType = symbols.get((ID13!=null?ID13.getText():null)).type; + + // float <- int + if (ID13_tree.exprType == XType.FloatType && (e!=null?((XTree)e.getTree()):null).exprType == XType.IntType) { + op_tree.exprType = XType.FloatType; + } else if (ID13_tree.exprType != (e!=null?((XTree)e.getTree()):null).exprType) { + op_tree.exprType = XType.InvalidType; + logError(op, "Cannot assign <" + (e!=null?((XTree)e.getTree()):null).exprType + "> to <" + ID13_tree.exprType + ">"); + } else { + op_tree.exprType = ID13_tree.exprType; + } + } + + } + + retval.tree = (XTree)adaptor.rulePostProcessing(root_0); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + // do for sure before leaving + } + return retval; + } + // $ANTLR end "assignstat" + + + public static class cond_return extends TreeRuleReturnScope { + XTree tree; + @Override + public XTree getTree() { return tree; } + }; + + + // $ANTLR start "cond" + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:92:1: cond : ^(op= ( '<' | '>' | '=' ) left= expr right= expr ) ; + public final XTypeCheck.cond_return cond() throws RecognitionException { + XTypeCheck.cond_return retval = new XTypeCheck.cond_return(); + retval.start = input.LT(1); + + XTree root_0 = null; + + XTree _first_0 = null; + XTree _last = null; + + + XTree op=null; + TreeRuleReturnScope left =null; + TreeRuleReturnScope right =null; + + XTree op_tree=null; + + try { + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:92:5: ( ^(op= ( '<' | '>' | '=' ) left= expr right= expr ) ) + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:93:5: ^(op= ( '<' | '>' | '=' ) left= expr right= expr ) + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + op=(XTree)input.LT(1); + if ( (input.LA(1) >= 30 && input.LA(1) <= 32) ) { + input.consume(); + op_tree = (XTree)adaptor.dupNode(op); + + + root_1 = (XTree)adaptor.becomeRoot(op_tree, root_1); + + state.errorRecovery=false; + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + match(input, Token.DOWN, null); + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_expr_in_cond408); + left=expr(); + state._fsp--; + + adaptor.addChild(root_1, left.getTree()); + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_expr_in_cond412); + right=expr(); + state._fsp--; + + adaptor.addChild(root_1, right.getTree()); + + match(input, Token.UP, null); + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + + + + if ((left!=null?((XTree)left.getTree()):null).exprType == XType.StringType || (right!=null?((XTree)right.getTree()):null).exprType == XType.StringType) { + op_tree.exprType = XType.InvalidType; + logError(op, "Cannot use operator '" + (op!=null?op.getText():null) + "' on '" + (left!=null?(input.getTokenStream().toString(input.getTreeAdaptor().getTokenStartIndex(left.start),input.getTreeAdaptor().getTokenStopIndex(left.start))):null) + "' and '" + (right!=null?(input.getTokenStream().toString(input.getTreeAdaptor().getTokenStartIndex(right.start),input.getTreeAdaptor().getTokenStopIndex(right.start))):null) + "'"); + } else if ((left!=null?((XTree)left.getTree()):null).exprType == XType.IntType && (right!=null?((XTree)right.getTree()):null).exprType == XType.IntType) { + op_tree.exprType = XType.IntType; + } else { + op_tree.exprType = XType.FloatType; + } + + } + + retval.tree = (XTree)adaptor.rulePostProcessing(root_0); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + // do for sure before leaving + } + return retval; + } + // $ANTLR end "cond" + + + public static class condstat_return extends TreeRuleReturnScope { + XTree tree; + @Override + public XTree getTree() { return tree; } + }; + + + // $ANTLR start "condstat" + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:106:1: condstat : ^(op= 'if' cond stat ( stat )? ) ; + public final XTypeCheck.condstat_return condstat() throws RecognitionException { + XTypeCheck.condstat_return retval = new XTypeCheck.condstat_return(); + retval.start = input.LT(1); + + XTree root_0 = null; + + XTree _first_0 = null; + XTree _last = null; + + + XTree op=null; + TreeRuleReturnScope cond14 =null; + TreeRuleReturnScope stat15 =null; + TreeRuleReturnScope stat16 =null; + + XTree op_tree=null; + + try { + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:106:9: ( ^(op= 'if' cond stat ( stat )? ) ) + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:106:13: ^(op= 'if' cond stat ( stat )? ) + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + _last = (XTree)input.LT(1); + op=(XTree)match(input,38,FOLLOW_38_in_condstat436); + op_tree = (XTree)adaptor.dupNode(op); + + + root_1 = (XTree)adaptor.becomeRoot(op_tree, root_1); + + match(input, Token.DOWN, null); + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_cond_in_condstat438); + cond14=cond(); + state._fsp--; + + adaptor.addChild(root_1, cond14.getTree()); + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_stat_in_condstat440); + stat15=stat(); + state._fsp--; + + adaptor.addChild(root_1, stat15.getTree()); + + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:106:33: ( stat )? + int alt10=2; + int LA10_0 = input.LA(1); + if ( (LA10_0==STATLIST||LA10_0==28||(LA10_0 >= 37 && LA10_0 <= 38)||LA10_0==45) ) { + alt10=1; + } + switch (alt10) { + case 1 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:106:33: stat + { + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_stat_in_condstat442); + stat16=stat(); + state._fsp--; + + adaptor.addChild(root_1, stat16.getTree()); + + } + break; + + } + + match(input, Token.UP, null); + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + + + } + + retval.tree = (XTree)adaptor.rulePostProcessing(root_0); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + // do for sure before leaving + } + return retval; + } + // $ANTLR end "condstat" + + + public static class whilestat_return extends TreeRuleReturnScope { + XTree tree; + @Override + public XTree getTree() { return tree; } + }; + + + // $ANTLR start "whilestat" + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:108:1: whilestat : ^( 'while' cond stat ) ; + public final XTypeCheck.whilestat_return whilestat() throws RecognitionException { + XTypeCheck.whilestat_return retval = new XTypeCheck.whilestat_return(); + retval.start = input.LT(1); + + XTree root_0 = null; + + XTree _first_0 = null; + XTree _last = null; + + + XTree string_literal17=null; + TreeRuleReturnScope cond18 =null; + TreeRuleReturnScope stat19 =null; + + XTree string_literal17_tree=null; + + try { + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:108:10: ( ^( 'while' cond stat ) ) + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:108:13: ^( 'while' cond stat ) + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + _last = (XTree)input.LT(1); + string_literal17=(XTree)match(input,45,FOLLOW_45_in_whilestat453); + string_literal17_tree = (XTree)adaptor.dupNode(string_literal17); + + + root_1 = (XTree)adaptor.becomeRoot(string_literal17_tree, root_1); + + match(input, Token.DOWN, null); + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_cond_in_whilestat455); + cond18=cond(); + state._fsp--; + + adaptor.addChild(root_1, cond18.getTree()); + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_stat_in_whilestat457); + stat19=stat(); + state._fsp--; + + adaptor.addChild(root_1, stat19.getTree()); + + match(input, Token.UP, null); + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + + + } + + retval.tree = (XTree)adaptor.rulePostProcessing(root_0); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + // do for sure before leaving + } + return retval; + } + // $ANTLR end "whilestat" + + + public static class forstat_return extends TreeRuleReturnScope { + XTree tree; + @Override + public XTree getTree() { return tree; } + }; + + + // $ANTLR start "forstat" + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:109:1: forstat : ^( 'for' assignstat cond assignstat stat ) ; + public final XTypeCheck.forstat_return forstat() throws RecognitionException { + XTypeCheck.forstat_return retval = new XTypeCheck.forstat_return(); + retval.start = input.LT(1); + + XTree root_0 = null; + + XTree _first_0 = null; + XTree _last = null; + + + XTree string_literal20=null; + TreeRuleReturnScope assignstat21 =null; + TreeRuleReturnScope cond22 =null; + TreeRuleReturnScope assignstat23 =null; + TreeRuleReturnScope stat24 =null; + + XTree string_literal20_tree=null; + + try { + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:109:8: ( ^( 'for' assignstat cond assignstat stat ) ) + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:109:13: ^( 'for' assignstat cond assignstat stat ) + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + _last = (XTree)input.LT(1); + string_literal20=(XTree)match(input,37,FOLLOW_37_in_forstat468); + string_literal20_tree = (XTree)adaptor.dupNode(string_literal20); + + + root_1 = (XTree)adaptor.becomeRoot(string_literal20_tree, root_1); + + match(input, Token.DOWN, null); + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_assignstat_in_forstat470); + assignstat21=assignstat(); + state._fsp--; + + adaptor.addChild(root_1, assignstat21.getTree()); + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_cond_in_forstat472); + cond22=cond(); + state._fsp--; + + adaptor.addChild(root_1, cond22.getTree()); + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_assignstat_in_forstat474); + assignstat23=assignstat(); + state._fsp--; + + adaptor.addChild(root_1, assignstat23.getTree()); + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_stat_in_forstat476); + stat24=stat(); + state._fsp--; + + adaptor.addChild(root_1, stat24.getTree()); + + match(input, Token.UP, null); + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + + + } + + retval.tree = (XTree)adaptor.rulePostProcessing(root_0); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + // do for sure before leaving + } + return retval; + } + // $ANTLR end "forstat" + + + public static class stat_return extends TreeRuleReturnScope { + XTree tree; + @Override + public XTree getTree() { return tree; } + }; + + + // $ANTLR start "stat" + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:111:1: stat : ( assignstat | condstat | whilestat | forstat | statlist ); + public final XTypeCheck.stat_return stat() throws RecognitionException { + XTypeCheck.stat_return retval = new XTypeCheck.stat_return(); + retval.start = input.LT(1); + + XTree root_0 = null; + + XTree _first_0 = null; + XTree _last = null; + + + TreeRuleReturnScope assignstat25 =null; + TreeRuleReturnScope condstat26 =null; + TreeRuleReturnScope whilestat27 =null; + TreeRuleReturnScope forstat28 =null; + TreeRuleReturnScope statlist29 =null; + + + try { + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:111:5: ( assignstat | condstat | whilestat | forstat | statlist ) + int alt11=5; + switch ( input.LA(1) ) { + case 28: + { + alt11=1; + } + break; + case 38: + { + alt11=2; + } + break; + case 45: + { + alt11=3; + } + break; + case 37: + { + alt11=4; + } + break; + case STATLIST: + { + alt11=5; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 11, 0, input); + throw nvae; + } + switch (alt11) { + case 1 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:111:13: assignstat + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_assignstat_in_stat490); + assignstat25=assignstat(); + state._fsp--; + + adaptor.addChild(root_0, assignstat25.getTree()); + + } + break; + case 2 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:111:26: condstat + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_condstat_in_stat494); + condstat26=condstat(); + state._fsp--; + + adaptor.addChild(root_0, condstat26.getTree()); + + } + break; + case 3 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:111:37: whilestat + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_whilestat_in_stat498); + whilestat27=whilestat(); + state._fsp--; + + adaptor.addChild(root_0, whilestat27.getTree()); + + } + break; + case 4 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:111:49: forstat + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_forstat_in_stat502); + forstat28=forstat(); + state._fsp--; + + adaptor.addChild(root_0, forstat28.getTree()); + + } + break; + case 5 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:111:59: statlist + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_statlist_in_stat506); + statlist29=statlist(); + state._fsp--; + + adaptor.addChild(root_0, statlist29.getTree()); + + } + break; + + } + retval.tree = (XTree)adaptor.rulePostProcessing(root_0); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + // do for sure before leaving + } + return retval; + } + // $ANTLR end "stat" + + + public static class statlist_return extends TreeRuleReturnScope { + XTree tree; + @Override + public XTree getTree() { return tree; } + }; + + + // $ANTLR start "statlist" + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:113:1: statlist : ^( STATLIST ( stat )* ) ; + public final XTypeCheck.statlist_return statlist() throws RecognitionException { + XTypeCheck.statlist_return retval = new XTypeCheck.statlist_return(); + retval.start = input.LT(1); + + XTree root_0 = null; + + XTree _first_0 = null; + XTree _last = null; + + + XTree STATLIST30=null; + TreeRuleReturnScope stat31 =null; + + XTree STATLIST30_tree=null; + + try { + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:113:9: ( ^( STATLIST ( stat )* ) ) + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:113:13: ^( STATLIST ( stat )* ) + { + root_0 = (XTree)adaptor.nil(); + + + _last = (XTree)input.LT(1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + _last = (XTree)input.LT(1); + STATLIST30=(XTree)match(input,STATLIST,FOLLOW_STATLIST_in_statlist516); + STATLIST30_tree = (XTree)adaptor.dupNode(STATLIST30); + + + root_1 = (XTree)adaptor.becomeRoot(STATLIST30_tree, root_1); + + if ( input.LA(1)==Token.DOWN ) { + match(input, Token.DOWN, null); + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:113:24: ( stat )* + loop12: + while (true) { + int alt12=2; + int LA12_0 = input.LA(1); + if ( (LA12_0==STATLIST||LA12_0==28||(LA12_0 >= 37 && LA12_0 <= 38)||LA12_0==45) ) { + alt12=1; + } + + switch (alt12) { + case 1 : + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:113:24: stat + { + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_stat_in_statlist518); + stat31=stat(); + state._fsp--; + + adaptor.addChild(root_1, stat31.getTree()); + + } + break; + + default : + break loop12; + } + } + + match(input, Token.UP, null); + } + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + + + } + + retval.tree = (XTree)adaptor.rulePostProcessing(root_0); + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + // do for sure before leaving + } + return retval; + } + // $ANTLR end "statlist" public static class program_return extends TreeRuleReturnScope { @@ -109,7 +1597,7 @@ public class XTypeCheck extends TreeParser { // $ANTLR start "program" - // /Users/kreis/git/gitea.humenius.me/dhbw-compilerbau/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.g:27:1: program : 'todo' ; + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:115:1: program : ^( 'program' ID decllist statlist ) ; public final XTypeCheck.program_return program() throws RecognitionException { XTypeCheck.program_return retval = new XTypeCheck.program_return(); retval.start = input.LT(1); @@ -120,23 +1608,61 @@ public class XTypeCheck extends TreeParser { XTree _last = null; - XTree string_literal1=null; + XTree string_literal32=null; + XTree ID33=null; + TreeRuleReturnScope decllist34 =null; + TreeRuleReturnScope statlist35 =null; - XTree string_literal1_tree=null; + XTree string_literal32_tree=null; + XTree ID33_tree=null; try { - // /Users/kreis/git/gitea.humenius.me/dhbw-compilerbau/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.g:27:8: ( 'todo' ) - // /Users/kreis/git/gitea.humenius.me/dhbw-compilerbau/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.g:27:15: 'todo' + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:115:8: ( ^( 'program' ID decllist statlist ) ) + // C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr X Uebersetzer-Leer\\src\\de\\dhbw\\compiler\\antlrxcompiler\\XTypeCheck.g:115:13: ^( 'program' ID decllist statlist ) { root_0 = (XTree)adaptor.nil(); + symbols.clear(); _last = (XTree)input.LT(1); - string_literal1=(XTree)match(input,46,FOLLOW_46_in_program82); - string_literal1_tree = (XTree)adaptor.dupNode(string_literal1); + { + XTree _save_last_1 = _last; + XTree _first_1 = null; + XTree root_1 = (XTree)adaptor.nil(); + _last = (XTree)input.LT(1); + string_literal32=(XTree)match(input,41,FOLLOW_41_in_program533); + string_literal32_tree = (XTree)adaptor.dupNode(string_literal32); - adaptor.addChild(root_0, string_literal1_tree); + root_1 = (XTree)adaptor.becomeRoot(string_literal32_tree, root_1); + + match(input, Token.DOWN, null); + _last = (XTree)input.LT(1); + ID33=(XTree)match(input,ID,FOLLOW_ID_in_program535); + ID33_tree = (XTree)adaptor.dupNode(ID33); + + + adaptor.addChild(root_1, ID33_tree); + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_decllist_in_program537); + decllist34=decllist(); + state._fsp--; + + adaptor.addChild(root_1, decllist34.getTree()); + + _last = (XTree)input.LT(1); + pushFollow(FOLLOW_statlist_in_program539); + statlist35=statlist(); + state._fsp--; + + adaptor.addChild(root_1, statlist35.getTree()); + + match(input, Token.UP, null); + adaptor.addChild(root_0, root_1); + _last = _save_last_1; + } + } @@ -158,5 +1684,59 @@ public class XTypeCheck extends TreeParser { - public static final BitSet FOLLOW_46_in_program82 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_DECL_in_decl81 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_ID_in_decl83 = new BitSet(new long[]{0x0000008000000000L}); + public static final BitSet FOLLOW_39_in_decl87 = new BitSet(new long[]{0x0000050000000008L}); + public static final BitSet FOLLOW_42_in_decl91 = new BitSet(new long[]{0x0000010000000008L}); + public static final BitSet FOLLOW_40_in_decl96 = new BitSet(new long[]{0x0000000000000008L}); + public static final BitSet FOLLOW_DECL_in_decl111 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_ID_in_decl113 = new BitSet(new long[]{0x0000001000000000L}); + public static final BitSet FOLLOW_36_in_decl117 = new BitSet(new long[]{0x0000050000000008L}); + public static final BitSet FOLLOW_42_in_decl121 = new BitSet(new long[]{0x0000010000000008L}); + public static final BitSet FOLLOW_40_in_decl126 = new BitSet(new long[]{0x0000000000000008L}); + public static final BitSet FOLLOW_DECL_in_decl141 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_ID_in_decl143 = new BitSet(new long[]{0x0000080000000000L}); + public static final BitSet FOLLOW_43_in_decl147 = new BitSet(new long[]{0x0000050000000008L}); + public static final BitSet FOLLOW_42_in_decl151 = new BitSet(new long[]{0x0000010000000008L}); + public static final BitSet FOLLOW_40_in_decl156 = new BitSet(new long[]{0x0000000000000008L}); + public static final BitSet FOLLOW_DECLLIST_in_decllist183 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_decl_in_decllist185 = new BitSet(new long[]{0x0000000000000028L}); + public static final BitSet FOLLOW_set_in_expr201 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_expr_in_expr219 = new BitSet(new long[]{0x0000000005C30700L}); + public static final BitSet FOLLOW_expr_in_expr223 = new BitSet(new long[]{0x0000000000000008L}); + public static final BitSet FOLLOW_UMINUS_in_expr241 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_expr_in_expr245 = new BitSet(new long[]{0x0000000000000008L}); + public static final BitSet FOLLOW_INTCONST_in_expr258 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_FLOATCONST_in_expr281 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_STRINGCONST_in_expr302 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_ID_in_expr322 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_28_in_assignstat362 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_ID_in_assignstat364 = new BitSet(new long[]{0x0000000005C30700L}); + public static final BitSet FOLLOW_expr_in_assignstat368 = new BitSet(new long[]{0x0000000000000008L}); + public static final BitSet FOLLOW_set_in_cond394 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_expr_in_cond408 = new BitSet(new long[]{0x0000000005C30700L}); + public static final BitSet FOLLOW_expr_in_cond412 = new BitSet(new long[]{0x0000000000000008L}); + public static final BitSet FOLLOW_38_in_condstat436 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_cond_in_condstat438 = new BitSet(new long[]{0x0000206010008000L}); + public static final BitSet FOLLOW_stat_in_condstat440 = new BitSet(new long[]{0x0000206010008008L}); + public static final BitSet FOLLOW_stat_in_condstat442 = new BitSet(new long[]{0x0000000000000008L}); + public static final BitSet FOLLOW_45_in_whilestat453 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_cond_in_whilestat455 = new BitSet(new long[]{0x0000206010008000L}); + public static final BitSet FOLLOW_stat_in_whilestat457 = new BitSet(new long[]{0x0000000000000008L}); + public static final BitSet FOLLOW_37_in_forstat468 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_assignstat_in_forstat470 = new BitSet(new long[]{0x00000001C0000000L}); + public static final BitSet FOLLOW_cond_in_forstat472 = new BitSet(new long[]{0x0000000010000000L}); + public static final BitSet FOLLOW_assignstat_in_forstat474 = new BitSet(new long[]{0x0000206010008000L}); + public static final BitSet FOLLOW_stat_in_forstat476 = new BitSet(new long[]{0x0000000000000008L}); + public static final BitSet FOLLOW_assignstat_in_stat490 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_condstat_in_stat494 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_whilestat_in_stat498 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_forstat_in_stat502 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_statlist_in_stat506 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_STATLIST_in_statlist516 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_stat_in_statlist518 = new BitSet(new long[]{0x0000206010008008L}); + public static final BitSet FOLLOW_41_in_program533 = new BitSet(new long[]{0x0000000000000004L}); + public static final BitSet FOLLOW_ID_in_program535 = new BitSet(new long[]{0x0000000000000040L}); + public static final BitSet FOLLOW_decllist_in_program537 = new BitSet(new long[]{0x0000000000008000L}); + public static final BitSet FOLLOW_statlist_in_program539 = new BitSet(new long[]{0x0000000000000008L}); } diff --git a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.tokens b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.tokens index c292af2..cd21f48 100644 --- a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.tokens +++ b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/XTypeCheck.tokens @@ -40,7 +40,6 @@ STRINGCONST=16 UMINUS=17 WS=18 ZERO=19 -T__46=46 PLUS=23 '('=20 ')'=21 @@ -68,4 +67,3 @@ PLUS=23 'string'=43 'then'=44 'while'=45 -'todo'=46 diff --git a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/test/OptimizerTest.java b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/test/OptimizerTest.java index afa4cee..d88d6b0 100644 --- a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/test/OptimizerTest.java +++ b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/test/OptimizerTest.java @@ -16,21 +16,15 @@ import static org.junit.Assert.assertEquals; import java.io.ByteArrayInputStream; +import de.dhbw.compiler.antlrxcompiler.*; import org.antlr.runtime.ANTLRInputStream; import org.antlr.runtime.CommonTokenStream; import org.antlr.runtime.tree.CommonTreeNodeStream; -import de.dhbw.compiler.antlrxcompiler.XLexer; -import de.dhbw.compiler.antlrxcompiler.XOptimizer; -import de.dhbw.compiler.antlrxcompiler.XParser; -import de.dhbw.compiler.antlrxcompiler.XTree; -import de.dhbw.compiler.antlrxcompiler.XTreeAdaptor; -import de.dhbw.compiler.antlrxcompiler.XTypeCheck; - public abstract class OptimizerTest { protected void testTypeCheckTree(String in, String expected) throws Exception { - XTreeAdaptor xTreeAdaptor = new XTreeAdaptor(); + XTreeAdaptor xTreeAdaptor = new XTreeAdaptor(); ANTLRInputStream input = new ANTLRInputStream(new ByteArrayInputStream(in.getBytes())); XLexer scanner = new XLexer(input); CommonTokenStream tokens = new CommonTokenStream(scanner); diff --git a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/test/ParseTreeTest.java b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/test/ParseTreeTest.java index 9f9b3b0..2cfedc6 100644 --- a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/test/ParseTreeTest.java +++ b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/test/ParseTreeTest.java @@ -16,6 +16,7 @@ import static org.junit.Assert.assertEquals; import java.io.ByteArrayInputStream; +import de.dhbw.compiler.antlrxcompiler.XTreeAdaptor; import org.antlr.runtime.ANTLRInputStream; import org.antlr.runtime.CommonTokenStream; import org.antlr.runtime.ParserRuleReturnScope; @@ -23,7 +24,6 @@ import org.antlr.runtime.tree.CommonTree; import de.dhbw.compiler.antlrxcompiler.XLexer; import de.dhbw.compiler.antlrxcompiler.XParser; -import de.dhbw.compiler.antlrxcompiler.XTreeAdaptor; public abstract class ParseTreeTest { diff --git a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/test/TypeCheckTest.java b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/test/TypeCheckTest.java index f98aca3..a1c109b 100644 --- a/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/test/TypeCheckTest.java +++ b/CC-Praxis-Antlr X Uebersetzer-Leer/src/de/dhbw/compiler/antlrxcompiler/test/TypeCheckTest.java @@ -16,20 +16,15 @@ import static org.junit.Assert.assertEquals; import java.io.ByteArrayInputStream; +import de.dhbw.compiler.antlrxcompiler.*; import org.antlr.runtime.ANTLRInputStream; import org.antlr.runtime.CommonTokenStream; import org.antlr.runtime.tree.CommonTreeNodeStream; -import de.dhbw.compiler.antlrxcompiler.XLexer; -import de.dhbw.compiler.antlrxcompiler.XParser; -import de.dhbw.compiler.antlrxcompiler.XTree; -import de.dhbw.compiler.antlrxcompiler.XTreeAdaptor; -import de.dhbw.compiler.antlrxcompiler.XTypeCheck; - public abstract class TypeCheckTest { protected void testTypeCheckTree(String in, String expected) throws Exception { - XTreeAdaptor xTreeAdaptor = new XTreeAdaptor(); + XTreeAdaptor xTreeAdaptor = new XTreeAdaptor(); ANTLRInputStream input = new ANTLRInputStream(new ByteArrayInputStream(in.getBytes())); XLexer scanner = new XLexer(input); CommonTokenStream tokens = new CommonTokenStream(scanner);