winamp/Src/Wasabi/api/script/vcpu.cpp

#include <precomp.h>
#include <wasabicfg.h>
#include <api/skin/widgets/mb/scriptbrowser.h>
#include <api/script/scriptmgr.h>
#include <api/script/script.h>
#include "vcpu.h"
#include "opcodes.h"
#include <api/wndmgr/container.h>
#include <api/wndmgr/msgbox.h>
#include <api/script/objecttable.h>
#include <api/syscb/callbacks/consolecb.h>
#include "../nu/AutoWide.h"

ScriptObjectManager *VCPU::scriptManager = NULL;

void VCPU::shutdown()
{
  foreach(globalDlfList)
    FREE(globalDlfList.getfor()->functionName);
    delete globalDlfList.getfor();
  endfor
  globalDlfList.removeAll();
  atoms.deleteAll();
}

// -------------------------------------------------------------
void VCPU::push(VCPUscriptVar v) {
  CpuStack.push(v);
  VSP++;
}

// -------------------------------------------------------------
void VCPU::push(scriptVar v) {
  VCPUscriptVar _v;
  _v.v = v;
  CpuStack.push(_v);
  VSP++;
}

void VCPU::RemoveOldScripts()
{
	while (scriptsToRemove.getNumItems())
	{
		int id = scriptsToRemove.getFirst();
		VCPU::removeScript(id);
		scriptsToRemove.delByPos(0);
	}
}

// -------------------------------------------------------------
VCPUscriptVar VCPU::pop() {
  if (VSP <= 0) {
    Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_POPEMPTYSTACK);
    VCPUscriptVar v;
    MEMSET(&v, 0, sizeof(v));
    return v;
//    ASSERT(0);
  }
  VCPUscriptVar v;
  CpuStack.pop(&v);
  VSP--;
	if (VSP == 0)
		VCPU::RemoveOldScripts(); // benski> TODO: dunno if this is the best place for this
  return v;
}

// -------------------------------------------------------------
VCPUscriptVar VCPU::peekAt(int n) {
  if (VSP <= n) {
    Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_INVALIDPEEKSTACK);
    VCPUscriptVar v;
    MEMSET(&v, 0, sizeof(v));
    return v;
//    ASSERT(0);
  }
  VCPUscriptVar v={0,{0},0};
  CpuStack.peekAt(&v, n);
  return v;
}

// -------------------------------------------------------------
int VCPU::assignNewScriptId() {
  return numScripts++;
}

// -------------------------------------------------------------
int VCPU::oldClassToClassId(int id) {
  if (id < SCRIPT_OBJECT) return id;
  if (id >= 0x10000) return id;
  switch (id) {
    case 7 : return ObjectTable::getClassFromName(L"Object");
    case 8 : return ObjectTable::getClassFromName(L"SystemObject");
    case 9 : return ObjectTable::getClassFromName(L"Container");
    case 10: return ObjectTable::getClassFromName(L"Layout");
    case 11: return ObjectTable::getClassFromName(L"Button");
    case 12: return ObjectTable::getClassFromName(L"Slider");
    case 13: return ObjectTable::getClassFromName(L"Text");
    case 14: return ObjectTable::getClassFromName(L"Image");
    case 15: return ObjectTable::getClassFromName(L"Anim");
    case 16: return ObjectTable::getClassFromName(L"Vis");
    case 17: return ObjectTable::getClassFromName(L"Component");
    case 18: return ObjectTable::getClassFromName(L"ToggleButton");
    case 19: return ObjectTable::getClassFromName(L"Timer");
    case 20: return ObjectTable::getClassFromName(L"Layer");
    case 21: return ObjectTable::getClassFromName(L"GuiObject");
    case 22: return ObjectTable::getClassFromName(L"AnimatedLayer");
    case 23: return ObjectTable::getClassFromName(L"Browser");
    case 24: return ObjectTable::getClassFromName(L"Edit");
    case 25: return ObjectTable::getClassFromName(L"Map");
    case 26: return ObjectTable::getClassFromName(L"Popup");
    case 27: return ObjectTable::getClassFromName(L"Title");
    case 28: return ObjectTable::getClassFromName(L"ComponentBucket");
    case 29: return ObjectTable::getClassFromName(L"Status");
    case 30: return ObjectTable::getClassFromName(L"Region");
    case 31: return ObjectTable::getClassFromName(L"Wac");
    case 32: return ObjectTable::getClassFromName(L"List");
    case 33: return ObjectTable::getClassFromName(L"SBitList");
    case 34: return ObjectTable::getClassFromName(L"SEqVis");
    default: Script::guruMeditation(NULL, GURU_INVALIDOLDID, L"xlat error", id);
      break;
  }
  return SCRIPT_INT; // heh =)
}


