/*private void Store(string name, System.Type type, ref ILGenerator il, SymbolTable symbolTable) * { * if (symbolTable.locals.ContainsKey(name)) * { * LocalBuilder locb = symbolTable.locals[name]; * * if (locb.LocalType == type) * { * il.Emit(OpCodes.Stloc, symbolTable.locals[name]); * } * else * { * throw new System.Exception("'" + name + "' is of type " + locb.LocalType.Name + " but attempted to store value of type " + type.Name); * } * } * else * { * throw new System.Exception("undeclared variable '" + name + "'"); * } * }*/ private void GenExpr(ParseTreeNode expr, System.Type expectedType, ref ILGenerator il, SymbolTable symbolTable) { Type deliveredType; if (expr.Term.Name == "stringLiteral") { deliveredType = typeof(string); il.Emit(OpCodes.Ldstr, expr.Token.ValueString); } else if (expr.Term.Name == "number") { if (expr.Token.Value is int) { deliveredType = typeof(int); il.Emit(OpCodes.Ldc_I4, (int)expr.Token.Value); } else { deliveredType = typeof(float); il.Emit(OpCodes.Ldc_R4, float.Parse(expr.Token.ValueString)); } } else if (expr.Term.Name == "binExpr") { deliveredType = TypeOfExpr(expr.ChildNodes[0], symbolTable); GenExpr(expr.ChildNodes[0], deliveredType, ref il, symbolTable); GenExpr(expr.ChildNodes[2], deliveredType, ref il, symbolTable); switch (expr.ChildNodes[1].Term.Name) { case "+": il.Emit(OpCodes.Add); break; case "*": il.Emit(OpCodes.Mul); break; case "-": il.Emit(OpCodes.Sub); break; default: throw new Exception("Unrecognized operator " + expr.ChildNodes[1].Term.Name); } } else if (expr.Term.Name == "identifier") { string ident = expr.Token.ValueString; symbolTable.PushVar(ident, ref il); deliveredType = this.TypeOfExpr(expr, symbolTable); } else if (expr.Term.Name == "functionCall") { deliveredType = TypeOfExpr(expr, symbolTable); string funcName = expr.ChildNodes[0].Token.ValueString; if (!this.functionTable.ContainsKey(funcName)) { throw new System.Exception("undeclared function or procedure '" + funcName + "'"); } //il.Emit(OpCodes.Call, mainProgram.GetMethod(funcName)); var parameters = this.functionTable[funcName].arguments; int curParam = 0; if (expr.ChildNodes[1].ChildNodes.Count > 0) {//push all the arguments onto the stack ParseTreeNode argItem = expr.ChildNodes[1].ChildNodes[0]; while (true) { this.GenExpr(argItem.ChildNodes[0], parameters[curParam].argType, ref il, symbolTable); if (argItem.ChildNodes.Count == 1) { break; } argItem = argItem.ChildNodes[1]; curParam++; } } il.Emit(OpCodes.Call, this.functionTable[funcName].methodDefinition); } else { throw new System.Exception("don't know how to generate " + expr.GetType().Name); } if (deliveredType != expectedType) { if (deliveredType == typeof(int) && expectedType == typeof(string)) { il.Emit(OpCodes.Box, typeof(int)); il.Emit(OpCodes.Callvirt, typeof(object).GetMethod("ToString")); } else if (deliveredType == typeof(float) && expectedType == typeof(string)) { il.Emit(OpCodes.Box, typeof(float)); il.Emit(OpCodes.Callvirt, typeof(object).GetMethod("ToString")); } else { throw new System.Exception("can't coerce a " + deliveredType.Name + " to a " + expectedType.Name); } } }
private void GenStmt(ParseTreeNode stmt, ref ILGenerator il, SymbolTable symbolTable) { if (stmt.Term.Name == "program") { if (stmt.ChildNodes.Count > 0) { this.GenStmt(stmt.ChildNodes[0].ChildNodes[0], ref il, symbolTable); this.GenStmt(stmt.ChildNodes[1], ref il, symbolTable); } } else if (stmt.Term.Name == "variableDeclaration") { Type localType; // declare a local if (stmt.ChildNodes[2].Term.Name == "typeSpecifier") { localType = this.TypeOfTypeDeclaration(stmt.ChildNodes[2].ChildNodes[1]); } else { localType = this.TypeOfExpr(stmt.ChildNodes[2].ChildNodes[1], symbolTable); //symbolTable.locals[stmt.ChildNodes[1].ChildNodes[0].Token.ValueString] = il.DeclareLocal(this.TypeOfExpr(stmt.ChildNodes[2].ChildNodes[1], symbolTable)); } Action <string> generateAssign = null; ParseTreeNode assign = stmt.ChildNodes.Where(x => x.Term.Name == "setEqual").SingleOrDefault(); // set the initial value if (assign != null) { generateAssign = new Action <string>(name => { this.GenExpr(assign.ChildNodes[1], symbolTable.locals[name].LocalType, ref il, symbolTable); symbolTable.Store(name, this.TypeOfExpr(assign.ChildNodes[1], symbolTable), ref il); } ); //this.Store(stmt.ChildNodes[1].Token.ValueString, this.TypeOfExpr(assign.ChildNodes[1], symbolTable), ref il, symbolTable); } } else if (stmt.Term.Name == "io") { if (stmt.ChildNodes[0].Token.ValueString == "put") { ParseTreeNode argItem = stmt.ChildNodes[1]; while (true) { this.GenExpr(argItem.ChildNodes[0], typeof(string), ref il, symbolTable); il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("Write", new System.Type[] { typeof(string) })); if (argItem.ChildNodes.Count > 1) { argItem = argItem.ChildNodes[1]; } else { break; } } il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new System.Type[] { })); } } else if (stmt.Term.Name == "assignment") { string ident = stmt.ChildNodes[0].Token.ValueString; this.GenExpr(stmt.ChildNodes[1].ChildNodes[1], this.TypeOfExpr(stmt.ChildNodes[1].ChildNodes[1], symbolTable), ref il, symbolTable); symbolTable.Store(ident, this.TypeOfExpr(stmt.ChildNodes[1].ChildNodes[1], symbolTable), ref il); //this.Store(ident, this.TypeOfExpr(stmt.ChildNodes[1].ChildNodes[1], symbolTable), ref il, symbolTable); } else if (stmt.Term.Name == "functionDefinition") { string functionName = stmt.ChildNodes[1].Token.ValueString; if (functionTable.ContainsKey(functionName)) { throw new Exception(functionName + " has already been defined"); } var argumentList = new List <FunctionDefinition.Argument>(); List <Type> types = new List <Type>(); if (stmt.ChildNodes[2].ChildNodes.Count > 0) { var currParam = stmt.ChildNodes[2].ChildNodes[0]; while (true) { var parameterType = TypeOfExpr(currParam.ChildNodes[0].ChildNodes[1].ChildNodes[1], symbolTable); types.Add(parameterType); argumentList.Add(new FunctionDefinition.Argument() { argName = currParam.ChildNodes[0].ChildNodes[0].Token.ValueString, argType = parameterType }); if (currParam.ChildNodes.Count == 1) { break; } currParam = currParam.ChildNodes[1]; } } var methodDeclaration = mainProgram.DefineMethod(functionName, MethodAttributes.Static, TypeOfExpr(stmt.ChildNodes[3].ChildNodes[1], symbolTable), types.ToArray()); var ilMeth = methodDeclaration.GetILGenerator(); SymbolTable localSymbols = new SymbolTable(); if (stmt.ChildNodes[2].ChildNodes.Count > 0) { var currParam = stmt.ChildNodes[2].ChildNodes[0]; while (true) { localSymbols.parameters.Add(new Tuple <string, Type>(currParam.ChildNodes[0].ChildNodes[0].Token.ValueString, TypeOfExpr(currParam.ChildNodes[0].ChildNodes[1].ChildNodes[1], symbolTable))); if (currParam.ChildNodes.Count == 1) { break; } currParam = currParam.ChildNodes[1]; } } GenStmt(stmt.ChildNodes[4], ref ilMeth, localSymbols); ilMeth.Emit(OpCodes.Ret); var methodDec = new FunctionDefinition() { methodDefinition = methodDeclaration, arguments = argumentList }; functionTable.Add(functionName, methodDec); } else if (stmt.Term.Name == "result") { GenExpr(stmt.ChildNodes[1], TypeOfExpr(stmt.ChildNodes[1], symbolTable), ref il, symbolTable); var result = il.DeclareLocal(TypeOfExpr(stmt.ChildNodes[1], symbolTable)); il.Emit(OpCodes.Stloc, result); il.Emit(OpCodes.Ldloc, result); il.Emit(OpCodes.Ret, result); } /* * else if (stmt is ReadInt) * { * this.il.Emit(Emit.OpCodes.Call, typeof(System.Console).GetMethod("ReadLine", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static, null, new System.Type[] { }, null)); * this.il.Emit(Emit.OpCodes.Call, typeof(int).GetMethod("Parse", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static, null, new System.Type[] { typeof(string) }, null)); * this.Store(((ReadInt)stmt).Ident, typeof(int)); * } * else if (stmt is ForLoop) * { * // example: * // for x = 0 to 100 do * // print "hello"; * // end; * * // x = 0 * ForLoop forLoop = (ForLoop)stmt; * Assign assign = new Assign(); * assign.Ident = forLoop.Ident; * assign.Expr = forLoop.From; * this.GenStmt(assign); * // jump to the test * Emit.Label test = this.il.DefineLabel(); * this.il.Emit(Emit.OpCodes.Br, test); * * // statements in the body of the for loop * Emit.Label body = this.il.DefineLabel(); * this.il.MarkLabel(body); * this.GenStmt(forLoop.Body); * * // to (increment the value of x) * this.il.Emit(Emit.OpCodes.Ldloc, this.symbolTable[forLoop.Ident]); * this.il.Emit(Emit.OpCodes.Ldc_I4, 1); * this.il.Emit(Emit.OpCodes.Add); * this.Store(forLoop.Ident, typeof(int)); * * // **test** does x equal 100? (do the test) * this.il.MarkLabel(test); * this.il.Emit(Emit.OpCodes.Ldloc, this.symbolTable[forLoop.Ident]); * this.GenExpr(forLoop.To, typeof(int)); * this.il.Emit(Emit.OpCodes.Blt, body); * }*/ else { throw new System.Exception("don't know how to gen a " + stmt.Term.Name); } }