public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var codeExpression = (CodeObjectReference)code;
if (codeExpression.Modifiers.Count == 0)
{
var op = machine.CreateOperation<GetValueOperation>();
op.Id = codeExpression.Id;
}
else
{
foreach (var modifier in codeExpression.Modifiers)
{
var functionCall = modifier as CodeObjectFunctionCall;
if (functionCall == null) continue;
CodeDomCompiler.Compile(modifier, machine);
var callOp = machine.CreateOperation<ObjectMemberOperation>();
callOp.MemberName = codeExpression.Id;
}
}
if (codeExpression.Next != null)
{
machine.CreateOperation<PushOperation>();
CodeDomCompiler.Compile(codeExpression.Next, machine);
}
return machine;
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
// CCCC(indexA)SSSSSS(indexC)
var whileStatement = (CodeWhileStatement)code;
int cCount = machine.CommandCount;
CodeDomCompiler.Compile(whileStatement.Condition, machine);
//Put AX (result of condition evaluation) to BBX
var exch = machine.CreateOperation <RegisterOperation>();
exch.Source = MachineRegisters.AX;
exch.Destination = MachineRegisters.BBX;
//Jmp To Else
var jmpToNext = machine.CreateOperation <JmpIfOperation>();
int eCount = machine.CommandCount;
//Compile Statement
CodeDomCompiler.Compile(whileStatement.Statement, machine);
var jmpToCondition = machine.CreateOperation <JmpIfOperation>();
jmpToCondition.Offset = cCount - machine.CommandCount + 1;
jmpToNext.Offset = machine.CommandCount - eCount + 1;
return(machine);
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
// CCCC(indexA)SSSSSS(indexC)
var whileStatement = (CodeWhileStatement)code;
int cCount = machine.CommandCount;
CodeDomCompiler.Compile(whileStatement.Condition, machine);
//Put AX (result of condition evaluation) to BBX
var exch = machine.CreateOperation<RegisterOperation>();
exch.Source = MachineRegisters.AX;
exch.Destination = MachineRegisters.BBX;
//Jmp To Else
var jmpToNext = machine.CreateOperation<JmpIfOperation>();
int eCount = machine.CommandCount;
//Compile Statement
CodeDomCompiler.Compile(whileStatement.Statement, machine);
var jmpToCondition = machine.CreateOperation<JmpIfOperation>();
jmpToCondition.Offset = cCount - machine.CommandCount + 1;
jmpToNext.Offset = machine.CommandCount - eCount + 1;
return machine;
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
// CCCC(indexA)SSSSSS(indexB)EEEEEE(indexC)
var ifStatement = (CodeIfStatement)code;
CodeDomCompiler.Compile(ifStatement.Condition, machine);
//Put AX (result of condition evaluation) to BBX
var exch = machine.CreateOperation <RegisterOperation>();
exch.Source = MachineRegisters.AX;
exch.Destination = MachineRegisters.BBX;
//Jmp To Else
var jmpToElse = machine.CreateOperation <JmpIfOperation>();
int eCount = machine.CommandCount;
//Compile Statement
CodeDomCompiler.Compile(ifStatement.Statement, machine);
jmpToElse.Offset = machine.CommandCount - eCount + 1;
//Compile Else if Any
if (ifStatement.ElseStatement != null)
{
//Jmp To Next
var jmpToNext = machine.CreateOperation <JmpOperation>();
//Modify jmpToElse
jmpToElse.Offset++;
int sCount = machine.CommandCount;
CodeDomCompiler.Compile(ifStatement.ElseStatement, machine);
jmpToNext.Offset = machine.CommandCount - sCount + 1;
}
return(machine);
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var codeExpression = (CodeObjectReference)code;
if (codeExpression.Modifiers.Count == 0)
{
var op = machine.CreateOperation <GetValueOperation>();
op.Id = codeExpression.Id;
}
else
{
foreach (var modifier in codeExpression.Modifiers)
{
var functionCall = modifier as CodeObjectFunctionCall;
if (functionCall == null)
{
continue;
}
CodeDomCompiler.Compile(modifier, machine);
var callOp = machine.CreateOperation <ObjectMemberOperation>();
callOp.MemberName = codeExpression.Id;
}
}
if (codeExpression.Next != null)
{
machine.CreateOperation <PushOperation>();
CodeDomCompiler.Compile(codeExpression.Next, machine);
}
return(machine);
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
// CCCC(indexA)SSSSSS(indexB)EEEEEE(indexC)
var ifStatement = (CodeIfStatement)code;
CodeDomCompiler.Compile(ifStatement.Condition, machine);
//Put AX (result of condition evaluation) to BBX
var exch = machine.CreateOperation<RegisterOperation>();
exch.Source = MachineRegisters.AX;
exch.Destination = MachineRegisters.BBX;
//Jmp To Else
var jmpToElse = machine.CreateOperation<JmpIfOperation>();
int eCount = machine.CommandCount;
//Compile Statement
CodeDomCompiler.Compile(ifStatement.Statement, machine);
jmpToElse.Offset = machine.CommandCount - eCount + 1;
//Compile Else if Any
if (ifStatement.ElseStatement != null)
{
//Jmp To Next
var jmpToNext = machine.CreateOperation<JmpOperation>();
//Modify jmpToElse
jmpToElse.Offset++;
int sCount = machine.CommandCount;
CodeDomCompiler.Compile(ifStatement.ElseStatement, machine);
jmpToNext.Offset = machine.CommandCount - sCount + 1;
}
return machine;
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var codeExpression = (CodeBinaryOperator)code;
CodeDomCompiler.Compile(codeExpression.Right, machine);
var op = machine.CreateOperation <PushOperation>();
op.SourceObject = codeExpression.Right;
CodeDomCompiler.Compile(codeExpression.Left, machine);
op = machine.CreateOperation <PushOperation>();
op.SourceObject = codeExpression.Left;
Operation sop;
switch (codeExpression.Type)
{
case OperatorType.Plus:
sop = machine.CreateOperation <AddOperation>();
break;
case OperatorType.Minus:
sop = machine.CreateOperation <SubOperation>();
break;
case OperatorType.Mul:
sop = machine.CreateOperation <MulOperation>();
break;
case OperatorType.Mod:
sop = machine.CreateOperation <ModOperation>();
break;
case OperatorType.Div:
sop = machine.CreateOperation <DivOperation>();
break;
default:
var gop = machine.CreateOperation <GenericOperation>();
gop.Symbol = Mapping[codeExpression.Type];
sop = gop;
break;
}
sop.SourceObject = codeExpression;
var pop = machine.CreateOperation <PopOperation>();
pop.SourceObject = codeExpression;
return(machine);
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var op = machine.CreateOperation<ValueOperation>();
op.Value = ((CodeValueReference)code).Value;
op.SourceObject = code;
return machine;
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var op = machine.CreateOperation <ValueOperation>();
op.Value = ((CodeValueReference)code).Value;
op.SourceObject = code;
return(machine);
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var ret = (CodeReturnStatement)code;
CodeDomCompiler.Compile(ret.Expression, machine);
machine.CreateOperation <RetOperation>();
return(machine);
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var ret = (CodeReturnStatement)code;
CodeDomCompiler.Compile(ret.Expression, machine);
machine.CreateOperation<RetOperation>();
return machine;
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var codeExpression = (CodeVariableReference)code;
var op = machine.CreateOperation<GetValueOperation>();
op.Id = codeExpression.Id;
op.SourceObject = codeExpression;
return machine;
}
public void MachineExection()
{
IScriptContext context = new ScriptContext();
//Example 0: Machine
ExecutableMachine machine = ExecutableMachine.Create();
SetValueOperation sv = machine.CreateOperation <SetValueOperation>();
sv.Id = "a";
machine.AX = "Hello World";
machine.CreateOperation <RetOperation>();
machine.Execute(context);
object rez = context.GetItem("a", true);
Assert.Equal("Hello World", rez);
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var codeExpression = (CodeVariableReference)code;
var op = machine.CreateOperation <GetValueOperation>();
op.Id = codeExpression.Id;
op.SourceObject = codeExpression;
return(machine);
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var codeExpression = (CodeAssignExpression)code;
CodeDomCompiler.Compile(codeExpression.RightExpression, machine);
var op = machine.CreateOperation<SetValueOperation>();
op.Id = codeExpression.Id;
op.SourceObject = code;
return machine;
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var call = (CodeObjectFunctionCall)code;
// AX = function name
// BX = parameter count
// stack is full of parameters
foreach (var codeParameter in call.Parameters)
{
CodeDomCompiler.Compile(codeParameter, machine);
var op = machine.CreateOperation<PushOperation>();
}
var countOp = machine.CreateOperation<RegisterOperation>();
countOp.Destination = MachineRegisters.BX;
countOp.Value = call.Parameters.Count;
return machine;
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var codeExpression = (CodeAssignExpression)code;
CodeDomCompiler.Compile(codeExpression.RightExpression, machine);
var op = machine.CreateOperation <SetValueOperation>();
op.Id = codeExpression.Id;
op.SourceObject = code;
return(machine);
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var call = (CodeObjectFunctionCall)code;
// AX = function name
// BX = parameter count
// stack is full of parameters
foreach (var codeParameter in call.Parameters)
{
CodeDomCompiler.Compile(codeParameter, machine);
var op = machine.CreateOperation <PushOperation>();
}
var countOp = machine.CreateOperation <RegisterOperation>();
countOp.Destination = MachineRegisters.BX;
countOp.Value = call.Parameters.Count;
return(machine);
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var codeExpression = (CodeBinaryOperator)code;
CodeDomCompiler.Compile(codeExpression.Right, machine);
var op = machine.CreateOperation<PushOperation>();
op.SourceObject = codeExpression.Right;
CodeDomCompiler.Compile(codeExpression.Left, machine);
op = machine.CreateOperation<PushOperation>();
op.SourceObject = codeExpression.Left;
Operation sop;
switch (codeExpression.Type)
{
case OperatorType.Plus:
sop = machine.CreateOperation<AddOperation>();
break;
case OperatorType.Minus:
sop = machine.CreateOperation<SubOperation>();
break;
case OperatorType.Mul:
sop = machine.CreateOperation<MulOperation>();
break;
case OperatorType.Mod:
sop = machine.CreateOperation<ModOperation>();
break;
case OperatorType.Div:
sop = machine.CreateOperation<DivOperation>();
break;
default:
var gop = machine.CreateOperation<GenericOperation>();
gop.Symbol = Mapping[codeExpression.Type];
sop = gop;
break;
}
sop.SourceObject = codeExpression;
var pop = machine.CreateOperation<PopOperation>();
pop.SourceObject = codeExpression;
return machine;
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var program = (CodeProgram)code;
foreach (var statement in program.Statements)
CodeDomCompiler.Compile(statement, machine);
machine.CreateOperation<RetOperation>();
//TODO: Functions
//foreach (CodeObject function in program.Functions)
// Compile(function, machine);
return machine;
}
public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
{
var program = (CodeProgram)code;
foreach (var statement in program.Statements)
{
CodeDomCompiler.Compile(statement, machine);
}
machine.CreateOperation <RetOperation>();
//TODO: Functions
//foreach (CodeObject function in program.Functions)
// Compile(function, machine);
return(machine);
}
public void Benchmark()
{
IScriptContext context = new ScriptContext();
//Example 0: Machine
ExecutableMachine machine = ExecutableMachine.Create();
int iterations = 2;// 10000000;
//loops = 10000000
ValueOperation op0 = machine.CreateOperation <ValueOperation>();
op0.Value = iterations;
SetValueOperation op1 = machine.CreateOperation <SetValueOperation>();
op1.Id = "loops";
// counter = 0
ValueOperation op2 = machine.CreateOperation <ValueOperation>();
op2.Value = 0;
SetValueOperation op3 = machine.CreateOperation <SetValueOperation>();
op3.Id = "counter";
//while (loops > 0)
RegisterOperation op4 = machine.CreateOperation <RegisterOperation>();
op4.Destination = MachineRegisters.BX;
op4.Value = 0;
GetValueOperation op5 = machine.CreateOperation <GetValueOperation>();
op5.Id = "loops";
CmpOperation op6 = machine.CreateOperation <CmpOperation>();
JmpIfOperation op7 = machine.CreateOperation <JmpIfOperation>();
op7.Offset = 8;
//loops = loops -1;
GetValueOperation op8 = machine.CreateOperation <GetValueOperation>();
op8.Id = "loops";
DecOperation op9 = machine.CreateOperation <DecOperation>();
SetValueOperation op10 = machine.CreateOperation <SetValueOperation>();
op10.Id = "loops";
//counter = counter + 1;
GetValueOperation op11 = machine.CreateOperation <GetValueOperation>();
op11.Id = "counter";
IncOperation op12 = machine.CreateOperation <IncOperation>();
SetValueOperation op13 = machine.CreateOperation <SetValueOperation>();
op13.Id = "counter";
JmpOperation op14 = machine.CreateOperation <JmpOperation>();
op14.Offset = -10;
machine.CreateOperation <RetOperation>();
machine.Execute(context);
object rez = context.GetItem("counter", true);
Assert.Equal(iterations, rez);
}