// -------------------------------------------------------------
int VCPU::addScript(void *mem, int memsize, int id) {

  int i,j;
  int translateobjects = 0;

  char *p = (char *)mem;

  int hdr=0;
  if (!MEMCMP(p, "FG\x03\x04\x14\00\00\00\00", 8))
    hdr=1;
  else if (!MEMCMP(p, "FG\x03\x04\x15\00\00\00\00", 8))
    hdr=2;
  else if (!MEMCMP(p, "FG\x03\x04\x16\00\00\00\00", 8))
    hdr=3;
  else if (!MEMCMP(p, "FG\x03\x04\x17\00\00\00\00", 8))
    hdr=4;     
  else if (!MEMCMP(p, "FG\x03\x04", 4)) {
    if (*(p+4) > 0x17) 
      hdr = -1;
  }

  switch (hdr) {
    case -1:
      Script::guruMeditation(SOM::getSystemObjectByScriptId(id), GURU_FUTUREFORMAT, L"NEED LATEST VERSION");
      return -1;
    case 0:
      Script::guruMeditation(SOM::getSystemObjectByScriptId(id), GURU_INVALIDHEADER);
      return -1;
    case 1:
      Script::guruMeditation(SOM::getSystemObjectByScriptId(id), GURU_OLDFORMAT, L"DEPRECATED BINARY");
      return -1;
    case 2:
      translateobjects=1;
      break;
    case 3:
    case 4:
      break;
  }

  SOM::getSystemObjectByScriptId(id)->setIsOldFormat(translateobjects);

  p+=8;

  TList<int> *typetable = SOM::getSystemObjectByScriptId(id)->getTypesList();
  typetable->removeAll();

  if (!translateobjects) {
  
    int nGuids = *(int *)p;
    p+=sizeof(int);

    for (int z=0;z<nGuids;z++) {
      GUID g;
      MEMCPY(&g, p, sizeof(GUID));
      p+=sizeof(GUID);
      char zz[256] = {0};
      nsGUID::toChar(g, zz);
      int t = ObjectTable::getClassFromGuid(g);
      if (t == -1) { 
        DebugStringW(L"maki class entry %d not found : %s\n", z, zz);
//        __asm int 3; 
      }
      typetable->addItem(t);
    }
  }

  // -------------------------------------------------------------
  // Load DLF Table

  int DLFEntryBase = DLFentryTable.getNumItems();

  int nDLFentries = *(int *)p;
  p+=sizeof(int);

  for (i=0;i<nDLFentries;i++) {

    int basetype = *(int *)p;
    int pt = basetype;
    int type = basetype;
    p+=sizeof(int);

    if (translateobjects) {
      basetype = oldClassToClassId(basetype);
    } else
      if (basetype >= CLASS_ID_BASE && basetype < 0x10000)
        basetype = typetable->enumItem(basetype - CLASS_ID_BASE);

    if (basetype == -1) {
//CUT!!!! so annoying      Std::messageBox("Error while loading a script, a component is missing", "Oops", 0);
      DebugStringW(L"Tried to link DLF %d (class entry %d) but the class isn't here\n", i, pt - CLASS_ID_BASE);
      //return -1;
    }

    type = basetype;

    uint16_t stringLen = *(uint16_t *)p;
    p+=sizeof(uint16_t);
    char functionName[65536+1] = {0};
    MEMCPY(functionName, p, stringLen);
    functionName[stringLen]=0;
    p+=stringLen;

    // check if entry seems valid

    if (!*functionName) {
      Script::guruMeditation(SOM::getSystemObjectByScriptId(id), GURU_INVALIDFUNCINDLF);
//      api->messageBox("Invalid function name in DLF table", "Script Error", MSGBOX_OK, NULL, NULL);
      return -1;
    }

    // ok, register this function
    VCPUdlfEntry *e = new VCPUdlfEntry;
    e->basetype = type;
#ifdef _WIN32
				int size = MultiByteToWideChar(CP_UTF8, 0, functionName, -1, 0,0);
		if (size)
		{
			wchar_t *wide = (wchar_t *)MALLOC(size*sizeof(wchar_t));
			MultiByteToWideChar(CP_UTF8, 0, functionName, -1, wide,size);
			e->functionName = wide;
		}
		else
			e->functionName = 0;
#else
    e->functionName = WCSDUP(AutoWide(functionName));
#warning port me
#endif
    e->scriptId = id;
    // insert safe values
    e->nparams = -1;
    e->DLFid = -1;
    e->ptr = NULL;
    DLFentryTable.addItem(e);

    setupDLF(e, DLFEntryBase);

  }

  // -------------------------------------------------------------
  // Load VAR Table

  int variableBase = variablesTable.getNumItems();

  int nVariables = *(int *)p;
  p+=sizeof(int);

  for (i=0;i<nVariables;i++) {
    scriptVar e;
    MEMCPY(&e, p, sizeof(scriptVar));
    p+=sizeof(scriptVar);

    VCPUscriptVar *v = new VCPUscriptVar;
    v->isaclass = 0;

    if (e.type >= 0x10000) {
      int type = e.type;
      int id;

      do {
        id = type - 0x10000;
        VCPUscriptVar *v = variablesTable.enumItem(id+variableBase);
        v->isaclass = 1;
        type = v->v.type;
      } while (type >= 0x10000);
      
    }

    if (translateobjects) {
      e.type = oldClassToClassId(e.type);
    } else
      if (e.type >= CLASS_ID_BASE && e.type < 0x10000)
        e.type = typetable->enumItem(e.type - CLASS_ID_BASE);

    v->scriptId = id;
    v->varId = i;
    v->transcient = (*p++ == 0);
    if (hdr >= 4)
      v->isstatic = *p++;
    else
      v->isstatic = 0;

    if (hdr < 4) {
      // Autoassign system variables
      if (e.type == ObjectTable::getClassFromName(L"SystemObject")) {
        SystemObject *so = SOM::getSystemObjectByScriptId(id);
        if (so) e.data.odata = so->getScriptObject(); else e.data.odata = NULL;
      }
    } else {
      if (v->isstatic && e.type == ObjectTable::getClassFromName(L"SystemObject")) {
        SystemObject *so = SOM::getSystemObjectByScriptId(id);
        if (so) e.data.odata = so->getScriptObject(); else e.data.odata = NULL;
        v->isstatic = 0; // disable deletion
      } else if (v->isstatic) {
        // Autoassign class variables
        e.data.odata = ObjectTable::instantiate(e.type);
        if (e.data.odata)
          e.data.odata->vcpu_setScriptId(VSD);
      }
    }

    if (e.type == SCRIPT_STRING) 
		{
			wchar_t *emptyString = WMALLOC(1);
			emptyString[0]=0;
      e.data.sdata = emptyString;
    }

    if (e.type == SCRIPT_DOUBLE) 
      e.data.ddata = e.data.fdata;

    v->v = e;
    variablesTable.addItem(v);
  }

  // -------------------------------------------------------------
  // Load Strings into string vars

  int nStrings = *(int *)p;
  p+=sizeof(int);

  j=0;
  //CUT: int count=0;

	char string_buf[65536+1] = {0};
  for (i=0;i<nStrings;i++) 
	{
    int attach_id = *(int *)p;
    p+=4;
    uint16_t stringLen = *(uint16_t *)p;
    p+=2;
    //char *string;
    //string = (char *)MALLOC(stringLen+1);
    MEMCPY(string_buf, p, stringLen);
    string_buf[stringLen]=0;
    p+=stringLen;

    // find next variable in this script that needs a string attached, and attach it
    VCPUscriptVar *v = variablesTable.enumItem(attach_id+variableBase);
		if (!v)
		{
			Script::guruMeditation(SOM::getSystemObjectByScriptId(id), GURU_EXCEPTION, L"Invalid String ID");
      return -1;
		}
    FREE((wchar_t *)(v->v.data.sdata));
		// strings are stored in UTF-8, but we're using UTF-16 here
#ifdef _WIN32
		int size = MultiByteToWideChar(CP_UTF8, 0, string_buf, -1, 0,0);
		if (size)
		{
			wchar_t *wide = (wchar_t *)MALLOC(size*sizeof(wchar_t));
			MultiByteToWideChar(CP_UTF8, 0, string_buf, -1, wide,size);
			v->v.data.sdata = wide;
		}
		else
			v->v.data.sdata = 0;
		
#else
#warning port me 
		// TODO: benski> change to do one malloc
    v->v.data.sdata = WCSDUP(AutoWide(string_buf)); 
#endif
		//FREE(string);

	}


  // -------------------------------------------------------------
  // Load Events into table

  int nEvents = *(int *)p;
  p+=sizeof(int);

  for (i=0;i<nEvents;i++) {

    int varId = *(int *)p;
    p+=sizeof(int);
    int DLFentry = *(int *)p;
    p+=sizeof(int);
    int pointer = *(int *)p;
    p+=sizeof(int);

    // check if this event seems valid
    if (DLFentry >= nDLFentries || DLFentry < 0) {
//      api->messageBox("Invalid event DLF descriptor", "Script Error", MSGBOX_OK, NULL, NULL);
      Script::guruMeditation(SOM::getSystemObjectByScriptId(id), GURU_INVALIDEVENTDLF);
      return -1;
    }

    if (pointer < 0) {
//      api->messageBox("Invalid event address", "Script Error", MSGBOX_OK, NULL, NULL);
      Script::guruMeditation(SOM::getSystemObjectByScriptId(id), GURU_INVALIDEVENTADDR);
      return -1;
    }

    if (varId < 0 || varId >= nVariables) {
//      api->messageBox("Invalid event variable", "Script Error", MSGBOX_OK, NULL, NULL);
      Script::guruMeditation(SOM::getSystemObjectByScriptId(id), GURU_INVALIDEVENTVAR);
      return -1;
    }

    // insert event into table

    VCPUeventEntry *e = new VCPUeventEntry;
    //e->DLFentry = DLFentry + DLFEntryBase;
    e->DLFid = DLFentryTable.enumItem(DLFEntryBase+DLFentry)->DLFid;
    e->pointer = pointer;
    e->scriptId = id;
    e->varId = varId;

    eventsTable.addItem(e);
  }

  // -------------------------------------------------------------
  // Load Code block into code table

  int codeSize = *(int *)p;
  p+=sizeof(int);
  VCPUcodeBlock *c = new VCPUcodeBlock;
  c->codeBlock = p;
  c->dlfBase = DLFEntryBase;
  c->varBase = variableBase;
  c->scriptId = id;
  c->size = codeSize;

  codeTable.addItem(c);

  SystemObject *so = SOM::getSystemObjectByScriptId(id);
  if (so) {
    ScriptObject *sso = so->getScriptObject();
    if (sso)
      sso->vcpu_addAssignedVariable(0, id);
  }

  cacheCount++;

  c->debugsymbols = c->codeBlock+codeSize;
  c->debugsize = memsize - (c->debugsymbols-(char *)mem);

  //WASABI_API_MAKIDEBUG->debugger_createJITD(id); // fucko !!
 
  return id;
}


// -------------------------------------------------------------
int VCPU::varBase(int scriptId) {
  static int lasti=-1;;
  static int lastb=0;
  static int lastid=0;
  if (lastid == scriptId && lasti>=0 && lasti < codeTable.getNumItems()) {
    if (lastid == codeTable.enumItem(lasti)->scriptId) 
      return lastb;
  }
  for (int i=0;i<codeTable.getNumItems();i++ ){
    if (codeTable.enumItem(i)->scriptId == scriptId) {
      lasti = i;
      lastid = scriptId;
      lastb = codeTable.enumItem(i)->varBase;
      return lastb;
    }
  }
  Script::guruMeditation(SOM::getSystemObjectByScriptId(scriptId), GURU_INVALIDSCRIPTID);
  ASSERT(0);
  return 0;
}

// -------------------------------------------------------------
int VCPU::nVars(int scriptId) {
  for (int i=0;i<codeTable.getNumItems();i++ ){
    if (codeTable.enumItem(i)->scriptId == scriptId) {
      if (codeTable.getNumItems() == i+1)
        return variablesTable.getNumItems() - codeTable.enumItem(i)->varBase;
      return codeTable.enumItem(i+1)->varBase - codeTable.enumItem(i)->varBase;
    }
  }
  Script::guruMeditation(SOM::getSystemObjectByScriptId(scriptId), GURU_INVALIDSCRIPTID);
  ASSERT(0);
  return 0;
}

