Code Listing for Problem 4

Transcription

1 Code Listing for Problem 4 Phillip Cannata, arranged by Jonathan Bernard test.c 1 float x; 2 3 int main () { 4 int x; 5 x = 4 * 2 * * ; 6 } hmm.bat -cp bin proj. Hmm %* Hmm.java 1 package proj; 2 3 import java. io. FileInputStream ; 4 import java. io. IOException ; 5 import java. io. InputStream ; 6 7 import proj. AbstractSyntax.*; 8 import proj. parser. Parser; 9 import proj. parser. ParseException ; public class Hmm { public static void main( String args []) throws ParseException, IOException, InterpreterRuntimeError { 14 // If there is a command line argument, interpret it as a stdin. 15 InputStream instream = System. in; 16 if (args.length > 0 ) { 17 instream = new FileInputStream ( args [0]); 18 } Parser parser = new Parser( instream); 21 Program prog = parser. Program (); prog.display (); 1

2 24 25 } } Parser.jj 1 options { 2 STATIC = false ; 3 } 4 PARSER_BEGIN ( Parser) 5 package proj. parser; 6 7 import java.io.*; 8 import java.util.*; 9 import static proj. AbstractSyntax.*; 10 import proj. AbstractSyntax ; public class Parser { private Type curtopleveltype ; 15 private Token curtopleveltoken ; 16 } PARSER_END ( Parser) SKIP : 21 { 22 " " 23 "\t" 24 "\n" 25 "\r" 26 <"//" (~["\n","\r"])* ("\n" "\r")> 27 } TOKEN: 30 { 31 < IF: "if" > 32 < ELSE: " else" > 33 < WHILE: " while" > < INT: "int" > 36 < FLOAT: " float" > 37 < BOOL: " bool" > 38 < VOID: " void" > < TRUE: " true" > 41 < FALSE: " false" > < AND_OP: "&&" > 44 < OR_OP: " " > 45 < LPAREN: "(" > 46 < RPAREN: ")" > 47 < LBRACE: "[" > 48 < RBRACE: "]" > 49 < LCURLY: "{" > 50 < RCURLY: "}" > 2

3 51 < SEMI: ";" > 52 < EQ_OP: "==" > 53 < NE_OP: "!=" > 54 < LE_OP: " <=" > 55 < GE_OP: " >=" > 56 < ELEM: "<-" > 57 < PIPE: " " > 58 < EQUALS: "=" > 59 < LT_OP: "<" > 60 < GT_OP: ">" > 61 < MINUS: "-" > 62 < PLUS: "+" > 63 < MULT: "*" > 64 < DIV: "/" > 65 < PRCNT: "%" > 66 < BANG: "!" > 67 < COMMA: "," > 68 < SQUOTE: " " > 69 < DOT: "." > } TOKEN: /* Literals */ 74 { 75 < INTEGER: (["0"-"9"])+ > 76 < IDENTIFIER : [ "A"-"Z", "a"-"z", "_"] // Maybe we could add the "_" check by the grammar ( [ "A"-"Z", "a"-"z", "0"-"9", "_" ] )* 78 > 79 < CLFLOAT: (["0"-"9"])+ "." (["0"-"9"])* > 80 } TOKEN: 83 { 84 <ERROR: ~[] > 85 } Program Program () : 88 { List < Declaration > globals = new ArrayList < Declaration >(); 89 List < Declaration > declist = null; 90 List < Function > funclist = new ArrayList < Function >(); 91 List < Statement > stmntlist ; 92 Function f; Token t; 93 } 94 { ( LOOKAHEAD (3) declist = declaration () <SEMI > { globals. addall( declist ); } )* curtopleveltype = rettype () curtopleveltoken = <IDENTIFIER > f = function () 97 { funclist. add(f); return new Program( globals, funclist); } 98 } Function function () : 101 { Block b; List < Declaration > args = new ArrayList < Declaration >(); } 102 { 103 <LPAREN > <RPAREN > b = block () 104 { 3

4 105 return new Function ( curtopleveltype, curtopleveltoken, args, b); 106 } 107 } List < Declaration > declaration () : 112 { Type t; Declaration d; List < Declaration > result = new ArrayList < Declaration >() ;} 113 { 114 t = vartype () 115 d = singlevardeclaration (t) { result. add(d); } 116 ( <COMMA > d = singlevardeclaration (t) { result. add(d); } )* 117 { 118 return result; 119 } 120 } Declaration singlevardeclaration ( Type type) : 123 { Token id; Expression initvalue = null;} 124 { 125 id = <IDENTIFIER > [ <EQUALS > initvalue = expression () ] 126 { 127 return new Declaration ( type, id, initvalue ); 128 } 129 } /** 133 * The return type is either a Variable type or void 134 */ 135 Type rettype () : 136 { Type t;} 137 { 138 <VOID > { return BaseType. VOID; } 139 t = vartype () { return t; } 140 } /** 143 * A type that can be assigned to a variable. 144 */ 145 Type vartype () : 146 { Type t; List <Type > argtypes = new ArrayList <Type >() ;} 147 { 148 t = varbasetype () { return t; } 149 <LPAREN > ( LOOKAHEAD (2) t = vartype () <COMMA > { argtypes. add(t);} )* t = rettype () <RPAREN > 150 { return new FunctionType ( argtypes, t); } 151 } /** 154 * A Base Type, except for the void 155 */ 156 Type varbasetype () : 157 {} 158 { 159 <INT > { return BaseType. INT; } 4

5 160 <FLOAT > { return BaseType. FLOAT; } 161 <BOOL > { return BaseType. BOOL; } 162 } List < Statement > statements () : 165 { Statement s; List < Statement > statements = new ArrayList < Statement >() ;} 166 { 167 ( s = statement () {if (s!= null) { statements. add(s);} } )* { return statements ; } 168 } Statement statement () : 171 { Statement s; List < Declaration > decls; } 172 { 173 <SEMI > { return null; } 174 decls = declaration () { return new DeclContainer ( decls); } 175 s = block () { return s; } 176 s = assignment () { return s; } 177 s = ifstatement () { return s; } 178 s = whilestatement () { return s; } 179 } Block block () : 182 { List < Statement > ss; } 183 { 184 <LCURLY > ss = statements () <RCURLY > { return new Block( ss); } 185 } Assignment assignment () : 188 { Token id ; LValue target; Expression e;} 189 { 190 id = <IDENTIFIER > ( 191 <LBRACE > e = expression () <RBRACE > { target = new ListTupleReference (id, e);} 192 { target = new Variable( id); } 193 ) <EQUALS > e = expression () <SEMI > 194 { return new Assignment ( target, e);} 195 } Conditional ifstatement () : 198 { Expression e; Statement sif = null, selse = null; Conditional c; } 199 { 200 <IF > <LPAREN > e = expression () <RPAREN > sif = block () 201 [ <ELSE > ( selse = ifstatement () selse = block ()) ] 202 { 203 return new Conditional (e, sif, selse); 204 } 205 } Loop whilestatement () : 208 { Expression e; Loop l; Block s; } 209 { 210 <WHILE > <LPAREN > e = expression () <RPAREN > s = block () 211 { return new Loop(e, s); } 212 } Expression expression () : 5

