public void execute(Stack data, Heap heap)
{
if (m_objectBuilder != null)
{
int addr = data.popInt();
m_objectBuilder.setValues(heap.readString(addr));
}
}
public void execute(Stack data, Heap heap)
{
if (m_macroService != null && m_resourceService != null)
{
int addr = data.popInt();
XnaScrapId macro_id = new XnaScrapId(heap.readString(addr));//(data.popString());
addr = data.popInt();
XnaScrapId scriptName = new XnaScrapId(heap.readString(addr));//(data.popString());
if (!m_macroService.RegisteredMacros.Keys.Contains(macro_id))
{
if (m_resourceService.Scripts.Keys.Contains(scriptName.ToString()))
{
IScript script = m_resourceService.Scripts[scriptName.ToString()];
ScriptedMacro newMacro = new ScriptedMacro(null);
newMacro.Script = script;
newMacro.Name = macro_id.ToString();
m_macroService.RegisteredMacros.Add(scriptName, newMacro);
}
}
else
{
throw new InvalidOperationException("Error Macro with Id \"" + macro_id + "\" already registered.");
}
}
}
public void end(Stack data, Heap heap)
{
}
public void execute(Stack data, Heap heap)
{
String id = XnaScrapId.CreateId().ToString();
int addr = heap.allocString(id);
data.push(addr);
}
public void execute(Stack data, Heap heap)
{
//throw new Exception("Cannot call Main::execute in a compiled script");
}
public void execute(Stack data, Heap heap)
{
if (m_objectBuilder != null)
{
int addr = data.popInt();
String s = heap.readString(addr);//data.popString();
m_objectBuilder.beginParameter(s);
}
}
public void execute(Stack data, Heap heap)
{
if (m_macroService != null)
{
int addr = data.popInt();
XnaScrapId id = new XnaScrapId(heap.readString(addr));//(data.popString());
if (m_macroService.RegisteredMacros.Keys.Contains(id))
{
IMacro macro = m_macroService.RegisteredMacros[id];
// get number of arguments
int numParameter = data.popInt();
for (int i = 0; i < numParameter; ++i)
{
addr = data.popInt();
String name = heap.readString(addr);//data.popString();
addr = data.popInt();
String value = heap.readString(addr);//data.popString();
macro.setParameter(name,value);
}
macro.execute();
}
}
}
public void execute(Stack data, Heap heap)
{
if (m_objectBuilder != null)
{
int addr = data.popInt();
XnaScrapId id = new XnaScrapId(heap.readString(addr));//(data.popString());
m_objectBuilder.beginGameObject(id);
}
}
public void end(Stack data, Heap heap)
{
m_objectBuilder.endParameter();
}
public void end(Stack data, Heap heap)
{
m_objectBuilder.endElement();
}
public void end(Stack data, Heap heap)
{
m_objectBuilder.endGameObject();
}
public static String readStringFromHeap(Stack data, Heap heap)
{
// get address
int addr = data.popInt();
int ptr = data.readInt((int)data.Position + addr * sizeof(int));
return heap.readString(ptr);
}
/// <summary>
/// Executes a subroutine. All parameters must be written to the heap before execution.
/// Afterwards the addresses of the parameters have to be stored in the stack (realtive to stackpointer).
/// Mind this if you want to execute a script with external parameters.
/// </summary>
/// <param name="programCode">The script's code.</param>
/// <param name="data">The data stack of the current script execution.</param>
public void executeSub(MemoryStream programCode, int entryPoint, Stack data, Heap heap)
{
m_eip = entryPoint;
m_ebp = (int)data.Position; // base pointer
readNextOpCode(programCode);
while (m_opcode != OpCode.HALT)
{
//eip = (int)programCode.Position;
switch (m_opcode)
{
case OpCode.POP_INT:
{
break;
}
case OpCode.POP_FLOAT:
{
break;
}
case OpCode.POP_STRING:
{
break;
}
case OpCode.PUSH_INT:
{
data.push(readNextProgramInt(programCode));
break;
}
case OpCode.PUSH_FLOAT:
{
data.push(readNextProgramFloat(programCode));
break;
}
case OpCode.PUSH_STRING:
{
data.push(readNextProgramString(programCode));
break;
}
case OpCode.PUSH_ADDR:
{
int addr = readNextProgramInt(programCode); // address relative to ebp
// read heap address from stack
int heapAddr = data.readInt(m_ebp + addr);
data.push(heapAddr);
break;
}
case OpCode.PUSH_EBP:
{
data.push(m_ebp);
break;
}
case OpCode.ADD_INT:
{
int val1 = data.popInt();
int val2 = data.popInt();
data.push(val1 + val2);
break;
}
case OpCode.SUB_INT:
{
int val1 = data.popInt();
int val2 = data.popInt();
data.push(val1 - val2);
break;
}
case OpCode.READ_INT:
{
int addr = data.popInt();
data.push(data.readInt(addr));
break;
}
case OpCode.WRITE_INT:
{
// read address
int addr = data.popInt();
// read value
int value = data.popInt();
// write
data.writeInt(addr,value);
break;
}
case OpCode.READ_FLOAT:
{
int addr = data.popInt();
data.push(data.readFlt(addr));
break;
}
case OpCode.WRITE_FLOAT:
{
// read address
int addr = data.popInt();
// read value
float value = data.popInt();
// write
data.writeFlt(addr, value);
break;
}
case OpCode.ALLOC_STRING_ON_HEAP:
{
String s = data.popString();
int address = heap.allocString(s);
data.push(address);
break;
}
case OpCode.READ_STRING_FROM_HEAP:
{
//int ptr = data.readInt((int)data.Position + addr * sizeof(int));
int ptr = data.popInt();
String s = heap.readString(ptr);
data.push(s);
break;
}
case OpCode.BEGIN_BLOCK:
{
// save base pointer
m_ebp = (int)data.Position;
data.push(m_ebp);
break;
}
case OpCode.CALL_FUNCTION:
{
// get function address
int func_addr = data.popInt();
// save instruction pointer
data.push(m_eip);
m_eip = func_addr;
programCode.Position = m_eip;
break;
}
case OpCode.RETURN:
{
m_eip = data.popInt(); // restore eip
programCode.Position = m_eip;
break;
}
case OpCode.END_BLOCK:
{
m_ebp = data.popInt(); // restore ebp
data.set(m_ebp);
break;
}
// Built in function
case OpCode.NATIVE_CALL:
{
int f = readNextProgramInt(programCode);
if (f > 0)
{
m_registeredFunctions.RegisteredFunctionAddresses[f].execute(data,heap);
}
else if (f < 0)
{
m_registeredFunctions.RegisteredFunctionAddresses[-1*f].end(data,heap);
}
break;
}
}
readNextOpCode(programCode);
}
}
/// <summary>
/// Executes a script from the beginging.
/// </summary>
/// <param name="script">The script tu execute.</param>
/// <param name="data">Stack with the addresses of parameters on the heap. These addresses point to the beginning of the parameters in the heap Stack.</param>
/// <param name="heap">Stack containing the parameter.</param>
public void execute(XmlScriptCompiled script, Stack data, Heap heap)
{
script.reset();
executeSub(script.ProgramCode, script.EntryPoint, data, heap);
}
/// <summary>
/// Execute a script with the given parameters.
/// </summary>
/// <param name="script"></param>
/// <param name="parameters"></param>
public void execute(IScript script)
{
if (!(script is XmlScriptCompiled))
{
throw new InvalidOperationException("Wrong script type!");
}
XmlScriptCompiled xmlScript = script as XmlScriptCompiled;
Heap heap = new Heap();
//// push eip
//parameters.push(0);
//// push base pointer
//parameters.push(0);
//execute(script, parameters, heap);
Stack stack = new Stack();
// go through intern parametersequencer and alloc strings
if (script.ParameterSequence.Root != null)
{
//stack = new Stack(script.ParameterSequence.getMemStream(false));
foreach (Parameter p in script.ParameterSequence.Root.Parameters.Values)
{
// for now we only allow strings
if (p is StringParameter)
{
StringParameter stringParam = p as StringParameter;
stack.push(heap.allocString(stringParam.Value));
}
else
{
throw new WrongParameterTypeException("Only StringParameters are allowed when initialising a script.", typeof(StringParameter));
}
}
}
// push base pointer
stack.push(0);
// push instruction pointer
stack.push(0);
execute(xmlScript, stack, heap);
}
// URGENT: Use Parameter Sequencer
/// <summary>
/// Execute a script with the given parameters.
/// </summary>
/// <param name="script"></param>
/// <param name="parameters"></param>
public void execute(XmlScriptCompiled script, String[] parameters)
{
Stack data = new Stack();
Heap heap = new Heap();
// parameters in reverse order
for(int i = parameters.Length-1; i >= 0; --i)
{
int a = heap.allocString(parameters[i]);
data.push(a);
}
// push eip
data.push(0);
// push base pointer
data.push(0);
execute(script, data, heap);
}