// -------------------------------------------------------------
int VCPU::dlfBase(int scriptId) {
  for (int i=0;i<codeTable.getNumItems();i++ ){
    if (codeTable.enumItem(i)->scriptId == scriptId)
      return codeTable.enumItem(i)->dlfBase;
  }
  Script::guruMeditation(SOM::getSystemObjectByScriptId(scriptId), GURU_INVALIDSCRIPTID);
  ASSERT(0);
  return 0;                                        
}

// -------------------------------------------------------------
void VCPU::removeScript(int id) 
{
//  ASSERTPR(VCPU::VSP==0, "Can't unload script while in script");
	if (VCPU::VSP != 0)
	{
		scriptsToRemove.addItem(id);
		return;
	}

  SystemObject *s = SOM::getSystemObjectByScriptId(id);
	if (s)
	{
		s->onUnload();
		delete s;
	}

  PtrList<ScriptObject> *l = SystemObject::getAllScriptObjects();
  int i;
  for (i=0;i<l->getNumItems();i++) {
    ScriptObject *o = l->enumItem(i);
    o->vcpu_delMembers(id);
  }

  int dlfdeleted=0;
  int vardeleted=0;

  for (i=0;i<DLFentryTable.getNumItems();i++) {
    if (DLFentryTable.enumItem(i)->scriptId == id) {
      delrefDLF(DLFentryTable.enumItem(i));
      if (DLFentryTable.enumItem(i)->functionName)
        FREE(DLFentryTable.enumItem(i)->functionName);
      delete DLFentryTable.enumItem(i);
      DLFentryTable.delByPos(i);
      dlfdeleted++;
      i--;
    }
  }

  for (i=0;i<eventsTable.getNumItems();i++) {
    if (eventsTable.enumItem(i)->scriptId == id) {
      delete eventsTable.enumItem(i);
      eventsTable.delByPos(i);
      i--;
    }
  }

  for (i=0;i<variablesTable.getNumItems();i++) {
    if (variablesTable.enumItem(i)->scriptId == id) {
      VCPUscriptVar *v = variablesTable.enumItem(i);
      if (v->isstatic && v->v.type) {
        ObjectTable::destroy(v->v.data.odata);
      }
      if (v->v.type == SCRIPT_STRING)
        if (v->v.data.sdata)
          FREE((wchar_t *)v->v.data.sdata);
      delete v;
      variablesTable.delByPos(i);
      vardeleted++;
      i--;
    }
  }

  for (i=0;i<codeTable.getNumItems();i++) {
    if (codeTable.enumItem(i)->scriptId == id) {
      VCPUcodeBlock *b = codeTable.enumItem(i);
      delete b;
      codeTable.removeByPos(i);
      for (;i<codeTable.getNumItems();i++) {
        codeTable.enumItem(i)->dlfBase-=dlfdeleted;
        codeTable.enumItem(i)->varBase-=vardeleted;
      }
    }
  }


  cacheCount++;
}

// -------------------------------------------------------------
// Find next matching object, starting from start
int VCPU::findObject(ScriptObject *o, int start, int dlfid, int vcpuid) {
/*  int stop;
  if (vcpuid != -1) {
  int b = varBase(vcpuid);
    if (start < b)
      start = b;
    stop = b + nVars(vcpuid);
  } else {
    stop = variablesTable.getNumItems();
    if (start < 0) 
      start = 0;
  }*/

/*  while (start < stop) {
    VCPUscriptVar *v = variablesTable.enumItem(start);
    if (v->v.data.odata == o && !v->transcient && (vcpuid == -1 || v->scriptId == vcpuid))
      return start;
    start++;
  }*/
  return -1;
}



// -------------------------------------------------------------
// Assign DLF functionId to class exported functions, starting from the last non initialized DLF
void VCPU::setupDLF(VCPUdlfEntry *e, int dlfEntryBase) {
  if (ObjectTable::addrefDLF(e, highestDLFId)) {
    newDlf();
  }

}

int VCPU::newDlf() {
  return highestDLFId++;
}

void VCPU::resetDlf() {
  highestDLFId = 0;
}

void VCPU::registerGlobalDlf(VCPUdlfEntry *e, int dlf) {
  ASSERT(dlf == globalDlfList.getNumItems());
  VCPUdlfEntry *_e = new VCPUdlfEntry;
  MEMCPY(_e, e, sizeof(VCPUdlfEntry));
  _e->functionName = WCSDUP(e->functionName);
  globalDlfList.addItem(_e);
}

void VCPU::delrefDLF(VCPUdlfEntry *e) {
  ObjectTable::delrefDLF(e);
}

// -------------------------------------------------------------

TList<VCPUscriptVar> VCPU::plist;

// -------------------------------------------------------------
int VCPU::runEvent(VCPUeventEntry *e, int np, int pbase) {

#ifdef WASABI_COMPILE_MAKIDEBUG
  /*if (WASABI_API_MAKIDEBUG && WASABI_API_MAKIDEBUG->debugger_isActive()) {
    if (WASABI_API_MAKIDEBUG->debugger_filterEvent(e->scriptId, e->DLFid)) {
      DebugString("Skipping event\n");
      scriptVar v;
      v.type = SCRIPT_INT;
      v.data.idata = 0;
      VCPU::push(v);
      return 1;
    }
  }*/
#endif

  for (int z=0;z<np;z++) {
    VCPU::push(plist[z+pbase]);
  }

  runCode(e->scriptId, e->pointer, np);

#ifdef WASABI_COMPILE_MAKIDEBUG
/*  if (WASABI_API_MAKIDEBUG && WASABI_API_MAKIDEBUG->debugger_isActive()) 
    WASABI_API_MAKIDEBUG->debugger_eventComplete();*/
#endif

  return 1;
}

// This is the function that actually executes the event. In the future, it will sequencially parse all loaded scripts in reversed load order and stop
// either at the end of the chain OR as soon as one of the event used "complete;" in its code

// -------------------------------------------------------------
scriptVar VCPU::executeEvent(scriptVar v, int functionId, int np, int vcpuid) {

  VCPUscriptVar retvar={0,{0},0};
  int pbase = plist.getNumItems();

  int varId=0;

  complete = 0;

  for (int z=0;z<np;z++) {
    VCPUscriptVar vcpuv = VCPU::pop();
    plist.addItem(vcpuv);
  }

  // find all variables containing this object, and run their event if it's traped

  int next = 0;

  while (!complete) {
    VCPUscriptVar *vclass=NULL;
    int inheritedevent=0;
//    varId = VCPU::findObject(v.data.odata, varId, vcpuid);
    int event;
	  ASSERT(v.data.odata != NULL);
    varId = ((ScriptObject *)v.data.odata)->vcpu_getAssignedVariable(next, vcpuid, functionId, &next, &event, &inheritedevent);

    if (varId < 0) break;

    VCPUscriptVar *vc = variablesTable.enumItem(varId);
    ScriptObject *thisobject = (ScriptObject *)v.data.odata;

    VCPUeventEntry *e = eventsTable.enumItem(event);

    int r_varId = varId;

    if (!vc->isaclass && !inheritedevent) {
      if (e && runEvent(e, np, pbase))
        retvar = pop();
      if (getComplete())
        break;
    }

    while (vc->isaclass) {
      ASSERT(r_varId < variablesTable.getNumItems());
      vclass = variablesTable.enumItem(r_varId);
      vclass->v.data.odata = thisobject;

      if (runEvent(e, np, pbase))
        retvar = pop();

      if (getComplete())
        break;

      vc = vclass;
      if (vc->varId < 0x10000) break;
      r_varId = varBase(vc->scriptId) + vc->v.type - 0x10000;
    }

    if (getComplete())
      break;

    varId++;
  }

  for (int i=0;i<np;i++)
    plist.delByPos(pbase);

  return retvar.v;
}

