public override void Compile(ByteCode bc)
{
m_Function.Compile(bc);
var argslen = m_Arguments.Count;
if (!string.IsNullOrEmpty(m_Name))
{
bc.Emit_Copy(0);
bc.Emit_Index(DynValue.NewString(m_Name), true);
bc.Emit_Swap(0, 1);
++argslen;
}
for (var i = 0; i < m_Arguments.Count; i++)
m_Arguments[i].Compile(bc);
if (!string.IsNullOrEmpty(m_Name))
{
bc.Emit_ThisCall(argslen, m_DebugErr);
}
else
{
bc.Emit_Call(argslen, m_DebugErr);
}
}
internal static int LoadChunk(Script script, SourceCode source, ByteCode bytecode)
{
ScriptLoadingContext lcontext = CreateLoadingContext(script, source);
try
{
Statement stat;
using (script.PerformanceStats.StartStopwatch(Diagnostics.PerformanceCounter.AstCreation))
stat = new ChunkStatement(lcontext);
int beginIp = -1;
//var srcref = new SourceRef(source.SourceID);
using (script.PerformanceStats.StartStopwatch(Diagnostics.PerformanceCounter.Compilation))
using (bytecode.EnterSource(null))
{
bytecode.Emit_Nop(string.Format("Begin chunk {0}", source.Name));
beginIp = bytecode.GetJumpPointForLastInstruction();
stat.Compile(bytecode);
bytecode.Emit_Nop(string.Format("End chunk {0}", source.Name));
}
//Debug_DumpByteCode(bytecode, source.SourceID);
return beginIp;
}
catch (SyntaxErrorException ex)
{
ex.DecorateMessage(script);
throw;
}
}
internal static int LoadFunction(Script script, SourceCode source, ByteCode bytecode, bool usesGlobalEnv)
{
ScriptLoadingContext lcontext = CreateLoadingContext(script, source);
try
{
FunctionDefinitionExpression fnx;
using (script.PerformanceStats.StartStopwatch(Diagnostics.PerformanceCounter.AstCreation))
fnx = new FunctionDefinitionExpression(lcontext, usesGlobalEnv);
int beginIp = -1;
//var srcref = new SourceRef(source.SourceID);
using (script.PerformanceStats.StartStopwatch(Diagnostics.PerformanceCounter.Compilation))
using (bytecode.EnterSource(null))
{
bytecode.Emit_Nop(string.Format("Begin function {0}", source.Name));
beginIp = fnx.CompileBody(bytecode, source.Name);
bytecode.Emit_Nop(string.Format("End function {0}", source.Name));
}
//Debug_DumpByteCode(bytecode, source.SourceID);
return beginIp;
}
catch (SyntaxErrorException ex)
{
ex.DecorateMessage(script);
throw;
}
}
public override void Compile(ByteCode bc)
{
var L = new Loop
{
Scope = m_StackFrame
};
bc.PushSourceRef(m_Repeat);
bc.LoopTracker.Loops.Push(L);
var start = bc.GetJumpPointForNextInstruction();
bc.Emit_Enter(m_StackFrame);
m_Block.Compile(bc);
bc.PopSourceRef();
bc.PushSourceRef(m_Until);
bc.Emit_Debug("..end");
m_Condition.Compile(bc);
bc.Emit_Leave(m_StackFrame);
bc.Emit_Jump(OpCode.Jf, start);
bc.LoopTracker.Loops.Pop();
var exitpoint = bc.GetJumpPointForNextInstruction();
foreach (var i in L.BreakJumps)
i.NumVal = exitpoint;
bc.PopSourceRef();
}
public override void Compile(ByteCode bc)
{
using (bc.EnterSource(m_FunctionCallExpression.SourceRef))
{
m_FunctionCallExpression.Compile(bc);
RemoveBreakpointStop(bc.Emit_Pop());
}
}
public override void Compile(ByteCode bc)
{
foreach (var exp in expressions)
exp.Compile(bc);
if (expressions.Count > 1)
bc.Emit_MkTuple(expressions.Count);
}
public override void Compile(ByteCode bc)
{
bc.Emit_Clean(m_StackFrame);
Address = bc.GetJumpPointForLastInstruction();
foreach (var gotostat in m_Gotos)
gotostat.SetAddress(Address);
}
private Processor(Processor parentProcessor)
{
m_Debug = parentProcessor.m_Debug;
m_RootChunk = parentProcessor.m_RootChunk;
m_GlobalTable = parentProcessor.m_GlobalTable;
m_Script = parentProcessor.m_Script;
m_Parent = parentProcessor;
m_State = CoroutineState.NotStarted;
}
public override void Compile(ByteCode bc)
{
using (bc.EnterSource(m_Do))
bc.Emit_Enter(m_StackFrame);
m_Block.Compile(bc);
using (bc.EnterSource(m_End))
bc.Emit_Leave(m_StackFrame);
}
public override void Compile(ByteCode bc)
{
if (m_Statements != null)
{
foreach (var s in m_Statements)
{
s.Compile(bc);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Script"/> class.
/// </summary>
/// <param name="coreModules">The core modules to be pre-registered in the default global table.</param>
public Script(CoreModules coreModules)
{
Options = new ScriptOptions(DefaultOptions);
PerformanceStats = new PerformanceStatistics();
Registry = new Table(this);
m_ByteCode = new ByteCode(this);
m_GlobalTable = new Table(this).RegisterCoreModules(coreModules);
m_MainProcessor = new Processor(this, m_GlobalTable, m_ByteCode);
}
public Processor(Script script, Table globalContext, ByteCode byteCode)
{
m_CoroutinesStack = new List<Processor>();
m_Debug = new DebugContext();
m_RootChunk = byteCode;
m_GlobalTable = globalContext;
m_Script = script;
m_State = CoroutineState.Main;
DynValue.NewCoroutine(new Coroutine(this)); // creates an associated coroutine for the main processor
}
public override void Compile(ByteCode bc)
{
using (bc.EnterSource(m_Ref))
{
if (bc.LoopTracker.Loops.Count == 0)
throw new SyntaxErrorException(this.Script, m_Ref, "<break> at line {0} not inside a loop", m_Ref.FromLine);
ILoop loop = bc.LoopTracker.Loops.Peek();
if (loop.IsBoundary())
throw new SyntaxErrorException(this.Script, m_Ref, "<break> at line {0} not inside a loop", m_Ref.FromLine);
loop.CompileBreak(bc);
}
}
public override void Compile(ByteCode bc)
{
using (bc.EnterSource(m_Ref))
{
if (m_Expression != null)
{
m_Expression.Compile(bc);
bc.Emit_Ret(1);
}
else
{
bc.Emit_Ret(0);
}
}
}
public override void Compile(ByteCode bc)
{
bc.PushSourceRef(m_RefFor);
Loop L = new Loop()
{
Scope = m_StackFrame
};
bc.LoopTracker.Loops.Push(L);
m_End.Compile(bc);
bc.Emit_ToNum(3);
m_Step.Compile(bc);
bc.Emit_ToNum(2);
m_Start.Compile(bc);
bc.Emit_ToNum(1);
int start = bc.GetJumpPointForNextInstruction();
var jumpend = bc.Emit_Jump(OpCode.JFor, -1);
bc.Emit_Enter(m_StackFrame);
//bc.Emit_SymStorN(m_VarName);
bc.Emit_Store(m_VarName, 0, 0);
m_InnerBlock.Compile(bc);
bc.PopSourceRef();
bc.PushSourceRef(m_RefEnd);
bc.Emit_Debug("..end");
bc.Emit_Leave(m_StackFrame);
bc.Emit_Incr(1);
bc.Emit_Jump(OpCode.Jump, start);
bc.LoopTracker.Loops.Pop();
int exitpoint = bc.GetJumpPointForNextInstruction();
foreach (Instruction i in L.BreakJumps)
i.NumVal = exitpoint;
jumpend.NumVal = exitpoint;
bc.Emit_Pop(3);
bc.PopSourceRef();
}
public override void Compile(ByteCode bc)
{
var meta = bc.Emit_FuncMeta("<chunk-root>");
var metaip = bc.GetJumpPointForLastInstruction();
bc.Emit_BeginFn(m_StackFrame);
bc.Emit_Args(m_VarArgs);
bc.Emit_Literal(DynValue.NewTable(m_GlobalEnv));
bc.Emit_Store(m_Env, 0, 0);
bc.Emit_Pop();
m_Block.Compile(bc);
bc.Emit_Ret(0);
meta.NumVal = bc.GetJumpPointForLastInstruction() - metaip;
}
public override void Compile(ByteCode bc)
{
m_BaseExp.Compile(bc);
if (m_Name != null)
{
bc.Emit_Index(DynValue.NewString(m_Name), true);
}
else if (m_IndexExp is LiteralExpression)
{
var lit = (LiteralExpression) m_IndexExp;
bc.Emit_Index(lit.Value);
}
else
{
m_IndexExp.Compile(bc);
bc.Emit_Index(isExpList: (m_IndexExp is ExprListExpression));
}
}
public void CompileAssignment(ByteCode bc, int stackofs, int tupleidx)
{
m_BaseExp.Compile(bc);
if (m_Name != null)
{
bc.Emit_IndexSet(stackofs, tupleidx, DynValue.NewString(m_Name), true);
}
else if (m_IndexExp is LiteralExpression)
{
var lit = (LiteralExpression) m_IndexExp;
bc.Emit_IndexSet(stackofs, tupleidx, lit.Value);
}
else
{
m_IndexExp.Compile(bc);
bc.Emit_IndexSet(stackofs, tupleidx, isExpList: (m_IndexExp is ExprListExpression));
}
}
public override void Compile(ByteCode bc)
{
m_Exp.Compile(bc);
switch (m_OpText)
{
case "not":
bc.Emit_Operator(OpCode.Not);
break;
case "#":
bc.Emit_Operator(OpCode.Len);
break;
case "-":
bc.Emit_Operator(OpCode.Neg);
break;
default:
throw new InternalErrorException("Unexpected unary operator '{0}'", m_OpText);
}
}
public override void Compile(ByteCode bc)
{
var endJumps = new List<Instruction>();
Instruction lastIfJmp = null;
foreach (var ifblock in m_Ifs)
{
using (bc.EnterSource(ifblock.Source))
{
if (lastIfJmp != null)
lastIfJmp.NumVal = bc.GetJumpPointForNextInstruction();
ifblock.Exp.Compile(bc);
lastIfJmp = bc.Emit_Jump(OpCode.Jf, -1);
bc.Emit_Enter(ifblock.StackFrame);
ifblock.Block.Compile(bc);
}
using (bc.EnterSource(m_End))
bc.Emit_Leave(ifblock.StackFrame);
endJumps.Add(bc.Emit_Jump(OpCode.Jump, -1));
}
lastIfJmp.NumVal = bc.GetJumpPointForNextInstruction();
if (m_Else != null)
{
using (bc.EnterSource(m_Else.Source))
{
bc.Emit_Enter(m_Else.StackFrame);
m_Else.Block.Compile(bc);
}
using (bc.EnterSource(m_End))
bc.Emit_Leave(m_Else.StackFrame);
}
foreach (var endjmp in endJumps)
endjmp.NumVal = bc.GetJumpPointForNextInstruction();
}
public override void Compile(ByteCode bc)
{
Loop L = new Loop()
{
Scope = m_StackFrame
};
bc.LoopTracker.Loops.Push(L);
bc.PushSourceRef(m_Start);
int start = bc.GetJumpPointForNextInstruction();
m_Condition.Compile(bc);
var jumpend = bc.Emit_Jump(OpCode.Jf, -1);
bc.Emit_Enter(m_StackFrame);
m_Block.Compile(bc);
bc.PopSourceRef();
bc.Emit_Debug("..end");
bc.PushSourceRef(m_End);
bc.Emit_Leave(m_StackFrame);
bc.Emit_Jump(OpCode.Jump, start);
bc.LoopTracker.Loops.Pop();
int exitpoint = bc.GetJumpPointForNextInstruction();
foreach (Instruction i in L.BreakJumps)
i.NumVal = exitpoint;
jumpend.NumVal = exitpoint;
bc.PopSourceRef();
}
public SourceCodeStackGuard(SourceRef sref, ByteCode bc)
{
m_Bc = bc;
m_Bc.PushSourceRef(sref);
}
public override void Compile(ByteCode bc)
{
bc.Emit_NewTable();
foreach (var kvp in m_CtorArgs)
{
kvp.Key.Compile(bc);
kvp.Value.Compile(bc);
bc.Emit_TblInitN();
}
for (var i = 0; i < m_PositionalValues.Count; i++)
{
m_PositionalValues[i].Compile(bc);
bc.Emit_TblInitI(i == m_PositionalValues.Count - 1);
}
}
public override void Compile(ByteCode bc)
{
bc.Emit_Literal(Value);
}
public int CompileBody(ByteCode bc, string friendlyName)
{
string funcName = friendlyName ?? ("<" + this.m_Begin.FormatLocation(bc.Script, true) + ">");
bc.PushSourceRef(m_Begin);
Instruction I = bc.Emit_Jump(OpCode.Jump, -1);
Instruction meta = bc.Emit_Meta(funcName, OpCodeMetadataType.FunctionEntrypoint);
int metaip = bc.GetJumpPointForLastInstruction();
bc.Emit_BeginFn(m_StackFrame);
bc.LoopTracker.Loops.Push(new LoopBoundary());
int entryPoint = bc.GetJumpPointForLastInstruction();
if (m_UsesGlobalEnv)
{
bc.Emit_Load(SymbolRef.Upvalue(WellKnownSymbols.ENV, 0));
bc.Emit_Store(m_Env, 0, 0);
bc.Emit_Pop();
}
if (m_ParamNames.Length > 0)
bc.Emit_Args(m_ParamNames);
m_Statement.Compile(bc);
bc.PopSourceRef();
bc.PushSourceRef(m_End);
bc.Emit_Ret(0);
bc.LoopTracker.Loops.Pop();
I.NumVal = bc.GetJumpPointForNextInstruction();
meta.NumVal = bc.GetJumpPointForLastInstruction() - metaip;
bc.PopSourceRef();
return entryPoint;
}
public override void Compile(ByteCode bc)
{
m_Jump = bc.Emit_Jump(OpCode.Jump, m_LabelAddress);
}
public override void Compile(ByteCode bc)
{
Compile(bc, () => 0, null);
}
public int Compile(ByteCode bc, Func<int> afterDecl, string friendlyName)
{
using (bc.EnterSource(m_Begin))
{
var symbs = m_Closure
//.Select((s, idx) => s.CloneLocalAndSetFrame(m_ClosureFrames[idx]))
.ToArray();
m_ClosureInstruction = bc.Emit_Closure(symbs, bc.GetJumpPointForNextInstruction());
var ops = afterDecl();
m_ClosureInstruction.NumVal += 2 + ops;
}
return CompileBody(bc, friendlyName);
}
public override void Compile(ByteCode bc)
{
//for var_1, ···, var_n in explist do block end
bc.PushSourceRef(m_RefFor);
Loop L = new Loop()
{
Scope = m_StackFrame
};
bc.LoopTracker.Loops.Push(L);
// get iterator tuple
m_RValues.Compile(bc);
// prepares iterator tuple - stack : iterator-tuple
bc.Emit_IterPrep();
// loop start - stack : iterator-tuple
int start = bc.GetJumpPointForNextInstruction();
bc.Emit_Enter(m_StackFrame);
// expand the tuple - stack : iterator-tuple, f, var, s
bc.Emit_ExpTuple(0);
// calls f(s, var) - stack : iterator-tuple, iteration result
bc.Emit_Call(2, "for..in");
// perform assignment of iteration result- stack : iterator-tuple, iteration result
for (int i = 0; i < m_NameExps.Length; i++)
m_NameExps[i].CompileAssignment(bc, 0, i);
// pops - stack : iterator-tuple
bc.Emit_Pop();
// repushes the main iterator var - stack : iterator-tuple, main-iterator-var
bc.Emit_Load(m_Names[0]);
// updates the iterator tuple - stack : iterator-tuple, main-iterator-var
bc.Emit_IterUpd();
// checks head, jumps if nil - stack : iterator-tuple, main-iterator-var
var endjump = bc.Emit_Jump(OpCode.JNil, -1);
// executes the stuff - stack : iterator-tuple
m_Block.Compile(bc);
bc.PopSourceRef();
bc.PushSourceRef(m_RefEnd);
// loop back again - stack : iterator-tuple
bc.Emit_Leave(m_StackFrame);
bc.Emit_Jump(OpCode.Jump, start);
bc.LoopTracker.Loops.Pop();
int exitpointLoopExit = bc.GetJumpPointForNextInstruction();
bc.Emit_Leave(m_StackFrame);
int exitpointBreaks = bc.GetJumpPointForNextInstruction();
bc.Emit_Pop();
foreach (Instruction i in L.BreakJumps)
i.NumVal = exitpointBreaks;
endjump.NumVal = exitpointLoopExit;
bc.PopSourceRef();
}
public int CompileBody(ByteCode bc, string friendlyName)
{
var funcName = friendlyName ?? ("<" + m_Begin.FormatLocation(bc.Script, true) + ">");
bc.PushSourceRef(m_Begin);
var I = bc.Emit_Jump(OpCode.Jump, -1);
var meta = bc.Emit_FuncMeta(funcName);
var metaip = bc.GetJumpPointForLastInstruction();
bc.Emit_BeginFn(m_StackFrame);
bc.LoopTracker.Loops.Push(new LoopBoundary());
var entryPoint = bc.GetJumpPointForLastInstruction();
if (m_GlobalEnv != null)
{
bc.Emit_Literal(DynValue.NewTable(m_GlobalEnv));
bc.Emit_Store(m_Env, 0, 0);
bc.Emit_Pop();
}
if (m_ParamNames.Length > 0)
bc.Emit_Args(m_ParamNames);
m_Statement.Compile(bc);
bc.PopSourceRef();
bc.PushSourceRef(m_End);
bc.Emit_Ret(0);
bc.LoopTracker.Loops.Pop();
I.NumVal = bc.GetJumpPointForNextInstruction();
meta.NumVal = bc.GetJumpPointForLastInstruction() - metaip;
bc.PopSourceRef();
return entryPoint;
}
public SourceCodeStackGuard(SourceRef sref, ByteCode bc)
{
m_Bc = bc;
m_Bc.PushSourceRef(sref);
}
