private void GenStmt(ParseTreeNode stmt, ILGenerator il, SymbolTable symbolTable)
{
if (stmt.Term.Name == "program")
{
if (stmt.ChildNodes.Count > 0)
{
this.GenStmt(stmt.ChildNodes[0].ChildNodes[0], il, symbolTable);
this.GenStmt(stmt.ChildNodes[1], 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, il, symbolTable);
symbolTable.Store(name, this.TypeOfExpr(assign.ChildNodes[1], symbolTable), il);
});
}
var variableIden = stmt.ChildNodes[1];
while (true)
{
string name = variableIden.ChildNodes[0].Token.ValueString;
symbolTable.AddLocal(name, il.DeclareLocal(localType));
if (generateAssign != null)
{
generateAssign(name);
}
if (variableIden.ChildNodes.Count < 2)
{
break;
}
variableIden = variableIden.ChildNodes[1];
}
}
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), 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), il, symbolTable);
symbolTable.Store(ident, this.TypeOfExpr(stmt.ChildNodes[1].ChildNodes[1], symbolTable), 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 parameterList = new List <FunctionDefinition.Argument>();
List <Type> types = new List <Type>();
SymbolTable localSymbols = new SymbolTable();
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);
var paramIdentifier = currParam.ChildNodes[0].ChildNodes[0];
while (true)
{
var parameterName = paramIdentifier.ChildNodes[0].Token.ValueString;
parameterList.Add(new FunctionDefinition.Argument()
{
argName = parameterName, argType = parameterType
});
localSymbols.AddParameter(parameterName, parameterType);
types.Add(parameterType);
if (paramIdentifier.ChildNodes.Count == 1)
{
break;
}
paramIdentifier = paramIdentifier.ChildNodes[1];
}
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();
//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], ilMeth, localSymbols);
ilMeth.Emit(OpCodes.Ret);
var methodDec = new FunctionDefinition()
{
methodDefinition = methodDeclaration,
arguments = parameterList
};
functionTable.Add(functionName, methodDec);
}
else if (stmt.Term.Name == "result")
{
GenExpr(stmt.ChildNodes[1], TypeOfExpr(stmt.ChildNodes[1], symbolTable), 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);
}
}
private void GenStmt(ParseTreeNode stmt, ILGenerator il, SymbolTable symbolTable, Label?exitScope = null)
{
if (stmt.Term.Name == "program")
{
if (stmt.ChildNodes.Count > 0)
{
this.GenStmt(stmt.ChildNodes[0].ChildNodes[0], il, symbolTable);
this.GenStmt(stmt.ChildNodes[1], 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[0]);
}
else
{
localType = 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, il, symbolTable);
symbolTable.Store(name, TypeOfExpr(assign.ChildNodes[1], symbolTable), il);
});
}
var variableIden = stmt.ChildNodes[1];
while (true)
{
string name = variableIden.ChildNodes[0].Token.ValueString;
symbolTable.AddLocal(name, il.DeclareLocal(localType));
if (generateAssign != null)
{
generateAssign(name);
}
if (variableIden.ChildNodes.Count < 2)
{
break;
}
variableIden = variableIden.ChildNodes[1];
}
}
else if (stmt.Term.Name == "io")
{
if (stmt.ChildNodes[0].Token.ValueString == "put")
{
//the first argument is always there, until we can build a proper AST this'll have to do
ParseTreeNode argItem = stmt.ChildNodes[1];
this.GenExpr(argItem.ChildNodes[0], typeof(string), il, symbolTable);
il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("Write", new System.Type[] { typeof(string) }));
argItem = stmt.ChildNodes[2];
while (true)
{
if (argItem.ChildNodes.Count == 0)
{
break;
}
this.GenExpr(argItem.ChildNodes[0].ChildNodes[0], typeof(string), il, symbolTable);
il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("Write", new System.Type[] { typeof(string) }));
argItem = argItem.ChildNodes[1];
}
if (stmt.ChildNodes[3].ChildNodes.Count == 0)//put a newline character if there is no ...
{
il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new System.Type[] { }));
}
}
else if (stmt.ChildNodes[0].Token.ValueString == "get")
{
foreach (var argument in stmt.ChildNodes[1].ChildNodes)
{
//switch(symbolTable.TypeOfVar(
il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("ReadLine", new System.Type[] { }));
symbolTable.Store(argument.Token.ValueString, typeof(string), il);
}
}
}
else if (stmt.Term.Name == "assignment")
{
if (stmt.ChildNodes[0].Term.Name == "functionCall")//if we see this as a function call, we know that's not true, and it's actually an array (which is kinda the same thing in turing)
{
string arrayName = stmt.ChildNodes[0].ChildNodes[0].Token.ValueString;
if (symbolTable.TypeOfVar(arrayName).IsArray)
{
symbolTable.PushVar(arrayName, il);
if (stmt.ChildNodes[0].ChildNodes[1].ChildNodes.Count > 1)
{
throw new NotImplementedException("Multi-Dimensional arrays are not yet supported");
}
this.GenExpr(stmt.ChildNodes[0].ChildNodes[1].ChildNodes[0], typeof(int), il, symbolTable);
this.GenExpr(stmt.ChildNodes[1].ChildNodes[1], TypeOfExpr(stmt.ChildNodes[1].ChildNodes[1], symbolTable), il, symbolTable);
il.Emit(OpCodes.Stelem, symbolTable.TypeOfVar(arrayName).GetElementType());
}
else
{
throw new NotSupportedException(String.Format("Non-array identifier used like an array: {0}", arrayName));
}
}
else
{
this.GenExpr(stmt.ChildNodes[1].ChildNodes[1], TypeOfExpr(stmt.ChildNodes[1].ChildNodes[1], symbolTable), il, symbolTable);
string ident = stmt.ChildNodes[0].Token.ValueString;
symbolTable.Store(ident, TypeOfExpr(stmt.ChildNodes[1].ChildNodes[1], symbolTable), il);
}
}
else if (stmt.Term.Name == "functionDefinition")
{
string functionName = stmt.ChildNodes[0].ChildNodes[1].Token.ValueString;
SymbolTable localSymbols = new SymbolTable(symbolTable);
foreach (var parameter in symbolTable.functionTable[functionName].arguments)
{
localSymbols.AddParameter(parameter.argName, parameter.argType);
}
var ilMeth = symbolTable.functionTable[functionName].GetILGenerator();
GenStmt(stmt.ChildNodes[1], ilMeth, localSymbols);
ilMeth.Emit(OpCodes.Ret);
}
else if (stmt.Term.Name == "result")
{
GenExpr(stmt.ChildNodes[1], TypeOfExpr(stmt.ChildNodes[1], symbolTable), 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.Term.Name == "functionCall" | stmt.Term.Name == "memberCall")
{
GenExpr(stmt, null, il, symbolTable);
}
else if (stmt.Term.Name == "ifBlock")
{
Label ifTrue = il.DefineLabel();
Label ifFalse = il.DefineLabel();
Label endLabel = il.DefineLabel();
GenExpr(stmt.ChildNodes[0], typeof(bool), il, symbolTable); //expression to check if true
il.Emit(OpCodes.Brtrue, ifTrue); //if true then jump to true block
il.Emit(OpCodes.Br, ifFalse); //otherwise jump to false block
il.MarkLabel(ifTrue); //true block
GenStmt(stmt.ChildNodes[1], il, symbolTable);
il.Emit(OpCodes.Br, endLabel); //jump to after false block
il.MarkLabel(ifFalse); //false block
if (stmt.ChildNodes[2].ChildNodes.Count > 0) //then there's an else-if, this takes place in the else section
{
ParseTreeNode elseBlockStmt = stmt.ChildNodes[2]; //Turn the elsif to an inner if statement
elseBlockStmt.ChildNodes.Add(stmt.ChildNodes[3]); //Move the optional else statement to the inner if statement
elseBlockStmt.Term.Name = "ifBlock";
GenStmt(elseBlockStmt, il, symbolTable);
}
else if (stmt.ChildNodes[3].ChildNodes.Count > 0)
{
GenStmt(stmt.ChildNodes[3].ChildNodes[0], il, symbolTable); //generate expresson for false section, otherwise the label will be at the same spot as the end
}
il.MarkLabel(endLabel); //the end of the if statement
}
else if (stmt.Term.Name == "loop")
{
Label beginLoop = il.DefineLabel();
Label endLoop = il.DefineLabel();
il.MarkLabel(beginLoop);
GenStmt(stmt.ChildNodes[0], il, symbolTable, endLoop);
il.Emit(OpCodes.Br, beginLoop);
il.MarkLabel(endLoop);
}
else if (stmt.Term.Name == "forLoop")
{
il.BeginScope();
Label beginLoop = il.DefineLabel();
Label endLoop = il.DefineLabel();
LocalBuilder i = il.DeclareLocal(typeof(int));
string identName = stmt.ChildNodes[1].Token.ValueString;
symbolTable.AddLocal(identName, i);
symbolTable.AddLocal("___endLoop", il.DeclareLocal(typeof(int)));
if (stmt.ChildNodes[2].ChildNodes.Count == 1)//then an identifier is used as a range, or char. We just fail for now
{
throw new NotImplementedException();
}
else
{
GenExpr(stmt.ChildNodes[2].ChildNodes[0], typeof(int), il, symbolTable);
symbolTable.Store(identName, typeof(int), il);
GenExpr(stmt.ChildNodes[2].ChildNodes[1], typeof(int), il, symbolTable);
symbolTable.Store("___endLoop", typeof(int), il);
}
il.MarkLabel(beginLoop);
GenStmt(stmt.ChildNodes[4], il, symbolTable, endLoop);
symbolTable.PushVar(identName, il);
il.Emit(OpCodes.Ldc_I4_1);
if (stmt.ChildNodes[3].ChildNodes.Count > 0)//then there is a decreasing statement, so do decreasing
{
il.Emit(OpCodes.Sub);
}
else
{
il.Emit(OpCodes.Add);
}
il.Emit(OpCodes.Dup);
symbolTable.Store(identName, typeof(int), il);
symbolTable.PushVar("___endLoop", il);
if (stmt.ChildNodes[3].ChildNodes.Count > 0)//then there is a decreasing statement, so do decreasing
{
il.Emit(OpCodes.Bge, beginLoop);
}
else
{
il.Emit(OpCodes.Ble, beginLoop);
}
il.MarkLabel(endLoop);
symbolTable.RemoveLocal(identName);
symbolTable.RemoveLocal("___endLoop");
il.EndScope();
}
else
{
throw new System.Exception("don't know how to gen a " + stmt.Term.Name);
}
}