void VCPU::callDlfCommand(void *ptr, int nargs, maki_cmd *cmd) {
  try {

    scriptVar v={0,0};
    switch (nargs) {
      case 0:
        ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *))ptr)(cmd, -1, NULL);
        break;
      case 1:
        ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar))ptr)(cmd, -1, NULL, v);
        break;
      case 2:
        ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar))ptr)(cmd, -1, NULL, v, v);
        break;
      case 3:
        ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar))ptr)(cmd, -1, NULL, v, v, v);
        break;
      case 4:
        ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar))ptr)(cmd, -1, NULL, v, v, v, v);
        break;
      case 5:
        ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar))ptr)(cmd, -1, NULL, v, v, v, v, v);
        break;
      case 6:
        ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar))ptr)(cmd, -1, NULL, v, v, v, v, v, v);
        break;
      case 7:
        ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar))ptr)(cmd, -1, NULL, v, v, v, v, v, v, v);
        break;
      case 8:
        ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar))ptr)(cmd, -1, NULL, v, v, v, v, v, v, v, v);
        break;
      case 9:
        ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar))ptr)(cmd, -1, NULL, v, v, v, v, v, v, v, v, v);
        break;
      case 10:
        ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar))ptr)(cmd, -1, NULL, v, v, v, v, v, v, v, v, v, v);
        break;
    }
  } 

  catch(...)
  {
    Script::guruMeditation(SOM::getSystemObjectByScriptId(VCPU::VSD), GURU_EXCEPTION, L"Script Fatal Error", -1);
    #ifdef ON_FATAL_SKIN_ERROR
    ON_FATAL_SKIN_ERROR
    #endif
  }

}

int VCPU::getDLFFromPointer(void *ptr, int nargs) {
  maki_cmd cmd={MAKI_CMD_GETDLF, -1};
  callDlfCommand(ptr, nargs, &cmd);
  return cmd.id;
}

// This sends the DLFId to the function itself.
void VCPU::setupDLFFunction(void *ptr, int nargs, int DLFid, VCPUdlfEntry *e) {
  registerGlobalDlf(e, DLFid);
  maki_cmd cmd={MAKI_CMD_SETDLF, DLFid};
  callDlfCommand(ptr, nargs, &cmd);
}

// This sends the DLFId to the function itself.
void VCPU::DLF_reset(void *ptr, int nargs) {
  maki_cmd cmd={MAKI_CMD_RESETDLF, -1};
  callDlfCommand(ptr, nargs, &cmd);
}

void VCPU::DLF_addref(void *ptr, int nargs) {
  maki_cmd cmd={MAKI_CMD_ADDREF, -1};
  callDlfCommand(ptr, nargs, &cmd);
}

void VCPU::DLF_remref(void *ptr, int nargs) {
  maki_cmd cmd={MAKI_CMD_REMREF, -1};
  callDlfCommand(ptr, nargs, &cmd);
}

// -------------------------------------------------------------
scriptVar VCPU::safeDiv(VCPUscriptVar *v1, VCPUscriptVar *v2) {
  double _r=0;
  double _v1=SOM::makeDouble(&v1->v);
  double _v2=SOM::makeDouble(&v2->v);
  if (_v2 != 0.0)
    _r = _v1 / _v2;
  else
    Script::guruMeditation(SOM::getSystemObjectByScriptId(v1->scriptId), GURU_DIVBYZERO, L"Division by zero");

  scriptVar r = SOM::makeVar(SCRIPT_DOUBLE);
  SOM::assign(&r, _r);
  return r;
}

/*

Registers :

VIP : Instruction Pointer
VSP : Stack Pointer
VSD : Script Descriptor (ID of script we're in)


CALLM calls member function, pops a variable ID and a DLF entry, and pushs the result of
the function. CallC calls an address, so pushs the return address on its stack
(independant from the Push/Pop stack), and jumps to the code. Ret gets the last
address pushed and returns there. JIZ jumps to an address if the first value on the stack
is an int zero. JMP jumps unconditionnaly. 

The stack is a stack of 4 bytes integers containing scriptVar IDs.
Var IDs from binaries are being added the base ID of the current script so we
have only one variables segment for all scripts. Same for DLF entries. Events
aren't references in the bytecode other than in the event table that links
addresses in code to DLF entries, so we don't need that kind of tweaking.

*/

// -------------------------------------------------------------
char *VCPU::getCodeBlock(int id, int *size) {
  for (int i=0;i<codeTable.getNumItems();i++) {
    if (codeTable.enumItem(i)->scriptId == id) {
      if (size != NULL) *size = codeTable.enumItem(i)->size;
      return codeTable.enumItem(i)->codeBlock;
    }
  }
  return NULL;
}

// -------------------------------------------------------------
VCPUcodeBlock *VCPU::getCodeBlockEntry(int id) {
  for (int i=0;i<codeTable.getNumItems();i++) {
    if (codeTable.enumItem(i)->scriptId == id) {
      return codeTable.enumItem(i);
    }
  }
  return NULL;
}