6 215 { Expression e1, e2, current = null; Token t; Operator o = Operator. OR; } 216 { 217 e1 = conjunction () { current = e1; } 218 ( t = <OR_OP > e2 = conjunction () { current = new Binary(new OpTokenPair (o, t), current, e2); } 219 )* { return current; } 220 } Expression conjunction () : 223 { Expression e1, e2, current = null; Token t; Operator o = Operator. AND; } 224 { 225 e1 = equality () { current = e1; } 226 ( t = <AND_OP > e2 = equality () { current = new Binary(new OpTokenPair ( o, t), current, e2); } 227 )* { return current; } 228 } Expression equality () : 231 { Expression e1, e2, current = null; OpTokenPair o; } 232 { 233 e1 = relation () { current = e1; } 234 ( o = equop () e2 = relation () { current = new Binary(o, current, e2); } 235 )* { return current; } 236 } OpTokenPair equop () : 239 { Token t;} 240 { 241 t = <EQ_OP > { return new OpTokenPair ( Operator.EQ, t); } 242 t = <NE_OP > { return new OpTokenPair ( Operator.NE, t); } 243 } Expression relation () : 246 { Expression e1, e2, current = null; OpTokenPair o; } 247 { 248 e1 = addition () { current = e1; } 249 ( o = relop () e2 = addition () { current = new Binary(o, current, e2); } 250 )* { return current; } 251 } OpTokenPair relop () : 254 { Token t;} 255 { 256 t = <LT_OP > { return new OpTokenPair ( Operator.LT, t); } 257 t = <LE_OP > { return new OpTokenPair ( Operator.LE, t); } 258 t = <GT_OP > { return new OpTokenPair ( Operator.GT, t); } 259 t = <GE_OP > { return new OpTokenPair ( Operator.GE, t); } 260 } Expression addition () : 263 { Expression e1, e2, current = null; OpTokenPair o; } 264 { 265 e1 = term () { current = e1; } 266 ( LOOKAHEAD (2) o = addop () e2 = term () { current = new Binary(o, 6

7 current, e2); } 267 )* { return current; } 268 } OpTokenPair addop () : 271 { Token t;} 272 { 273 t = <PLUS > { return new OpTokenPair ( Operator. PLUS, t); } 274 t = <MINUS > { return new OpTokenPair ( Operator. MINUS, t); } 275 } Expression term () : 278 { Expression e1, e2, current = null; OpTokenPair o; } 279 { 280 e1 = factor () { current = e1; } 281 ( o = mulop () e2 = factor () { current = new Binary(o, current, e2); } 282 )* { return current; } 283 } OpTokenPair mulop () : 286 { Token t;} 287 { 288 t = <MULT > { return new OpTokenPair ( Operator. TIMES, t); } 289 t = <DIV > { return new OpTokenPair ( Operator. DIV, t); } 290 t = <PRCNT > { return new OpTokenPair ( Operator. MOD, t); } 291 } Expression factor () : 294 { Expression e; OpTokenPair o = null; } 295 { 296 [ o = unaryop () ] e = primary () { return (o == null)? e : new Unary(o, e); } 297 } OpTokenPair unaryop () : 300 { Token t; } 301 { 302 t = <MINUS > { return new OpTokenPair ( Operator. NEG, t); } 303 t = <BANG > { return new OpTokenPair ( Operator. NOT, t); } 304 } Expression primary () : 307 { Expression e; Token t;} 308 { 309 e = identifierorarrayref () { return e; } 310 e = literal () { return e; } 311 } Expression identifierorarrayref () : 314 { Token id; Expression ref = null; } 315 { 316 id = <IDENTIFIER > [ LOOKAHEAD (2) <LBRACE > ref = expression () <RBRACE > ] 317 { 318 if ( ref == null) { 319 return new Variable( id); 320 } else { 7

8 321 return new ListTupleReference (id, ref); 322 } 323 } 324 } Expression literal () : 327 { Token t;} 328 { 329 t = <INTEGER > { return new IntValue(t); } 330 t = <TRUE > { return new BoolValue (true, t. beginline ); } 331 t = <FALSE > { return new BoolValue (false, t. beginline ); } 332 t = <CLFLOAT > { return new FloatValue (t); } 333 } 8