public string GenerateCode(ProgramExpression program)
{
Traverse(program);
var body = Visit(program);
const string source = @"
{{#each imports}}
#include <{{.}}>
{{/each}}
int main() {
{{#each variableDeclarations}}
{{type}} {{name}};
{{/#each}}
{{body}}
return 0;
}
";
var template = Handlebars.Compile(source);
var data = new
{
body,
imports = imports.ToArray(),
variableDeclarations = variableDeclarations.ToArray()
};
return(template(data));
}
public void Walk(ProgramExpression expression)
{
foreach (var item in expression.Expressions)
{
item.Accept(this);
}
}
public void Walk(ProgramExpression expression)
{
foreach (var item in expression.Expressions)
{
item.Accept(this);
}
}
private static Func <object, object, object> CreateFunc(string program)
{
var assemblyName = new AssemblyName(Guid.NewGuid().ToString())
{
Version = new Version(1, 0)
};
AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName,
AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("Program");
ParameterExpression valueParameter = Expression.Parameter(typeof(object), "value");
ParameterExpression parameterParameter = Expression.Parameter(typeof(object), "parameter");
AstHelper astHelper = AstHelper.Default(moduleBuilder);
astHelper.Variables.Add("value", valueParameter);
astHelper.Variables.Add("parameter", parameterParameter);
Expression rootExpression = ProgramExpression.Compile(astHelper, program);
Expression <Func <object, object, object> > lambda =
Expression.Lambda <Func <object, object, object> >(Expression.Convert(rootExpression, typeof(object)),
valueParameter, parameterParameter);
return(lambda.Compile());
}
public void Comparisons(string program, bool result)
{
Expression expression = ProgramExpression.Compile(new AstHelper(null), program);
bool lamda = Expression.Lambda <Func <bool> >(expression).Compile()();
Assert.AreEqual(result, lamda);
}
public void BinaryExpresionOperation(string program, ExpressionType operation)
{
TigerParser parser = Mother.CreateParser(program);
ProgramExpression rootAstExpression = parser.parse();
Expression expression = rootAstExpression.Compile();
Assert.IsInstanceOf <BinaryExpression>(expression);
var binary = expression as BinaryExpression;
Assert.AreEqual(binary.NodeType, operation);
}
public static Expression Compile(string program)
{
var assemblyName = new AssemblyName(Guid.NewGuid().ToString())
{
Version = new Version(1, 0)
};
AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName,
AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("Program");
AstHelper runtime = CreateRuntime(moduleBuilder);
return(ProgramExpression.Compile(runtime, program));
}
public ProgramExpression Parse()
{
var program = new ProgramExpression();
while (true)
{
var expression = TryParseExpression();
if (expression == ProgramExpression.NullExpression) break;
program.Expressions.Add(expression);
CurrentIndex++;
}
return program;
}
public ProgramExpression Parse()
{
var program = new ProgramExpression();
while (true)
{
var expression = TryParseExpression();
if (expression == ProgramExpression.NullExpression)
{
break;
}
program.Expressions.Add(expression);
CurrentIndex++;
}
return(program);
}
public void FunctionInvoked_ComplexFunctions(string program, int result)
{
var scope = new AstHelper(null);
Expression <Func <int, int, int> > sum = (a, b) => a + b;
scope.Functions.Add("sum", new FunctionReference(sum, typeof(int), typeof(int), typeof(int)));
Expression <Func <int, int, int> > resta = (a, b) => a - b;
scope.Functions.Add("resta", new FunctionReference(resta, typeof(int), typeof(int), typeof(int)));
Expression <Func <int, int, int> > prod = (a, b) => a * b;
scope.Functions.Add("prod", new FunctionReference(prod, typeof(int), typeof(int), typeof(int)));
Expression <Func <int, int, int> > div = (a, b) => a / b;
scope.Functions.Add("div", new FunctionReference(div, typeof(int), typeof(int), typeof(int)));
Expression expression = ProgramExpression.Compile(scope, program);
int lamda = Expression.Lambda <Func <int> >(expression).Compile()();
Assert.AreEqual(lamda, result);
}
private static void Main(string[] args)
{
Console.Title = "Tiger Compiler version 1.0";
Console.WriteLine("Tiger Compiler version 1.0");
Console.WriteLine("Copyright (C) 2011 - 2012 Ariel Rodriguez & Eric Hernandez & Dayan Gonzalez");
FileInfo fi;
if (args.Length == 0 || args[0] == "")
{
fi = new FileInfo(Environment.CurrentDirectory + "\\program.tig");
}
else
{
string path = args.Aggregate("", (current, s) => current + s);
fi = new FileInfo(path);
}
if (!fi.Exists)
{
Console.WriteLine("(0, 0): File '{0}' cannot be found.", fi.FullName);
Console.WriteLine();
return;
}
string fileName = fi.Name.Substring(0, fi.Name.Length - 4);
try
{
var assemblyName = new AssemblyName("Program");
assemblyName.Version = new Version(1, 0);
AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName,
AssemblyBuilderAccess.
Save);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("Program", "Program.exe");
AstHelper runtime = CreateRuntime(moduleBuilder);
TypeBuilder typeBuilder = moduleBuilder.DefineType("Program");
MethodBuilder methodBuilder = typeBuilder.DefineMethod("Main", MethodAttributes.Static);
Expression <Func <string[], int> > lambda = WrapMain(ProgramExpression.CompileFile(runtime, fi.FullName));
lambda.CompileToMethod(methodBuilder);
typeBuilder.CreateType();
moduleBuilder.CreateGlobalFunctions();
assemblyBuilder.SetEntryPoint(methodBuilder);
assemblyBuilder.Save(fileName + ".exe");
}
catch (SyntaxException e)
{
Console.WriteLine(e.Message);
Console.ReadLine();
}
catch (SemanticException e)
{
Console.WriteLine(e.Message);
Console.ReadLine();
}
//catch (Exception e)
//{
// Console.WriteLine(e);
// Console.ReadLine();
//}
}
public LoopExpression(ProgramExpression body)
{
Body = body;
}