// -------------------------------------------------------------
void VCPU::runCode(int scriptId, int pointer, int np) {
  int quit=0;
  VIP = pointer;
  VSD = scriptId;

#ifdef WASABI_COMPILE_MAKIDEBUG
  int debugger_present = debugApi ? debugApi->debugger_isActive() : 0;
#endif

  char *codeblock = (char *)getCodeBlock(VSD);
  char *p = codeblock + VIP;
  unsigned char opcode;

  int stackbase = VSP-np;
  int callcbase = CallStack.peek();
  VCC = callcbase;

  while (!quit) {
#ifdef WASABI_COMPILE_MAKIDEBUG
    if (debugger_present) {
      VIPstack.push(VIP);
      VSDstack.push(VSD);
//      VSPstack.push(VSP);
      VCCstack.push(VCC);
      debugApi->debugger_trace();
      VIPstack.pop(&VIP);
      VSDstack.pop(&VSD);
//      VSPstack.pop(&VSP);
      VCCstack.pop(&VCC);
    }
#endif
    opcode = *p;
    p+=sizeof(opcode);
    VIP+=sizeof(opcode);

    switch (opcode) {
      case OPCODE_PUSH: {
        int id; // var id
        id = *(int *)p;
        p+=sizeof(int); VIP+=sizeof(int);
        VCPUscriptVar *var = variablesTable.enumItem(id+varBase(VSD));
        push(*var);
        break;
      }
      case OPCODE_POPI: {
        pop(); // discard
        if (VSP == stackbase)
          statementStringList.freeAll();
        break;
      }
      case OPCODE_POP: {
        int id = *(int *)p; // var id
        p+=sizeof(int); VIP+=sizeof(int);
        VCPUscriptVar v = pop(); 
        VCPUassign(id, v.v, VSD);
        break;
      }
      case OPCODE_SET: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        if (v1.varId == -1) {
          Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_SETNONINTERNAL);
          ASSERT(0);
        }
        scriptVar r = VCPUassign(v1.varId, v2.v, VSD);
        push(r);
        break;
      }
      case OPCODE_RETF: {
        if (/*VSP == stackbase+1 && */CallStack.peek() == callcbase) {
          quit = 1;
          break;
        }
        CallStack.pop(&p);
        VIP = p-(char *)getCodeBlock(VSD);
        break;
      }
      case OPCODE_CALLC: {
        int shift; // jump length
        shift = *(int *)p;
        p+=sizeof(int); VIP+=sizeof(int);
        CallStack.push(p);
        VCC++;
        p+=shift;
        VIP+=shift;
        break;
      }
      case OPCODE_CALLM: {
        int id; // DLF id
        id = *(int *)p;
        p+=sizeof(int); VIP+=sizeof(int);
        VCPUdlfEntry *e = DLFentryTable.enumItem(id+dlfBase(VSD));
        int np = *(int *)p;
        // OLD stack protection - was relying on a shody test based on the fact that the compiler should not be able to generate two FF's at this offset, replaced by new opcode but remains for backward compatibility
        if ((np & 0xFFFF0000) == 0xFFFF0000) {
          p += sizeof(int);
          VIP += sizeof(int);
          np &= 0xFFFF;
        } else np = -1;
        scriptVar r = callDLF(e, np);
        VCPUscriptVar vr;
        vr.scriptId = VSD;
        vr.varId = -1;
        vr.v = r;
        push(vr);
        break;
      }
      case OPCODE_CALLM2: {
        int id; // DLF id
        id = *(int *)p;
        p+=sizeof(int); VIP+=sizeof(int);
        VCPUdlfEntry *e = DLFentryTable.enumItem(id+dlfBase(VSD));
        int np = *(unsigned char *)p; p++; VIP+=1;
        scriptVar r = callDLF(e, np);
        VCPUscriptVar vr;
        vr.scriptId = VSD;
        vr.varId = -1;
        vr.v = r;
        push(vr);
        break;
      }
      case OPCODE_UMV: 
				{
        VCPUscriptVar name = pop();
        VCPUscriptVar obj = pop();
        ASSERT(obj.v.data.odata!=NULL);
        ASSERT(name.v.data.sdata!=NULL);

        int rettype = *(int *)p;
        p+=sizeof(int); VIP+=sizeof(int);

        if (rettype >= CLASS_ID_BASE) {
          SystemObject *so = SOM::getSystemObjectByScriptId(VSD);
          TList<int> *typeslist = so->getTypesList();
          rettype = typeslist->enumItem(rettype - CLASS_ID_BASE);
        }

        int oid = ((ScriptObject *)obj.v.data.odata)->vcpu_getMember(name.v.data.sdata, VSD, rettype);
        VCPUscriptVar *v = getOrphan(oid);
        ASSERT(v != NULL);
        push(*v);
        break;
        }
      case OPCODE_CMPEQ: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        VCPUscriptVar r;
        r.v = SOM::makeVar(SCRIPT_INT);
        SOM::assign(&r.v, SOM::compEq(&v1.v, &v2.v));
        push(r);
        break;
        }
      case OPCODE_CMPNE: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        VCPUscriptVar r;
        r.v = SOM::makeVar(SCRIPT_INT);
        SOM::assign(&r.v, SOM::compNeq(&v1.v, &v2.v));
        push(r);
        break;
        }
      case OPCODE_CMPA: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        VCPUscriptVar r;
        r.v = SOM::makeVar(SCRIPT_INT);
        SOM::assign(&r.v, SOM::compA(&v1.v, &v2.v));
        push(r);
        break;
        }
      case OPCODE_CMPAE: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        VCPUscriptVar r;
        r.v = SOM::makeVar(SCRIPT_INT);
        SOM::assign(&r.v, SOM::compAe(&v1.v, &v2.v));
        push(r);
        break;
        }
      case OPCODE_CMPB: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        VCPUscriptVar r;
        r.v = SOM::makeVar(SCRIPT_INT);
        SOM::assign(&r.v, SOM::compB(&v1.v, &v2.v));
        push(r);
        break;
        }
      case OPCODE_CMPBE: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        VCPUscriptVar r;
        r.v = SOM::makeVar(SCRIPT_INT);
        SOM::assign(&r.v, SOM::compBe(&v1.v, &v2.v));
        push(r);
        break;
        }
      case OPCODE_JIZ: {
        int shift; // jump length
        shift = *(int *)p;
        p+=sizeof(int); VIP+=sizeof(int);
        VCPUscriptVar v = pop();
        if (v.v.data.idata == 0) {
          p+=shift;
          VIP+=shift;
        }
        break;
      }
      case OPCODE_JNZ: {
        int shift; // jump length
        shift = *(int *)p;
        p+=sizeof(int); VIP+=sizeof(int);
        VCPUscriptVar v = pop();
        if (v.v.data.idata != 0) {
          p+=shift;
          VIP+=shift;
        }
        break;
      }
      case OPCODE_JMP: {
        int shift; // jump length
        shift = *(int *)p;
        p+=sizeof(int); VIP+=sizeof(int);
        p+=shift;
        VIP+=shift;
        break;
      }
      case OPCODE_NOT: {
        VCPUscriptVar v = pop();
        VCPUscriptVar r;
        r.v = SOM::makeVar(SCRIPT_BOOLEAN);
        switch (v.v.type) {
          case SCRIPT_BOOLEAN:
          case SCRIPT_INT:
          case SCRIPT_FLOAT:
          case SCRIPT_DOUBLE: {
            int i = SOM::makeBoolean(&v.v);
            r.v.data.idata = i == 0 ? 1 : 0;
          }
          break;
        case SCRIPT_STRING:
          r.v.data.idata = (!v.v.data.sdata || !*v.v.data.sdata) ? 1 : 0;
          break;
        default:
          r.v.data.idata = (v.v.data.odata == NULL) ? 1 : 0;
          break;
        }
        push(r);
        break;
      }
      case OPCODE_INCS: {
        VCPUscriptVar v = pop();
        push(v);
        switch (v.v.type) {
          case SCRIPT_BOOLEAN:
            v.v.data.idata = 1;
            break;
          case SCRIPT_INT:
            v.v.data.idata++;
            break;
          case SCRIPT_FLOAT:
            v.v.data.fdata = v.v.data.fdata+1;
            break;
          case SCRIPT_DOUBLE:
            v.v.data.ddata = v.v.data.ddata+1;
            break;
          default:
            Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_INCSNONNUM);
            ASSERT(0);
            break;
        }
        if (v.varId != -1)
          VCPUassign(v.varId, v.v, VSD);
        break;
      }
      case OPCODE_DECS: {
        VCPUscriptVar v = pop();
        push(v);
        switch (v.v.type) {
          case SCRIPT_BOOLEAN:
            v.v.data.idata = 0;
            break;
          case SCRIPT_INT:
            v.v.data.idata--;
            break;
          case SCRIPT_FLOAT:
            v.v.data.fdata = v.v.data.fdata-1;
            break;
          case SCRIPT_DOUBLE:
            v.v.data.ddata = v.v.data.ddata-1;
            break;
          default:
            Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_DECSNONNUM);
            ASSERT(0);
            break;
        }
        if (v.varId != -1)
          VCPUassign(v.varId, v.v, VSD);
        break;
      }
      case OPCODE_INCP: {
        VCPUscriptVar v = pop();
        switch (v.v.type) {
          case SCRIPT_BOOLEAN:
            v.v.data.idata = 1;
            break;
          case SCRIPT_INT:
            v.v.data.idata++;
            break;
          case SCRIPT_FLOAT:
            v.v.data.fdata = v.v.data.fdata+1;
            break;
          case SCRIPT_DOUBLE:
            v.v.data.ddata = v.v.data.ddata+1;
            break;
          default:
            Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_INCPNONNUM);
            ASSERT(0);
            break;
        }
        if (v.varId != -1)
          VCPUassign(v.varId, v.v, VSD);
        push(v);
        break;
      }
      case OPCODE_DECP: {
        VCPUscriptVar v = pop();
        switch (v.v.type) {
          case SCRIPT_BOOLEAN:
            v.v.data.idata = 0;
            break;
          case SCRIPT_INT:
            v.v.data.idata--;
            break;
          case SCRIPT_FLOAT:
            v.v.data.fdata = v.v.data.fdata-1;
            break;
          case SCRIPT_DOUBLE:
            v.v.data.ddata = v.v.data.ddata-1;
            break;
          default:
            Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_DECSNONNUM);
            ASSERT(0);
            break;
        }
        if (v.varId != -1)
          VCPUassign(v.varId, v.v, VSD);
        push(v);
        break;
      }
      case OPCODE_ADD: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        ASSERT(v1.v.type == SCRIPT_STRING || SOM::isNumeric(&v1.v));
        ASSERT(v2.v.type == SCRIPT_STRING || SOM::isNumeric(&v2.v));
        if (v2.v.type == SCRIPT_STRING)
				{
          int n=0;
          if (!v2.v.data.sdata) break;
          if (v1.v.data.sdata) n+= wcslen(v1.v.data.sdata);
          n+= wcslen(v2.v.data.sdata);
          wchar_t *s = (wchar_t *)WMALLOC((n+1));
          ASSERT(s != NULL);

          if (v1.v.data.sdata) 
		  {
            wcsncpy(s, v1.v.data.sdata, n);
			wcsncat(s, (v2.v.data.sdata ? v2.v.data.sdata : L""), n);
          } else
			  wcsncpy(s, (v2.v.data.sdata ? v2.v.data.sdata : L""), n);

          v1.v = SOM::makeVar(SCRIPT_STRING);
          SOM::assign(&v1.v, s);
          FREE(s);
          push(v1);
        } else {
          scriptVar r = SOM::makeVar(SCRIPT_DOUBLE);
          SOM::assign(&r, SOM::makeDouble(&v1.v) + SOM::makeDouble(&v2.v));
          push(r);
        }
        break;
      }
      case OPCODE_SUB: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        ASSERT(SOM::isNumeric(&v1.v));
        ASSERT(SOM::isNumeric(&v2.v));
        scriptVar r = SOM::makeVar(SCRIPT_DOUBLE);
        SOM::assign(&r, SOM::makeDouble(&v1.v) - SOM::makeDouble(&v2.v));
        push(r);
        break;
      }
      case OPCODE_MUL: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        ASSERT(SOM::isNumeric(&v1.v));
        ASSERT(SOM::isNumeric(&v2.v));
        scriptVar r = SOM::makeVar(SCRIPT_DOUBLE);
        SOM::assign(&r, SOM::makeDouble(&v1.v) * SOM::makeDouble(&v2.v));
        push(r);
        break;
      }
      case OPCODE_DIV: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        scriptVar r = safeDiv(&v1, &v2);
        push(r);
        break;
      }

      case OPCODE_MOD: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        if (!SOM::isNumeric(&v2.v) || !SOM::isNumeric(&v1.v)) {
          Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_MODNONNUM);
          ASSERT(0);
        }
        SOM::assign(&v1.v, SOM::makeInt(&v1.v) % SOM::makeInt(&v2.v));
        push(v1);
        break;
      }

      case OPCODE_NEG: {
        VCPUscriptVar v = pop();
        switch (v.v.type) {
          case SCRIPT_BOOLEAN:
            break;
          case SCRIPT_INT:
            v.v.data.idata = -v.v.data.idata;
            break;
          case SCRIPT_FLOAT:
            v.v.data.fdata = -v.v.data.fdata;
            break;
          case SCRIPT_DOUBLE: 
            v.v.data.ddata = -v.v.data.ddata;
            break;
          default:
            Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_NEGNONNUM);
            ASSERT(0);
            break;
        }
        push(v);
        break;
      }

      case OPCODE_BNOT: {
        VCPUscriptVar v = pop();
        if (!SOM::isNumeric(&v.v)) {
          Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_BNOTNONNUM);
          ASSERT(0);
        }
        SOM::assign(&v.v, ~SOM::makeInt(&v.v));
        push(v);
        break;
      }

      case OPCODE_SHL: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        if (!SOM::isNumeric(&v1.v) || !SOM::isNumeric(&v2.v)) {
          Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_SHLNONNUM);
          ASSERT(0);
        }
        SOM::assign(&v1.v, SOM::makeInt(&v1.v) << SOM::makeInt(&v2.v));
        push(v1);
        break;
      }
      case OPCODE_SHR: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        if (!SOM::isNumeric(&v1.v) || !SOM::isNumeric(&v2.v)) {
          Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_SHRNONNUM);
          ASSERT(0);
        }
        SOM::assign(&v1.v, SOM::makeInt(&v1.v) >> SOM::makeInt(&v2.v));
        push(v1);
        break;
      }

      case OPCODE_XOR: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        if (!SOM::isNumeric(&v1.v) || !SOM::isNumeric(&v2.v)) {
          Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_XORNONNUM);
          ASSERT(0);
        }
        SOM::assign(&v1.v, SOM::makeInt(&v1.v) ^ SOM::makeInt(&v2.v));
        push(v1);
        break;
      }

      case OPCODE_AND: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        if (!SOM::isNumeric(&v1.v) || !SOM::isNumeric(&v2.v)) {
          Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_ANDNONNUM);
          ASSERT(0);
        }
        SOM::assign(&v1.v, SOM::makeInt(&v1.v) & SOM::makeInt(&v2.v));
        push(v1);
        break;
      }
      case OPCODE_OR: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        if (!SOM::isNumeric(&v1.v) || !SOM::isNumeric(&v2.v)) {
          Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_ANDNONNUM);
          ASSERT(0);
        }
        SOM::assign(&v1.v, SOM::makeInt(&v1.v) | SOM::makeInt(&v2.v));
        push(v1);
        break;
      }

      case OPCODE_LAND: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        VCPUscriptVar r;
        r.v = SOM::makeVar(SCRIPT_BOOLEAN);
        int a2 = SOM::makeBoolean(&v2.v);
        int a1 = SOM::makeBoolean(&v1.v);
        r.v.data.idata = (a2 && a1) ? 1 : 0;
        push(r);
        break;
      }
      case OPCODE_LOR: {
        VCPUscriptVar v2 = pop();
        VCPUscriptVar v1 = pop();
        VCPUscriptVar r;
        r.v = SOM::makeVar(SCRIPT_BOOLEAN);
        int a2 = SOM::makeBoolean(&v2.v);
        int a1 = SOM::makeBoolean(&v1.v);
        r.v.data.idata = (a2 || a1) ? 1 : 0;
        push(r);
        break;
      }

      case OPCODE_DELETE: {
        VCPUscriptVar v1 = pop();
        int id = 0;
        int type = v1.v.type;
        if (type >= 0x10000)
          do {
            id = type - 0x10000;
            VCPUscriptVar *v = variablesTable.enumItem(id+varBase(VSD));
            type = v->v.type;
          } while (type >= 0x10000);

        if (isInstantiable(type)) {
          ScriptObject *s = (ScriptObject *)v1.v.data.odata;
          scriptVar v = SOM::makeVar(v1.v.type);
          VCPUassign(v1.varId, v, v1.scriptId);
          SystemObject *so = SOM::getSystemObjectByScriptId(VSD);
          so->removeInstantiatedObject(s);
          ObjectTable::destroy(s);
        }
        VCPU::push(v1);
        break;
      }


      case OPCODE_NEW: {
        int id = *(int *)p; // class id
        p+=sizeof(int); VIP+=sizeof(int);

        SystemObject *so = SOM::getSystemObjectByScriptId(VSD);
        TList<int> *typeslist = so->getTypesList();

        int _id;
        if (id >= 0x10000)
          do {
            _id = id - 0x10000;
            VCPUscriptVar *v = variablesTable.enumItem(_id+varBase(VSD));
            id = v->v.type;
          } while (id >= 0x10000);

        if (SOM::getSystemObjectByScriptId(VSD)->isOldFormat())
          id = oldClassToClassId(id);
        else
          id = typeslist->enumItem(id);

        if (isInstantiable(id)) {
          ScriptObject *s = ObjectTable::instantiate(id);
          if (s) s->vcpu_setScriptId(VSD);

          so->addInstantiatedObject(s);

          if (s == NULL) {
            Script::guruMeditation(SOM::getSystemObjectByScriptId(VSD), GURU_NEWFAILED);
          }
          VCPUscriptVar v={{SCRIPT_OBJECT, {0}}, 0};
          SOM::assign(&v.v, s);
          push(v);
        } else {
          VCPUscriptVar n = {{SCRIPT_OBJECT,NULL}, 0};
          push(n);
        }
        break;
      }

      case OPCODE_CMPLT : {
        complete = 1;
        break;
        }

      case OPCODE_NOP : 
      {
#if defined(_WIN32) || defined(_WIN64)
		  OutputDebugStringA("Opcode 0 - NOP encountered, please check!\n");
#else
#warning port me
#endif
        break;
      }
      default: {
        ASSERTALWAYS(StringPrintf("Opcode %X not implemented", opcode));
        break;
      }
    }
  }

  ASSERT(VSP == stackbase + 1);
}

