public void Compile(Generator gen, String outputFile)
{
// Generate compiletime environment
var labelMap = new Dictionary <String, String>();
foreach (String funName in fenv.getFunctionNames())
{
labelMap.Add(funName, Label.Fresh());
}
CEnv cenv = new CEnv(labelMap);
// Compile expression
e.Compile(cenv, gen);
gen.Emit(Instruction.PRINTI);
gen.Emit(Instruction.STOP);
// Compile functions
foreach (FuncDef f in fenv.getFunctions())
{
cenv = new CEnv(labelMap);
f.Compile(gen, cenv);
}
// Generate bytecode at and print to file
gen.PrintCode();
int[] bytecode = gen.ToBytecode();
using (TextWriter wr = new StreamWriter(outputFile)) {
foreach (int b in bytecode)
{
wr.Write(b);
wr.Write(" ");
}
}
}
public void Compile(Generator generator, string outputFile)
{
// Generate compiletime environment
var labels = _functionEnvironment.GetFunctionNames().ToDictionary(funName => funName, funName => Label.Fresh());
var compilationEnvironment = new CompilationEnvironment(labels);
// Compile expression
_expression.Compile(compilationEnvironment, generator);
generator.Emit(Instruction.PrintI);
generator.Emit(Instruction.Stop);
// Compile functions
foreach (var functionDefinition in _functionEnvironment.GetFunctions())
{
compilationEnvironment = new CompilationEnvironment(labels);
functionDefinition.Compile(compilationEnvironment, generator);
}
// Generate bytecode at and print to file
generator.PrintCode();
var bytecode = generator.ToBytecode();
using (TextWriter writer = new StreamWriter(outputFile))
{
foreach (var b in bytecode)
{
writer.Write(b);
writer.Write(" ");
}
}
}
public void Compile(Generator generator, string outputFile)
{
// Generate compiletime environment
var labels = _functionEnvironment.GetFunctionNames().ToDictionary(funName => funName, funName => Label.Fresh());
var compilationEnvironment = new CompilationEnvironment(labels);
// Compile expression
_expression.Compile(compilationEnvironment, generator);
generator.Emit(Instruction.PrintI);
generator.Emit(Instruction.Stop);
// Compile functions
foreach (var functionDefinition in _functionEnvironment.GetFunctions())
{
compilationEnvironment = new CompilationEnvironment(labels);
functionDefinition.Compile(compilationEnvironment, generator);
}
// Generate bytecode at and print to file
generator.PrintCode();
var bytecode = generator.ToBytecode();
using (TextWriter writer = new StreamWriter(outputFile))
{
foreach (var b in bytecode)
{
writer.Write(b);
writer.Write(" ");
}
}
}
public override void Compile(CEnv env, Generator gen)
{
e1.Compile(env, gen);
env.DeclareLocal(this.name);
e2.Compile(env, gen);
env.PopEnv();
gen.Emit(Instruction.SWAP);
gen.Emit(new INCSP(-1));
}
public override void Compile(CompilationEnvironment compilationEnvironment, Generator generator)
{
_e1.Compile(compilationEnvironment, generator);
compilationEnvironment.PushTemporary();
_e2.Compile(compilationEnvironment, generator);
switch (_op)
{
case Operator.Add:
generator.Emit(Instruction.Add);
break;
case Operator.Div:
generator.Emit(Instruction.Div);
break;
case Operator.Mul:
generator.Emit(Instruction.Mul);
break;
case Operator.Sub:
generator.Emit(Instruction.Sub);
break;
case Operator.Eq:
generator.Emit(Instruction.Eq);
break;
case Operator.Ne:
generator.Emit(Instruction.Eq);
generator.Emit(Instruction.Not);
break;
case Operator.Ge:
generator.Emit(Instruction.LT);
generator.Emit(Instruction.Not);
break;
case Operator.Gt:
generator.Emit(Instruction.Swap);
generator.Emit(Instruction.LT);
break;
case Operator.Le:
generator.Emit(Instruction.Swap);
generator.Emit(Instruction.LT);
generator.Emit(Instruction.Not);
break;
case Operator.Lt:
generator.Emit(Instruction.LT);
break;
case Operator.And:
generator.Emit(Instruction.Mul);
break;
case Operator.Or:
generator.Emit(Instruction.Add);
generator.Emit(new CstI(0));
generator.Emit(Instruction.Eq);
generator.Emit(Instruction.Not);
break;
default:
throw new InvalidOperationException(string.Format("Unknown binary operator: {0}", _op));
}
compilationEnvironment.PopTemporary();
}
public override void Compile(CEnv env, Generator gen)
{
string l1 = Label.Fresh();
string l2 = Label.Fresh();
cond.Compile(env, gen);
gen.Emit(new IFZERO(l1));
e2.Compile(env, gen);
gen.Emit(new GOTO(l2));
gen.Label(l1);
e3.Compile(env, gen);
gen.Label(l2);
}
public override void Compile(CEnv env, Generator gen)
{
String L1 = Label.Fresh();
String L2 = Label.Fresh();
e1.Compile(env, gen);
gen.Emit(new IFZERO(L1));
e2.Compile(env, gen);
gen.Emit(new GOTO(L2));
gen.Label(L1);
e3.Compile(env, gen);
gen.Label(L2);
}
public override void Compile(CompilationEnvironment env, Generator gen)
{
e1.Compile(env, gen);
env.DeclareLocal(name); // push the name variable to the stack<string> locals of CEnv
//env.CompileVariable(gen, name); // get the array index of the variable name
//gen.Emit(Instruction.LdI); // load the variable name with the index which is on the top of the stack
e2.Compile(env, gen);
gen.Emit(Instruction.Swap);
gen.Emit(new IncSp(-1));
env.Pop(); // deallocate variable name
}
public override void Compile(CompilationEnvironment env, Generator gen)
{
var l1 = Label.Fresh();
var l2 = Label.Fresh();
e1.Compile(env, gen);
gen.Emit(new IfZero(l1));
e2.Compile(env, gen); // inside if
gen.Emit(new Goto(l2));
//generate flash labels: Label.Fresh()
gen.Label(l1); // add labels to the stack machine L1 -else
e3.Compile(env, gen); // inside else
gen.Label(l2); // L2
}
public void Compile(CompilationEnvironment compilationEnvironment, Generator generator)
{
compilationEnvironment.DeclareLocal(_argument.Item1); // Formal argument name points to top of stack
generator.Label(compilationEnvironment.GetFunctionLabel(_name));
_body.Compile(compilationEnvironment, generator);
generator.Emit(new Return(1));
}
public void CompileVariable(Generator gen, string name)
{
var offset = 0;
foreach (var variableName in _locals)
{
if (variableName == name)
{
gen.Emit(Instruction.GetSp);
gen.Emit(new CstI(offset));
gen.Emit(Instruction.Sub);
return;
}
offset++;
}
throw new InvalidOperationException("Undeclared variable: " + name);
}
public void CompileVariable(Generator gen, string name)
{
var offset = 0;
foreach (var variableName in _locals)
{
if (variableName == name)
{
gen.Emit(Instruction.GetSp);
gen.Emit(new CstI(offset));
gen.Emit(Instruction.Sub);
return;
}
offset++;
}
throw new InvalidOperationException("Undeclared variable: " + name);
}
public override void Compile(CompilationEnvironment compilationEnvironment, Generator generator)
{
_expression.Compile(compilationEnvironment, generator);
switch (_op)
{
case Operator.Not:
generator.Emit(Instruction.Not);
break;
case Operator.Neg:
generator.Emit(new CstI(0));
generator.Emit(Instruction.Swap);
generator.Emit(Instruction.Sub);
break;
default:
throw new InvalidOperationException(string.Format("Unknown unary operator: {0}", _op));
}
}
public override void Compile(CEnv env, Generator gen)
{
e1.Compile(env, gen);
switch (op)
{
case Operator.Not:
gen.Emit(Instruction.NOT);
break;
case Operator.Neg:
gen.Emit(new CSTI(0));
gen.Emit(Instruction.SWAP);
gen.Emit(Instruction.SUB);
break;
default:
throw new Exception("Unknown unary operator: " + op);
}
}
public override void Compile(CompilationEnvironment compilationEnvironment, Generator generator)
{
_expression.Compile(compilationEnvironment, generator);
switch (_op)
{
case Operator.Not:
generator.Emit(Instruction.Not);
break;
case Operator.Neg:
generator.Emit(new CstI(0));
generator.Emit(Instruction.Swap);
generator.Emit(Instruction.Sub);
break;
default:
throw new InvalidOperationException(string.Format("Unknown unary operator: {0}", _op));
}
}
public void Compile(Generator gen, CEnv env)
{
foreach (Pair <String, Type> formArg in this.formArgs)
{
env.DeclareLocal(formArg.Fst);
}
gen.Label(env.getFunctionLabel(fName));
body.Compile(env, gen);
gen.Emit(new RET(formArgs.Count));
}
public void CompileVariable(Generator gen, String name)
{
int offset = 0;
foreach (String variableName in locals)
{
if (variableName == name)
{
gen.Emit(Instruction.GETSP);
gen.Emit(new CSTI(offset));
gen.Emit(Instruction.SUB);
return;
}
else
{
offset++;
}
}
throw new Exception("Undeclared variable: " + name);
}
public override void Compile(CEnv env, Generator gen)
{
int argCount = 0;
foreach (var expression in expressions)
{
expression.Compile(env, gen);
argCount++;
}
String fLabel = env.getFunctionLabel(fName);
gen.Emit(new CALL(argCount, fLabel));
}
public void Compile(Generator gen, CEnv env)
{
int argCount = 0;
foreach (var formArg in formArgs)
{
env.DeclareLocal(formArg.Fst);
argCount++;
}
gen.Label(env.getFunctionLabel(fName));
body.Compile(env, gen);
gen.Emit(new RET(argCount));
//throw new NotSupportedException("This functionality will be provided at a later moment.");
}
public override void Compile(CEnv env, Generator gen)
{
foreach (Expression arg in args)
{
arg.Compile(env, gen);
env.PushTemporary();
}
String fLabel = env.getFunctionLabel(fName);
gen.Emit(new CALL(args.Count, fLabel));
foreach (Expression arg in args)
{
env.PopTemporary();
}
}
public void Compile(CompilationEnvironment env, Generator gen)
{
foreach (Tuple <String, Type> arg in args)
{
env.DeclareLocal(arg.Item1);
}
gen.Label(env.GetFunctionLabel(fName));
body.Compile(env, gen);
gen.Emit(new Return(args.Count));
/*
* env.DeclareLocal(formArg.Fst); // Formal argument name points to top of stack
* gen.Label(env.getFunctionLabel(fName));
* body.Compile(env, gen);
* gen.Emit(new RET(1));
*/
}
public override void Compile(CompilationEnvironment env, Generator gen)
{
foreach (Expression arg in _args)
{
arg.Compile(env, gen);
env.PushTemporary();
}
String fLabel = env.GetFunctionLabel(fName);
gen.Emit(new Call(_args.Count, fLabel));
foreach (var arg in _args)
{
env.PopTemporary();
}
/*
* arg.Compile(env, gen);
* String fLabel = env.getFunctionLabel(fName);
* gen.Emit(new CALL(1, fLabel));
*/
}
public override void Compile(CompilationEnvironment compilationEnvironment, Generator generator)
{
_e1.Compile(compilationEnvironment, generator);
compilationEnvironment.PushTemporary();
_e2.Compile(compilationEnvironment, generator);
switch (_op)
{
case Operator.Mod:
generator.Emit(Instruction.Mod);
break;
case Operator.Add:
generator.Emit(Instruction.Add);
break;
case Operator.Div:
generator.Emit(Instruction.Div);
break;
case Operator.Mul:
generator.Emit(Instruction.Mul);
break;
case Operator.Sub:
generator.Emit(Instruction.Sub);
break;
case Operator.Eq:
generator.Emit(Instruction.Eq);
break;
case Operator.Ne:
generator.Emit(Instruction.Eq);
generator.Emit(Instruction.Not);
break;
case Operator.Ge:
generator.Emit(Instruction.LT);
generator.Emit(Instruction.Not);
break;
case Operator.Gt:
generator.Emit(Instruction.Swap);
generator.Emit(Instruction.LT);
break;
case Operator.Le:
generator.Emit(Instruction.Swap);
generator.Emit(Instruction.LT);
generator.Emit(Instruction.Not);
break;
case Operator.Lt:
generator.Emit(Instruction.LT);
break;
case Operator.And:
generator.Emit(Instruction.Mul);
break;
case Operator.Or:
generator.Emit(Instruction.Add);
generator.Emit(new CstI(0));
generator.Emit(Instruction.Eq);
generator.Emit(Instruction.Not);
break;
default:
throw new InvalidOperationException(string.Format("Unknown binary operator: {0}", _op));
}
compilationEnvironment.PopTemporary();
}
public override void Compile(CEnv env, Generator gen)
{
e1.Compile(env, gen);
env.PushTemporary();
e2.Compile(env, gen);
switch (op)
{
case Operator.Add:
gen.Emit(Instruction.ADD);
break;
case Operator.Div:
gen.Emit(Instruction.DIV);
break;
case Operator.Mul:
gen.Emit(Instruction.MUL);
break;
case Operator.Sub:
gen.Emit(Instruction.SUB);
break;
case Operator.Eq:
gen.Emit(Instruction.EQ);
break;
case Operator.Ne:
gen.Emit(Instruction.EQ);
gen.Emit(Instruction.NOT);
break;
case Operator.Ge:
gen.Emit(Instruction.LT);
gen.Emit(Instruction.NOT);
break;
case Operator.Gt:
gen.Emit(Instruction.SWAP);
gen.Emit(Instruction.LT);
break;
case Operator.Le:
gen.Emit(Instruction.SWAP);
gen.Emit(Instruction.LT);
gen.Emit(Instruction.NOT);
break;
case Operator.Lt:
gen.Emit(Instruction.LT);
break;
case Operator.And:
gen.Emit(Instruction.MUL);
break;
case Operator.Or:
gen.Emit(Instruction.ADD);
gen.Emit(new CSTI(0));
gen.Emit(Instruction.EQ);
gen.Emit(Instruction.NOT);
break;
default:
throw new Exception("Unknown binary operator: " + op);
}
env.PopTemporary();
}
public override void Compile(CEnv env, Generator gen)
{
env.CompileVariable(gen, name);
gen.Emit(Instruction.LDI);
}
public override void Compile(CEnv env, Generator gen)
{
gen.Emit(new CSTI(value));
}
public override void Compile(CompilationEnvironment compilationEnvironment, Generator generator)
{
_arg.Compile(compilationEnvironment, generator);
var label = compilationEnvironment.GetFunctionLabel(_name);
generator.Emit(new Call(1, label));
}