// -------------------------------------------------------------
scriptVar VCPU::VCPUassign(int id, scriptVar sv, int scriptId) {
  VCPUscriptVar *v = NULL;

  if (id & (1 << 31)) {
    id = id & ~(1 << 31);
    v = getOrphan(id);
  } else
    v = variablesTable.enumItem(id+varBase(scriptId));

  if (v->v.type != SCRIPT_STRING) {
    if (!SOM::isNumeric(&v->v)) {
      // assigning an object

      scriptVar _sv = sv;

      if (_sv.data.odata != NULL && !SystemObject::isObjectValid(_sv.data.odata))
        _sv.data.odata = NULL;

      if (v->v.data.odata != _sv.data.odata) {

        if (v->v.data.odata != NULL && !v->transcient && SystemObject::isObjectValid(v->v.data.odata))
          ((ScriptObject *)v->v.data.odata)->vcpu_removeAssignedVariable(v->varId, v->scriptId);

        if (_sv.data.odata == NULL) {
          v->v.data.odata = NULL;
        } else {
          SOM::assign(&v->v, &sv);
          if (SOM::typeCheck(v, 0)) {
            if (!v->isaclass && !v->transcient)
              ((ScriptObject *)sv.data.odata)->vcpu_addAssignedVariable(v->varId, v->scriptId);
          } else {
            int type = v->v.type;
            if (type >= 0x10000)
              do {
                id = type - 0x10000;
                VCPUscriptVar *v = variablesTable.enumItem(id+varBase(VSD));
                type = v->v.type;
              } while (type >= 0x10000);
            class_entry *e = ObjectTable::getClassEntry(type);
            ASSERT(e != NULL);
            GUID g = e->classGuid;
            ScriptObject *o = NULL;
            v->v.data.odata->vcpu_getInterfaceObject(g, &o);
            if (o != NULL) {
              v->v.data.odata = o;
              if (!v->isaclass && !v->transcient)
                o->vcpu_addAssignedVariable(v->varId, v->scriptId);
            } else {
              v->v.data.odata = NULL;
            }
          }
        }
      }

    } else {
      // assigning a number
      SOM::assign(&v->v, &sv);
    }
  } else {
    ASSERT(sv.type == SCRIPT_STRING);
    SOM::persistentstrassign(&v->v, sv.data.sdata);
  }

  return v->v;
}

// -------------------------------------------------------------
void VCPU::traceState(VCPUscriptVar object, VCPUdlfEntry *e) {
  _DebugString("vcpu[%2X]: %04X [%04X].%s", VCPU::VSD, VCPU::VIP, object.varId, e->functionName); 
//  CallbackManager::issueCallback(SysCallback::CONSOLE, ConsoleCallback::DEBUGMESSAGE, 0, reinterpret_cast<int>(t));
}

// -------------------------------------------------------------
// Calls the DLF function
scriptVar VCPU::callDLF(VCPUdlfEntry *e, int np) {

  static Stack<int> cpuidstack;

  cpuidstack.push(VSD);
  cpuidstack.push(VIP);
  cpuidstack.push(VCC);

/*  if (e->external) {
    char t[256] = {0};
    VCPUscriptVar v = VCPU::peekAt(e->nparams);
    SPRINTF(t, "vcpu: %04X [%04X].%s", VCPU::VIP, v.varId, e->functionName);
    Console::outputString(0, t);
    DebugString("%s", t);
    ((void(*)(int))e->ptr)(-1);
    scriptVar rv = pop().v; // returned val
    cpuidstack.pop(&VCC);
    cpuidstack.pop(&VIP);
    cpuidstack.pop(&VSD);
    return rv;
  }*/

  
/*  char t[256] = {0};
  SPRINTF(t, "e->nparams = %d\n", e->nparams);
  DebugString("%s", t); */

  //ASSERT(np == -1 || np == e->nparams); // fucko!!!!!!!!

  if (np == -1) {
    np = e->nparams;
  }

  for (int i=0;i<np;i++) {
    paramList[i] = pop().v;
  }

  VCPUscriptVar object = pop();
  scriptVar r = MAKE_SCRIPT_INT(0);

  //traceState(object, e);

  if (object.v.data.odata == NULL) {
    Script::guruMeditation(SOM::getSystemObjectByScriptId(VCPU::VSD), GURU_NULLCALLED, L"Null object called", object.varId);
    cpuidstack.pop(&VCC);
    cpuidstack.pop(&VIP);
    cpuidstack.pop(&VSD);
    return MAKE_SCRIPT_INT(0);
    //ASSERT(0);
  }
#ifndef _DEBUG
  try
#endif
	{
    if (object.v.data.odata) object.v.data.odata->vcpu_setScriptId(object.scriptId);

    if (e->ptr != NULL) {
      switch (np) {
        case 0:
          r = ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *))e->ptr)(NULL, VCPU::VSD, object.v.data.odata);
          break;
        case 1:
          r = ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar))e->ptr)(NULL, VCPU::VSD, object.v.data.odata, paramList[0]);
          break;
        case 2:
          r = ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar))e->ptr)(NULL, VCPU::VSD, object.v.data.odata, paramList[0], paramList[1]);
          break;
        case 3:
          r = ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar))e->ptr)(NULL, VCPU::VSD, object.v.data.odata, paramList[0], paramList[1], paramList[2]);
          break;
        case 4:
          r = ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar))e->ptr)(NULL, VCPU::VSD, object.v.data.odata, paramList[0], paramList[1], paramList[2], paramList[3]);
          break;
        case 5:
          r = ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar))e->ptr)(NULL, VCPU::VSD, object.v.data.odata, paramList[0], paramList[1], paramList[2], paramList[3], paramList[4]);
          break;
        case 6:
          r = ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar))e->ptr)(NULL, VCPU::VSD, object.v.data.odata, paramList[0], paramList[1], paramList[2], paramList[3], paramList[4], paramList[5]);
          break;
        case 7:
          r = ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar))e->ptr)(NULL, VCPU::VSD, object.v.data.odata, paramList[0], paramList[1], paramList[2], paramList[3], paramList[4], paramList[5], paramList[6]);
          break;
        case 8:
          r = ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar))e->ptr)(NULL, VCPU::VSD, object.v.data.odata, paramList[0], paramList[1], paramList[2], paramList[3], paramList[4], paramList[5], paramList[6], paramList[7]);
          break;
        case 9:
          r = ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar))e->ptr)(NULL, VCPU::VSD, object.v.data.odata, paramList[0], paramList[1], paramList[2], paramList[3], paramList[4], paramList[5], paramList[6], paramList[7], paramList[8]);
          break;
        case 10:
          r = ((scriptVar (*)(maki_cmd *, int vsd, class ScriptObject *, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar, scriptVar))e->ptr)(NULL, VCPU::VSD, object.v.data.odata, paramList[0], paramList[1], paramList[2], paramList[3], paramList[4], paramList[5], paramList[6], paramList[7], paramList[8], paramList[9]);
          break;
      }
    }
  }
#ifndef _DEBUG
	catch(...) 
  {
    Script::guruMeditation(SOM::getSystemObjectByScriptId(VCPU::VSD), GURU_EXCEPTION, L"Script Fatal Error", object.varId);
    cpuidstack.pop(&VCC);
    cpuidstack.pop(&VIP);
    cpuidstack.pop(&VSD);
    #ifdef ON_FATAL_SKIN_ERROR
    ON_FATAL_SKIN_ERROR
    #endif
    return MAKE_SCRIPT_INT(0);
  }
#endif
  cpuidstack.pop(&VCC);
  cpuidstack.pop(&VIP);
  cpuidstack.pop(&VSD);

  return r;
}

// -------------------------------------------------------------
void VCPU::addStatementString(wchar_t *s) 
{
  statementStringList.addItem(s);
}

// -------------------------------------------------------------
int VCPU::getComplete() {
  return complete;
}

// -------------------------------------------------------------
int VCPU::isInstantiable(int id) {
  ASSERT(!SOM::isNumericType(id));
  return ObjectTable::isClassInstantiable(id);
}

// -------------------------------------------------------------
int VCPU::getDlfGlobalIndex(int dlfid, int scriptid) {
  static int lasti=-1;
  static int lastid=0;
  static int lastsid=0;
  if (lasti>=0 && lasti < DLFentryTable.getNumItems()) {
    if (lastsid == scriptid && lastid == dlfid) {
      VCPUdlfEntry *e = DLFentryTable.enumItem(lasti);
      if (e->DLFid == dlfid && e->scriptId == scriptid)
        return lasti;
    }
  }
  for (int i=0;i<DLFentryTable.getNumItems();i++ ){
    VCPUdlfEntry *e = DLFentryTable.enumItem(i);
    if (e->scriptId == scriptid && e->DLFid == dlfid) {
      lasti = i;
      lastsid = scriptid;
      lastid = dlfid;
      return lasti;
    }
  }
  Script::guruMeditation(SOM::getSystemObjectByScriptId(scriptid), GURU_INVALIDEVENTDLF);
  return -1;
}

// -------------------------------------------------------------
int VCPU::isValidScriptId(int id) {
  for (int i=0;i<codeTable.getNumItems();i++)
    if (codeTable[i]->scriptId == id) return 1;
  return 0;
}

// -------------------------------------------------------------
int VCPU::getCacheCount() {
  return cacheCount;
}

// -------------------------------------------------------------
int VCPU::getUserAncestor(int varid, int scriptid) {
  VCPUscriptVar *vc = variablesTable.enumItem(varid+varBase(scriptid)) ;
  if (vc->v.type < 0x10000) return -1;
  int r_varId = vc->v.type - 0x10000;
  ASSERT(r_varId < variablesTable.getNumItems());
  return r_varId;
}

// -------------------------------------------------------------
void VCPU::pushObject(void *o) {
  scriptVar v = SOM::makeVar(SCRIPT_OBJECT, (ScriptObject *)o);
  VCPU::push(v);
}

// -------------------------------------------------------------
void VCPU::pushInt(int i) {
  scriptVar v = SOM::makeVar(SCRIPT_INT);
  SOM::assign(&v, i);
  VCPU::push(v);
}

// -------------------------------------------------------------
void VCPU::pushBoolean(int b) {
  scriptVar v = SOM::makeVar(SCRIPT_BOOLEAN);
  SOM::assign(&v, b);
  VCPU::push(v);
}

// -------------------------------------------------------------
void VCPU::pushFloat(float f) {
  scriptVar v = SOM::makeVar(SCRIPT_FLOAT);
  SOM::assign(&v, f);
  VCPU::push(v);
}

// -------------------------------------------------------------
void VCPU::pushDouble(double d) {
  scriptVar v = SOM::makeVar(SCRIPT_DOUBLE);
  SOM::assign(&v, d);
  VCPU::push(v);
}

// -------------------------------------------------------------
void VCPU::pushString(const wchar_t *s) 
{
  scriptVar v = SOM::makeVar(SCRIPT_STRING);
  SOM::assign(&v, s);
  VCPU::push(v);
}

// -------------------------------------------------------------
void VCPU::pushVoid() {
  scriptVar v = SOM::makeVar(SCRIPT_VOID);
  VCPU::push(v);
}

// -------------------------------------------------------------
void *VCPU::popObject() {
  return (void *)VCPU::pop().v.data.odata;
}

// -------------------------------------------------------------
int VCPU::popInt() {
  scriptVar v = VCPU::pop().v;
  ASSERT(SOM::isNumeric(&v));
  return SOM::makeInt(&v);
}

// -------------------------------------------------------------
bool VCPU::popBoolean() {
  scriptVar v = VCPU::pop().v;
  ASSERT(SOM::isNumeric(&v));
  return SOM::makeBoolean(&v);
}

// -------------------------------------------------------------
float VCPU::popFloat() {
  scriptVar v = VCPU::pop().v;
  ASSERT(SOM::isNumeric(&v));
  return SOM::makeFloat(&v);
}

// -------------------------------------------------------------
double VCPU::popDouble() {
  scriptVar v = VCPU::pop().v;
  ASSERT(SOM::isNumeric(&v));
  return SOM::makeDouble(&v);
}

// -------------------------------------------------------------
const wchar_t *VCPU::popString() 
{
  scriptVar v = VCPU::pop().v;
  ASSERT(v.type == SCRIPT_STRING);
  return v.data.sdata;
}

// -------------------------------------------------------------
void VCPU::popDiscard() {
  VCPU::pop();
}

// -------------------------------------------------------------
VCPUdlfEntry *VCPU::getGlobalDlfEntry(int dlfid) {
  return globalDlfList.enumItem(dlfid);
}

// -------------------------------------------------------------
int VCPU::createOrphan(int type) {
  orphans.addItem(new OrphanEntry(orphanid, type));
  return orphanid++;
}

// -------------------------------------------------------------
void VCPU::killOrphan(int id) {
  int pos;
  OrphanEntry *p = orphans.findItem((const wchar_t *)&id, &pos);
  ASSERT(p != NULL && pos >= 0);
  if (p->v.v.type == SCRIPT_STRING)
    FREE((void *)p->v.v.data.sdata);
  delete p;
  orphans.removeByPos(pos);
}

// -------------------------------------------------------------
VCPUscriptVar *VCPU::getOrphan(int id) {
  OrphanEntry *p = orphans.findItem((const wchar_t *)&id);
  ASSERT(p != NULL);
  return &p->v;
}

// -------------------------------------------------------------
int OrphanQuickSort::compareItem(void *p1, void *p2) {
  if ((static_cast<OrphanEntry *>(p1))->id < (static_cast<OrphanEntry *>(p2))->id) return -1;
  if ((static_cast<OrphanEntry *>(p1))->id > (static_cast<OrphanEntry *>(p2))->id) return 1;
  return 0;
}

// -------------------------------------------------------------
int OrphanQuickSort::compareAttrib(const wchar_t *attr, void *p2) 
{
  int id = *(reinterpret_cast<const int *>(attr));
  int eid = (static_cast<OrphanEntry *>(p2))->id;
  if (id < eid) return -1;
  if (id > eid) return 1;
  return 0;
}

// -------------------------------------------------------------
OrphanEntry::OrphanEntry(int _id, int type) {
  id = _id;
  MEMSET(&v, 0, sizeof(VCPUscriptVar));
  v.v.type = type;
  v.scriptId = -1;
  v.varId = id | (1 << 31); 
  v.transcient = 1; // so no event is trapped, will change later when compiler supports it
}

// -------------------------------------------------------------
void VCPU::setAtom(const wchar_t *atomname, ScriptObject *o) {
  int pos;
  ScriptAtom *sa = atoms.findItem(atomname, &pos);
  if (pos >= 0) {
    delete sa;
    atoms.removeByPos(pos);
  }
  if (o)
    atoms.addItem(new ScriptAtom(atomname, o));
}

// -------------------------------------------------------------
ScriptObject *VCPU::getAtom(const wchar_t *atomname) {
  ScriptAtom *sa = atoms.findItem(atomname);
  if (sa) {
    return sa->getAtomObject();
  }
  return NULL;
}

// -------------------------------------------------------------
const wchar_t *VCPU::getClassName(int vcpuid, int localclassid) {
  SystemObject *so = SOM::getSystemObject(vcpuid);
  if (so != NULL) {
    TList<int> *l = so->getTypesList();
    if (l != NULL) {
      int global = l->enumItem(localclassid);
      class_entry *e = ObjectTable::getClassEntry(global);
      if (e != NULL)
        return e->classname;
    }
  }
  return NULL;
}


// -------------------------------------------------------------
int VCPU::cacheCount = 0;

// segments
PtrList<VCPUscriptVar> VCPU::variablesTable;
PtrList<VCPUeventEntry> VCPU::eventsTable;
PtrList<VCPUdlfEntry> VCPU::DLFentryTable;
PtrList<VCPUdlfEntry> VCPU::globalDlfList;
PtrList<VCPUcodeBlock> VCPU::codeTable;
PtrList<wchar_t> VCPU::statementStringList;
PtrListInsertSorted<OrphanEntry, OrphanQuickSort> VCPU::orphans;
PtrListQuickSorted<ScriptAtom, ScriptAtomSort> VCPU::atoms;
int VCPU::orphanid=0;

// stacks
Stack<VCPUscriptVar> VCPU::CpuStack;
Stack<char *> VCPU::CallStack;

// registers
int VCPU::VIP=0;
int VCPU::VSP=0;
int VCPU::VSD=0;
int VCPU::VCC=0;

Stack<int> VCPU::VIPstack;
Stack<int> VCPU::VSPstack;
Stack<int> VCPU::VSDstack;
Stack<int> VCPU::VCCstack;

// misc
int VCPU::numScripts=0;
int VCPU::highestDLFId=0;
scriptVar VCPU::paramList[SCRIPT_MAXARGS];
int VCPU::complete;

TList<int> VCPU::scriptsToRemove;
// NOTES

// There is no reason why people would cast System, Layout and Container
// back to the common base class... so...
// GUI objects should descend from a GUIObject rather than ScriptObject
// GUIObject would descend from ScriptObject for the compiler and should 
// be exported as "Object" for the script, ScriptObject should then not
// be exported at all, thus preventing someone from doing "Object o = System;"
// which makes no sense since System is not a GUI object. Of course you 
// could still do "Layout l = System.getContainer("mqlksd").getLayout("lqsdkj");"
// but you won't be able to cast that to an "Object". Furthermore, to get a
// GUI object, you'll use the layout's function "getObject", so this
// will add consistency to the overall thing. 

/*
--------------------------------------------------------------------------------

  VCPU: Virtual CPU, The virtual machine processor.
        The VCPU actually takes care of some kinds of segments of variables,
        events, and so on. The VCPU's task is to run any number of scripts
        serially in reversed loading order. Last script loaded takes precedence
        over previous ones. Events and functions fall back to the the previous
        script if it also defines them, unless explicitly prevented via 'complete;'
        The VCPU links DLFs in reverse hierarchy order, allowing overriding of
        functions in objects.

  DLF : Dynamically Linked Function. Function name is used to link it to
        whatever layout of functions we have in any release of the VCPU, allowing
        us to reorder our functions in objects.

  TODO: Add versionning info so we can safely expand this format.

 Binaries format :

 <obsolete>

  Size    Desc                What
  -----------------------------------------------------------------------------
  8       Header              FG\x03\x04\x14\00\00\00\00
  -----------------------------------------------------------------------------
  4       # of DLF            int
  -----------------------------------------------------------------------------
   4       DLF base type      int
   1       Size of func name  char
   N       Function name      char[n]
   ...
  -----------------------------------------------------------------------------
  4       # of variables      int
  -----------------------------------------------------------------------------
   8      variable            scriptVar
   ...
  -----------------------------------------------------------------------------
  4       # of strings        int
  -----------------------------------------------------------------------------
   1      Size of string      char    1st string assigned to 1st string var
   N      String              char[n] 2nd string assigned to 2nd string var...
   ...
  -----------------------------------------------------------------------------
  4       # of events         int
  -----------------------------------------------------------------------------
   4      variable id         int     Matching variable table
   4      DLF entry           int     Matching DLF table
   4      Function pointer    int     Pointer in code from base of code
   ...
  -----------------------------------------------------------------------------
  4       Size of code        int
  -----------------------------------------------------------------------------
   N      Compiled code       char[n]
  -----------------------------------------------------------------------------

*/