//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------

//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
// Arcane-FX for MIT Licensed Open Source version of Torque 3D from GarageGames
// Copyright (C) 2015 Faust Logic, Inc.
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//

#include "console/codeInterpreter.h"
#include "console/compiler.h"
#include "console/simBase.h"
#include "console/telnetDebugger.h"
#include "sim/netStringTable.h"
#include "console/ICallMethod.h"
#include "console/stringStack.h"
#include "util/messaging/message.h"
#include "core/strings/findMatch.h"
#include "core/strings/stringUnit.h"
#include "console/console.h"
#include "console/consoleInternal.h"
#include "cinterface/cinterface.h"

//#define TORQUE_VALIDATE_STACK

using namespace Compiler;

enum EvalConstants
{
   MaxStackSize = 1024,
   FieldBufferSizeString = 2048,
   FieldBufferSizeNumeric = 128,
   MethodOnComponent = -2
};

namespace Con
{
   // Current script file name and root, these are registered as
   // console variables.
   extern StringTableEntry gCurrentFile;
   extern StringTableEntry gCurrentRoot;
   extern S32 gObjectCopyFailures;
}

// Gets a component of an object's field value or a variable and returns it
// in val.
static void getFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField, char val[])
{
   const char* prevVal = NULL;

   // Grab value from object.
   if (object && field)
      prevVal = object->getDataField(field, array);

   // Otherwise, grab from the string stack. The value coming in will always
   // be a string because that is how multicomponent variables are handled.
   else
      prevVal = STR.getStringValue();

   // Make sure we got a value.
   if (prevVal && *prevVal)
   {
      static const StringTableEntry xyzw[] =
      {
         StringTable->insert("x"),
         StringTable->insert("y"),
         StringTable->insert("z"),
         StringTable->insert("w")
      };

      static const StringTableEntry rgba[] =
      {
         StringTable->insert("r"),
         StringTable->insert("g"),
         StringTable->insert("b"),
         StringTable->insert("a")
      };

      // Translate xyzw and rgba into the indexed component 
      // of the variable or field.
      if (subField == xyzw[0] || subField == rgba[0])
         dStrcpy(val, StringUnit::getUnit(prevVal, 0, " \t\n"), 128);

      else if (subField == xyzw[1] || subField == rgba[1])
         dStrcpy(val, StringUnit::getUnit(prevVal, 1, " \t\n"), 128);

      else if (subField == xyzw[2] || subField == rgba[2])
         dStrcpy(val, StringUnit::getUnit(prevVal, 2, " \t\n"), 128);

      else if (subField == xyzw[3] || subField == rgba[3])
         dStrcpy(val, StringUnit::getUnit(prevVal, 3, " \t\n"), 128);

      else
         val[0] = 0;
   }
   else
      val[0] = 0;
}

// Sets a component of an object's field value based on the sub field. 'x' will
// set the first field, 'y' the second, and 'z' the third.
static void setFieldComponent(SimObject* object, StringTableEntry field, const char* array, StringTableEntry subField)
{
   // Copy the current string value
   char strValue[1024];
   dStrncpy(strValue, STR.getStringValue(), 1024);

   char val[1024] = "";
   const char* prevVal = NULL;

   // Set the value on an object field.
   if (object && field)
      prevVal = object->getDataField(field, array);

   // Set the value on a variable.
   else if (gEvalState.currentVariable)
      prevVal = gEvalState.getStringVariable();

   // Ensure that the variable has a value
   if (!prevVal)
      return;

   static const StringTableEntry xyzw[] =
   {
      StringTable->insert("x"),
      StringTable->insert("y"),
      StringTable->insert("z"),
      StringTable->insert("w")
   };

   static const StringTableEntry rgba[] =
   {
      StringTable->insert("r"),
      StringTable->insert("g"),
      StringTable->insert("b"),
      StringTable->insert("a")
   };

   // Insert the value into the specified 
   // component of the string.
   if (subField == xyzw[0] || subField == rgba[0])
      dStrcpy(val, StringUnit::setUnit(prevVal, 0, strValue, " \t\n"), 128);

   else if (subField == xyzw[1] || subField == rgba[1])
      dStrcpy(val, StringUnit::setUnit(prevVal, 1, strValue, " \t\n"), 128);

   else if (subField == xyzw[2] || subField == rgba[2])
      dStrcpy(val, StringUnit::setUnit(prevVal, 2, strValue, " \t\n"), 128);

   else if (subField == xyzw[3] || subField == rgba[3])
      dStrcpy(val, StringUnit::setUnit(prevVal, 3, strValue, " \t\n"), 128);

   if (val[0] != 0)
   {
      // Update the field or variable.
      if (object && field)
         object->setDataField(field, 0, val);
      else if (gEvalState.currentVariable)
         gEvalState.setStringVariable(val);
   }
}
extern ExprEvalState gEvalState;

char sTraceBuffer[1024];

StringStack STR;
ConsoleValueStack CSTK;

U32 _FLT = 0;     ///< Stack pointer for floatStack.
U32 _UINT = 0;    ///< Stack pointer for intStack.
U32 _ITER = 0;    ///< Stack pointer for iterStack.

IterStackRecord iterStack[MaxStackSize];

F64 floatStack[MaxStackSize];
S64 intStack[MaxStackSize];

char curFieldArray[256];
char prevFieldArray[256];

typedef OPCodeReturn(CodeInterpreter::*OpFn)(U32&);

static OpFn gOpCodeArray[MAX_OP_CODELEN];

CodeInterpreter::CodeInterpreter(CodeBlock *cb) :
   mCodeBlock(cb),
   mIterDepth(0),
   mCurFloatTable(nullptr),
   mCurStringTable(nullptr),
   mThisFunctionName(nullptr),
   mPopFrame(false),
   mObjectCreationStackIndex(0),
   mCurrentNewObject(nullptr),
   mFailJump(0),
   mPrevField(nullptr),
   mCurField(nullptr),
   mPrevObject(nullptr),
   mCurObject(nullptr),
   mSaveObject(nullptr),
   mThisObject(nullptr),
   mNSEntry(nullptr),
   mCurFNDocBlock(nullptr),
   mCurNSDocBlock(nullptr),
   mCallArgc(0),
   mCallArgv(nullptr),
   mSaveCodeBlock(nullptr),
   mCurrentInstruction(0)
{
}

CodeInterpreter::~CodeInterpreter()
{
}

void CodeInterpreter::init()
{
   gOpCodeArray[OP_FUNC_DECL] = &CodeInterpreter::op_func_decl;
   gOpCodeArray[OP_CREATE_OBJECT] = &CodeInterpreter::op_create_object;
   gOpCodeArray[OP_ADD_OBJECT] = &CodeInterpreter::op_add_object;
   gOpCodeArray[OP_END_OBJECT] = &CodeInterpreter::op_end_object;
   gOpCodeArray[OP_FINISH_OBJECT] = &CodeInterpreter::op_finish_object;
   gOpCodeArray[OP_JMPIFFNOT] = &CodeInterpreter::op_jmpiffnot;
   gOpCodeArray[OP_JMPIFNOT] = &CodeInterpreter::op_jmpifnot;
   gOpCodeArray[OP_JMPIFF] = &CodeInterpreter::op_jmpiff;
   gOpCodeArray[OP_JMPIF] = &CodeInterpreter::op_jmpif;
   gOpCodeArray[OP_JMPIFNOT_NP] = &CodeInterpreter::op_jmpifnot_np;
   gOpCodeArray[OP_JMPIF_NP] = &CodeInterpreter::op_jmpif_np;
   gOpCodeArray[OP_JMP] = &CodeInterpreter::op_jmp;
   gOpCodeArray[OP_RETURN] = &CodeInterpreter::op_return;
   gOpCodeArray[OP_RETURN_VOID] = &CodeInterpreter::op_return_void;
   gOpCodeArray[OP_RETURN_FLT] = &CodeInterpreter::op_return_flt;
   gOpCodeArray[OP_RETURN_UINT] = &CodeInterpreter::op_return_uint;
   gOpCodeArray[OP_CMPEQ] = &CodeInterpreter::op_cmpeq;
   gOpCodeArray[OP_CMPGR] = &CodeInterpreter::op_cmpgr;
   gOpCodeArray[OP_CMPGE] = &CodeInterpreter::op_cmpge;
   gOpCodeArray[OP_CMPLT] = &CodeInterpreter::op_cmplt;
   gOpCodeArray[OP_CMPLE] = &CodeInterpreter::op_cmple;
   gOpCodeArray[OP_CMPNE] = &CodeInterpreter::op_cmpne;
   gOpCodeArray[OP_XOR] = &CodeInterpreter::op_xor;
   gOpCodeArray[OP_MOD] = &CodeInterpreter::op_mod;
   gOpCodeArray[OP_BITAND] = &CodeInterpreter::op_bitand;
   gOpCodeArray[OP_BITOR] = &CodeInterpreter::op_bitor;
   gOpCodeArray[OP_NOT] = &CodeInterpreter::op_not;
   gOpCodeArray[OP_NOTF] = &CodeInterpreter::op_notf;
   gOpCodeArray[OP_ONESCOMPLEMENT] = &CodeInterpreter::op_onescomplement;
   gOpCodeArray[OP_SHR] = &CodeInterpreter::op_shr;
   gOpCodeArray[OP_SHL] = &CodeInterpreter::op_shl;
   gOpCodeArray[OP_AND] = &CodeInterpreter::op_and;
   gOpCodeArray[OP_OR] = &CodeInterpreter::op_or;
   gOpCodeArray[OP_ADD] = &CodeInterpreter::op_add;
   gOpCodeArray[OP_SUB] = &CodeInterpreter::op_sub;
   gOpCodeArray[OP_MUL] = &CodeInterpreter::op_mul;
   gOpCodeArray[OP_DIV] = &CodeInterpreter::op_div;
   gOpCodeArray[OP_NEG] = &CodeInterpreter::op_neg;
   gOpCodeArray[OP_INC] = &CodeInterpreter::op_inc;
   gOpCodeArray[OP_DEC] = &CodeInterpreter::op_dec;
   gOpCodeArray[OP_SETCURVAR] = &CodeInterpreter::op_setcurvar;
   gOpCodeArray[OP_SETCURVAR_CREATE] = &CodeInterpreter::op_setcurvar_create;
   gOpCodeArray[OP_SETCURVAR_ARRAY] = &CodeInterpreter::op_setcurvar_array;
   gOpCodeArray[OP_SETCURVAR_ARRAY_VARLOOKUP] = &CodeInterpreter::op_setcurvar_array_varlookup;
   gOpCodeArray[OP_SETCURVAR_ARRAY_CREATE] = &CodeInterpreter::op_setcurvar_array_create;
   gOpCodeArray[OP_SETCURVAR_ARRAY_CREATE_VARLOOKUP] = &CodeInterpreter::op_setcurvar_array_create_varlookup;
   gOpCodeArray[OP_LOADVAR_UINT] = &CodeInterpreter::op_loadvar_uint;
   gOpCodeArray[OP_LOADVAR_FLT] = &CodeInterpreter::op_loadvar_flt;
   gOpCodeArray[OP_LOADVAR_STR] = &CodeInterpreter::op_loadvar_str;
   gOpCodeArray[OP_LOADVAR_VAR] = &CodeInterpreter::op_loadvar_var;
   gOpCodeArray[OP_SAVEVAR_UINT] = &CodeInterpreter::op_savevar_uint;
   gOpCodeArray[OP_SAVEVAR_FLT] = &CodeInterpreter::op_savevar_flt;
   gOpCodeArray[OP_SAVEVAR_STR] = &CodeInterpreter::op_savevar_str;
   gOpCodeArray[OP_SAVEVAR_VAR] = &CodeInterpreter::op_savevar_var;
   gOpCodeArray[OP_SETCUROBJECT] = &CodeInterpreter::op_setcurobject;
   gOpCodeArray[OP_SETCUROBJECT_INTERNAL] = &CodeInterpreter::op_setcurobject_internal;
   gOpCodeArray[OP_SETCUROBJECT_NEW] = &CodeInterpreter::op_setcurobject_new;
   gOpCodeArray[OP_SETCURFIELD] = &CodeInterpreter::op_setcurfield;
   gOpCodeArray[OP_SETCURFIELD_ARRAY] = &CodeInterpreter::op_setcurfield_array;
   gOpCodeArray[OP_SETCURFIELD_TYPE] = &CodeInterpreter::op_setcurfield_type;
   gOpCodeArray[OP_SETCURFIELD_ARRAY_VAR] = &CodeInterpreter::op_setcurfield_array_var;
   gOpCodeArray[OP_SETCURFIELD_THIS] = &CodeInterpreter::op_setcurfield_this;
   gOpCodeArray[OP_LOADFIELD_UINT] = &CodeInterpreter::op_loadfield_uint;
   gOpCodeArray[OP_LOADFIELD_FLT] = &CodeInterpreter::op_loadfield_flt;
   gOpCodeArray[OP_LOADFIELD_STR] = &CodeInterpreter::op_loadfield_str;
   gOpCodeArray[OP_SAVEFIELD_UINT] = &CodeInterpreter::op_savefield_uint;
   gOpCodeArray[OP_SAVEFIELD_FLT] = &CodeInterpreter::op_savefield_flt;
   gOpCodeArray[OP_SAVEFIELD_STR] = &CodeInterpreter::op_savefield_str;
   gOpCodeArray[OP_STR_TO_UINT] = &CodeInterpreter::op_str_to_uint;
   gOpCodeArray[OP_STR_TO_FLT] = &CodeInterpreter::op_str_to_flt;
   gOpCodeArray[OP_STR_TO_NONE] = &CodeInterpreter::op_str_to_none;
   gOpCodeArray[OP_FLT_TO_UINT] = &CodeInterpreter::op_flt_to_uint;
   gOpCodeArray[OP_FLT_TO_STR] = &CodeInterpreter::op_flt_to_str;
   gOpCodeArray[OP_FLT_TO_NONE] = &CodeInterpreter::op_flt_to_none;
   gOpCodeArray[OP_UINT_TO_FLT] = &CodeInterpreter::op_uint_to_flt;
   gOpCodeArray[OP_UINT_TO_STR] = &CodeInterpreter::op_uint_to_str;
   gOpCodeArray[OP_UINT_TO_NONE] = &CodeInterpreter::op_uint_to_none;
   gOpCodeArray[OP_COPYVAR_TO_NONE] = &CodeInterpreter::op_copyvar_to_none;
   gOpCodeArray[OP_LOADIMMED_UINT] = &CodeInterpreter::op_loadimmed_uint;
   gOpCodeArray[OP_LOADIMMED_FLT] = &CodeInterpreter::op_loadimmed_flt;
   gOpCodeArray[OP_TAG_TO_STR] = &CodeInterpreter::op_tag_to_str;
   gOpCodeArray[OP_LOADIMMED_STR] = &CodeInterpreter::op_loadimmed_str;
   gOpCodeArray[OP_DOCBLOCK_STR] = &CodeInterpreter::op_docblock_str;
   gOpCodeArray[OP_LOADIMMED_IDENT] = &CodeInterpreter::op_loadimmed_ident;
   gOpCodeArray[OP_CALLFUNC_RESOLVE] = &CodeInterpreter::op_callfunc_resolve;
   gOpCodeArray[OP_CALLFUNC] = &CodeInterpreter::op_callfunc;
   gOpCodeArray[OP_CALLFUNC_POINTER] = &CodeInterpreter::op_callfunc_pointer;
   gOpCodeArray[OP_CALLFUNC_THIS] = &CodeInterpreter::op_callfunc_this;
   gOpCodeArray[OP_ADVANCE_STR] = &CodeInterpreter::op_advance_str;
   gOpCodeArray[OP_ADVANCE_STR_APPENDCHAR] = &CodeInterpreter::op_advance_str_appendchar;
   gOpCodeArray[OP_ADVANCE_STR_COMMA] = &CodeInterpreter::op_advance_str_comma;
   gOpCodeArray[OP_ADVANCE_STR_NUL] = &CodeInterpreter::op_advance_str_nul;
   gOpCodeArray[OP_REWIND_STR] = &CodeInterpreter::op_rewind_str;
   gOpCodeArray[OP_TERMINATE_REWIND_STR] = &CodeInterpreter::op_terminate_rewind_str;
   gOpCodeArray[OP_COMPARE_STR] = &CodeInterpreter::op_compare_str;
   gOpCodeArray[OP_PUSH] = &CodeInterpreter::op_push;
   gOpCodeArray[OP_PUSH_UINT] = &CodeInterpreter::op_push_uint;
   gOpCodeArray[OP_PUSH_FLT] = &CodeInterpreter::op_push_flt;
   gOpCodeArray[OP_PUSH_VAR] = &CodeInterpreter::op_push_var;
   gOpCodeArray[OP_PUSH_THIS] = &CodeInterpreter::op_push_this;
   gOpCodeArray[OP_PUSH_FRAME] = &CodeInterpreter::op_push_frame;
   gOpCodeArray[OP_ASSERT] = &CodeInterpreter::op_assert;
   gOpCodeArray[OP_BREAK] = &CodeInterpreter::op_break;
   gOpCodeArray[OP_ITER_BEGIN_STR] = &CodeInterpreter::op_iter_begin_str;
   gOpCodeArray[OP_ITER_BEGIN] = &CodeInterpreter::op_iter_begin;
   gOpCodeArray[OP_ITER] = &CodeInterpreter::op_iter;
   gOpCodeArray[OP_ITER_END] = &CodeInterpreter::op_iter_end;
   gOpCodeArray[OP_INVALID] = &CodeInterpreter::op_invalid;
}

ConsoleValueRef CodeInterpreter::exec(U32 ip,
                                      StringTableEntry functionName,
                                      Namespace *thisNamespace,
                                      U32 argc, 
                                      ConsoleValueRef *argv,
                                      bool noCalls,
                                      StringTableEntry packageName,
                                      S32 setFrame) 
{
   mExec.functionName = functionName;
   mExec.thisNamespace = thisNamespace;
   mExec.argc = argc;
   mExec.argv = argv;
   mExec.noCalls = noCalls;
   mExec.packageName = packageName;
   mExec.setFrame = setFrame;

   mCodeBlock->incRefCount();

   mPopFrame = false;

#ifdef TORQUE_VALIDATE_STACK
   U32 stackStart = STR.mStartStackSize;
#endif

   STR.clearFunctionOffset(); // ensures arg buffer offset is back to 0

   // Lets load up our function arguments.
   parseArgs(ip);

   // Grab the state of the telenet debugger here once
   // so that the push and pop frames are always balanced.
   const bool telDebuggerOn = TelDebugger && TelDebugger->isConnected();
   if (telDebuggerOn && setFrame < 0)
      TelDebugger->pushStackFrame();

   mSaveCodeBlock = CodeBlock::smCurrentCodeBlock;
   CodeBlock::smCurrentCodeBlock = mCodeBlock;
   if (mCodeBlock->name)
   {
      Con::gCurrentFile = mCodeBlock->name;
      Con::gCurrentRoot = mCodeBlock->modPath;
   }

   U32 *code = mCodeBlock->code;

   while (true)
   {
      mCurrentInstruction = code[ip++];
      mNSEntry = nullptr;

#ifdef TORQUE_VALIDATE_STACK
      // OP Code check.
      AssertFatal(mCurrentInstruction < MAX_OP_CODELEN, "Invalid OP code in script interpreter");
#endif

   breakContinueLabel:
      OPCodeReturn ret = (this->*gOpCodeArray[mCurrentInstruction])(ip);
      if (ret == OPCodeReturn::exitCode)
         break;
      else if (ret == OPCodeReturn::breakContinue)
         goto breakContinueLabel;
   }

   if (telDebuggerOn && setFrame < 0)
      TelDebugger->popStackFrame();

   if (mPopFrame)
      gEvalState.popFrame();

   if (argv)
   {
      if (gEvalState.traceOn)
      {
         sTraceBuffer[0] = 0;
         dStrcat(sTraceBuffer, "Leaving ", 1024);

         if (packageName)
         {
            dStrcat(sTraceBuffer, "[", 1024);
            dStrcat(sTraceBuffer, packageName, 1024);
            dStrcat(sTraceBuffer, "]", 1024);
         }
         if (thisNamespace && thisNamespace->mName)
         {
            dSprintf(sTraceBuffer + dStrlen(sTraceBuffer), (U32)(sizeof(sTraceBuffer) - dStrlen(sTraceBuffer)),
               "%s::%s() - return %s", thisNamespace->mName, mThisFunctionName, STR.getStringValue());
         }
         else
         {
            dSprintf(sTraceBuffer + dStrlen(sTraceBuffer), (U32)(sizeof(sTraceBuffer) - dStrlen(sTraceBuffer)),
               "%s() - return %s", mThisFunctionName, STR.getStringValue());
         }
         Con::printf("%s", sTraceBuffer);
      }
   }

   CodeBlock::smCurrentCodeBlock = mSaveCodeBlock;
   if (mSaveCodeBlock && mSaveCodeBlock->name)
   {
      Con::gCurrentFile = mSaveCodeBlock->name;
      Con::gCurrentRoot = mSaveCodeBlock->modPath;
   }

   mCodeBlock->decRefCount();

#ifdef TORQUE_VALIDATE_STACK
   AssertFatal(!(STR.mStartStackSize > stackStart), "String stack not popped enough in script exec");
   AssertFatal(!(STR.mStartStackSize < stackStart), "String stack popped too much in script exec");
#endif

   return mReturnValue;
}

void CodeInterpreter::parseArgs(U32 &ip)
{
   U32 *code = mCodeBlock->code;

   if (mExec.argv)
   {
      U32 fnArgc = code[ip + 2 + 6];
      mThisFunctionName = Compiler::CodeToSTE(code, ip);
      S32 wantedArgc = getMin(mExec.argc - 1, fnArgc); // argv[0] is func name
      if (gEvalState.traceOn)
      {
         sTraceBuffer[0] = 0;
         dStrcat(sTraceBuffer, "Entering ", 1024);

         if (mExec.packageName)
         {
            dStrcat(sTraceBuffer, "[", 1024);
            dStrcat(sTraceBuffer, mExec.packageName, 1024);
            dStrcat(sTraceBuffer, "]", 1024);
         }
         if (mExec.thisNamespace && mExec.thisNamespace->mName)
         {
            dSprintf(sTraceBuffer + dStrlen(sTraceBuffer), (U32)(sizeof(sTraceBuffer) - dStrlen(sTraceBuffer)),
               "%s::%s(", mExec.thisNamespace->mName, mThisFunctionName);
         }
         else
         {
            dSprintf(sTraceBuffer + dStrlen(sTraceBuffer), (U32)(sizeof(sTraceBuffer) - dStrlen(sTraceBuffer)),
               "%s(", mThisFunctionName);
         }
         for (S32 i = 0; i < wantedArgc; i++)
         {
            dStrcat(sTraceBuffer, mExec.argv[i + 1], 1024);
            if (i != wantedArgc - 1)
               dStrcat(sTraceBuffer, ", ", 1024);
         }
         dStrcat(sTraceBuffer, ")", 1024);
         Con::printf("%s", sTraceBuffer);
      }

      gEvalState.pushFrame(mThisFunctionName, mExec.thisNamespace);
      mPopFrame = true;

      StringTableEntry thisPointer = StringTable->insert("%this");

      for (S32 i = 0; i < wantedArgc; i++)
      {
         StringTableEntry var = Compiler::CodeToSTE(code, ip + (2 + 6 + 1) + (i * 2));
         gEvalState.setCurVarNameCreate(var);

         ConsoleValueRef ref = mExec.argv[i + 1];

         switch (ref.getType())
         {
         case ConsoleValue::TypeInternalInt:
            gEvalState.setIntVariable(ref);
            break;
         case ConsoleValue::TypeInternalFloat:
            gEvalState.setFloatVariable(ref);
            break;
         case ConsoleValue::TypeInternalStringStackPtr:
            gEvalState.setStringStackPtrVariable(ref.getStringStackPtrValue());
            break;
         case ConsoleValue::TypeInternalStackString:
         case ConsoleValue::TypeInternalString:
         default:
            gEvalState.setStringVariable(ref);
            break;
         }

         if (var == thisPointer)
         {
            // %this gets optimized as it is flagged as a constant.
            // Since it is guarenteed to be constant, we can then perform optimizations.
            gEvalState.currentVariable->mIsConstant = true;

            // Store a reference to the this pointer object.
            mThisObject = Sim::findObject(gEvalState.getStringVariable());
         }
      }

      ip = ip + (fnArgc * 2) + (2 + 6 + 1);
      mCurFloatTable = mCodeBlock->functionFloats;
      mCurStringTable = mCodeBlock->functionStrings;
   }
   else
   {
      mCurFloatTable = mCodeBlock->globalFloats;
      mCurStringTable = mCodeBlock->globalStrings;

      // If requested stack frame isn't available, request a new one
      // (this prevents assert failures when creating local
      //  variables without a stack frame)
      if (gEvalState.getStackDepth() <= mExec.setFrame)
         mExec.setFrame = -1;

      // Do we want this code to execute using a new stack frame?
      if (mExec.setFrame < 0)
      {
         gEvalState.pushFrame(NULL, NULL);
         mPopFrame = true;
      }
      else
      {
         // We want to copy a reference to an existing stack frame
         // on to the top of the stack.  Any change that occurs to 
         // the locals during this new frame will also occur in the 
         // original frame.
         S32 stackIndex = gEvalState.getStackDepth() - mExec.setFrame - 1;
         gEvalState.pushFrameRef(stackIndex);
         mPopFrame = true;
      }
   }
}

OPCodeReturn CodeInterpreter::op_func_decl(U32 &ip)
{
   U32 *code = mCodeBlock->code;

   if (!mExec.noCalls)
   {
      StringTableEntry fnName = CodeToSTE(code, ip);
      StringTableEntry fnNamespace = CodeToSTE(code, ip + 2);
      StringTableEntry fnPackage = CodeToSTE(code, ip + 4);
      bool hasBody = (code[ip + 6] & 0x01) != 0;
      U32 lineNumber = code[ip + 6] >> 1;

      Namespace::unlinkPackages();
      Namespace *ns = Namespace::find(fnNamespace, fnPackage);
      ns->addFunction(fnName, mCodeBlock, hasBody ? ip : 0, mCurFNDocBlock ? dStrdup(mCurFNDocBlock) : NULL, lineNumber);// if no body, set the IP to 0
      if (mCurNSDocBlock)
      {
         // If we have a docblock before we declare the function in the script file,
         // this will attempt to set the doc block to the function.
         // See OP_DOCBLOCK_STR
         if (fnNamespace == StringTable->lookup(mNSDocBlockClass))
         {
            char *usageStr = dStrdup(mCurNSDocBlock);
            usageStr[dStrlen(usageStr)] = '\0';
            ns->mUsage = usageStr;
            ns->mCleanUpUsage = true;
            mCurNSDocBlock = NULL;
         }
      }
      Namespace::relinkPackages();

      // If we had a docblock, it's definitely not valid anymore, so clear it out.
      mCurFNDocBlock = NULL;

      //Con::printf("Adding function %s::%s (%d)", fnNamespace, fnName, ip);
   }
   ip = code[ip + 7];
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_create_object(U32 &ip)
{
   U32 *code = mCodeBlock->code;

   // Read some useful info.
   StringTableEntry objParent = CodeToSTE(code, ip);
   bool isDataBlock = code[ip + 2];
   bool isInternal = code[ip + 3];
   bool isSingleton = code[ip + 4];
   U32  lineNumber = code[ip + 5];
   mFailJump = code[ip + 6];

   // If we don't allow calls, we certainly don't allow creating objects!
   // Moved this to after failJump is set. Engine was crashing when
   // noCalls = true and an object was being created at the beginning of
   // a file. ADL.
   if (mExec.noCalls)
   {
      ip = mFailJump;
      return OPCodeReturn::success;
   }

   // Push the old info to the stack
   //Assert( objectCreationStackIndex < objectCreationStackSize );
   mObjectCreationStack[mObjectCreationStackIndex].newObject = mCurrentNewObject;
   mObjectCreationStack[mObjectCreationStackIndex++].failJump = mFailJump;

   // Get the constructor information off the stack.
   CSTK.getArgcArgv(NULL, &mCallArgc, &mCallArgv);
   const char *objectName = mCallArgv[2];

   // Con::printf("Creating object...");

   // objectName = argv[1]...
   mCurrentNewObject = NULL;

   // Are we creating a datablock? If so, deal with case where we override
   // an old one.
   if (isDataBlock)
   {
      // Con::printf("  - is a datablock");

      // Find the old one if any.
      SimObject *db = Sim::getDataBlockGroup()->findObject(objectName);

      // Make sure we're not changing types on ourselves...
      if (db && dStricmp(db->getClassName(), mCallArgv[1]))
      {
         Con::errorf(ConsoleLogEntry::General, "%s: Cannot re-declare data block %s with a different class.", mCodeBlock->getFileLine(ip), objectName);
         ip = mFailJump;
         STR.popFrame();
         CSTK.popFrame();
         return OPCodeReturn::success;
      }

      // If there was one, set the currentNewObject and move on.
      if (db)
         mCurrentNewObject = db;
   }
   else if (!isInternal)
   {
      // IF we aren't looking at a local/internal object, then check if 
      // this object already exists in the global space

      AbstractClassRep* rep = AbstractClassRep::findClassRep(objectName);
      if (rep != NULL) {
         Con::errorf(ConsoleLogEntry::General, "%s: Cannot name object [%s] the same name as a script class.",
            mCodeBlock->getFileLine(ip), objectName);
         ip = mFailJump;
         STR.popFrame();
         CSTK.popFrame();
         return OPCodeReturn::success;
      }

      SimObject *obj = Sim::findObject((const char*)objectName);
      if (obj /*&& !obj->isLocalName()*/)
      {
         if (isSingleton)
         {
            // Make sure we're not trying to change types
            if (dStricmp(obj->getClassName(), (const char*)mCallArgv[1]) != 0)
            {
               Con::errorf(ConsoleLogEntry::General, "%s: Cannot re-declare object [%s] with a different class [%s] - was [%s].",
                  mCodeBlock->getFileLine(ip), objectName, (const char*)mCallArgv[1], obj->getClassName());
               ip = mFailJump;
               STR.popFrame();
               CSTK.popFrame();
               return OPCodeReturn::success;
            }

            // We're creating a singleton, so use the found object
            // instead of creating a new object.
            mCurrentNewObject = obj;
         }
         else
         {
            const char* redefineBehavior = Con::getVariable("$Con::redefineBehavior");

            if (dStricmp(redefineBehavior, "replaceExisting") == 0)
            {
               // Save our constructor args as the argv vector is stored on the
               // string stack and may get stomped if deleteObject triggers
               // script execution.

               ConsoleValueRef savedArgv[StringStack::MaxArgs];
               for (int i = 0; i< mCallArgc; i++) {
                  savedArgv[i] = mCallArgv[i];
               }
               //dMemcpy( savedArgv, callArgv, sizeof( savedArgv[ 0 ] ) * callArgc );

               // Prevent stack value corruption
               CSTK.pushFrame();
               STR.pushFrame();
               // --

               obj->deleteObject();
               obj = NULL;

               // Prevent stack value corruption
               CSTK.popFrame();
               STR.popFrame();
               // --

               //dMemcpy( callArgv, savedArgv, sizeof( callArgv[ 0 ] ) * callArgc );
               for (int i = 0; i<mCallArgc; i++) {
                  mCallArgv[i] = savedArgv[i];
               }
            }
            else if (dStricmp(redefineBehavior, "renameNew") == 0)
            {
               for (U32 i = 1;; ++i)
               {
                  String newName = String::ToString("%s%i", objectName, i);
                  if (!Sim::findObject(newName))
                  {
                     objectName = StringTable->insert(newName);
                     break;
                  }
               }
            }
            else if (dStricmp(redefineBehavior, "unnameNew") == 0)
            {
               objectName = StringTable->insert("");
            }
            else if (dStricmp(redefineBehavior, "postfixNew") == 0)
            {
               const char* postfix = Con::getVariable("$Con::redefineBehaviorPostfix");
               String newName = String::ToString("%s%s", objectName, postfix);

               if (Sim::findObject(newName))
               {
                  Con::errorf(ConsoleLogEntry::General, "%s: Cannot re-declare object with postfix [%s].",
                     mCodeBlock->getFileLine(ip), newName.c_str());
                  ip = mFailJump;
                  STR.popFrame();
                  CSTK.popFrame();
                  return OPCodeReturn::success;
               }
               else
                  objectName = StringTable->insert(newName);
            }
            else
            {
               Con::errorf(ConsoleLogEntry::General, "%s: Cannot re-declare object [%s].",
                  mCodeBlock->getFileLine(ip), objectName);
               ip = mFailJump;
               STR.popFrame();
               CSTK.popFrame();
               return OPCodeReturn::success;
            }
         }
      }
   }

   STR.popFrame();
   CSTK.popFrame();

   if (!mCurrentNewObject)
   {
      // Well, looks like we have to create a new object.
      ConsoleObject *object = ConsoleObject::create((const char*)mCallArgv[1]);

      // Deal with failure!
      if (!object)
      {
         Con::errorf(ConsoleLogEntry::General, "%s: Unable to instantiate non-conobject class %s.", mCodeBlock->getFileLine(ip), (const char*)mCallArgv[1]);
         ip = mFailJump;
         return OPCodeReturn::success;
      }

      // Do special datablock init if appropros
      if (isDataBlock)
      {
         SimDataBlock *dataBlock = dynamic_cast<SimDataBlock *>(object);
         if (dataBlock)
         {
            dataBlock->assignId();
         }
         else
         {
            // They tried to make a non-datablock with a datablock keyword!
            Con::errorf(ConsoleLogEntry::General, "%s: Unable to instantiate non-datablock class %s.", mCodeBlock->getFileLine(ip), (const char*)mCallArgv[1]);
            // Clean up...
            delete object;
            mCurrentNewObject = NULL;
            ip = mFailJump;
            return OPCodeReturn::success;
         }
      }

      // Finally, set currentNewObject to point to the new one.
      mCurrentNewObject = dynamic_cast<SimObject *>(object);

      // Deal with the case of a non-SimObject.
      if (!mCurrentNewObject)
      {
         Con::errorf(ConsoleLogEntry::General, "%s: Unable to instantiate non-SimObject class %s.", mCodeBlock->getFileLine(ip), (const char*)mCallArgv[1]);
         delete object;
         mCurrentNewObject = NULL;
         ip = mFailJump;
         return OPCodeReturn::success;
      }

      // Set the declaration line
      mCurrentNewObject->setDeclarationLine(lineNumber);

      // Set the file that this object was created in
      mCurrentNewObject->setFilename(mCodeBlock->name);

      // Does it have a parent object? (ie, the copy constructor : syntax, not inheriance)
      if (*objParent)
      {
         // Find it!
         SimObject *parent;
         if (Sim::findObject(objParent, parent))
         {
            // Con::printf(" - Parent object found: %s", parent->getClassName());

            mCurrentNewObject->setCopySource(parent);
            mCurrentNewObject->assignFieldsFrom(parent);

            // copy any substitution statements
            SimDataBlock* parent_db = dynamic_cast<SimDataBlock*>(parent);
            if (parent_db)
            {
               SimDataBlock* currentNewObject_db = dynamic_cast<SimDataBlock*>(mCurrentNewObject);
               if (currentNewObject_db)
                  currentNewObject_db->copySubstitutionsFrom(parent_db);
            }
         }
         else
         {
            if (Con::gObjectCopyFailures == -1)
               Con::errorf(ConsoleLogEntry::General, "%s: Unable to find parent object %s for %s.", mCodeBlock->getFileLine(ip), objParent, (const char*)mCallArgv[1]);
            else
               ++Con::gObjectCopyFailures;

            // Fail to create the object.
            delete object;
            mCurrentNewObject = NULL;
            ip = mFailJump;
            return OPCodeReturn::success;
         }
      }

      // If a name was passed, assign it.
      if (objectName[0])
      {
         if (!isInternal)
            mCurrentNewObject->assignName(objectName);
         else
            mCurrentNewObject->setInternalName(objectName);

         // Set the original name
         mCurrentNewObject->setOriginalName(objectName);
      }

      // Prevent stack value corruption
      CSTK.pushFrame();
      STR.pushFrame();
      // --

      // Do the constructor parameters.
      if (!mCurrentNewObject->processArguments(mCallArgc - 3, mCallArgv + 3))
      {
         delete mCurrentNewObject;
         mCurrentNewObject = NULL;
         ip = mFailJump;

         // Prevent stack value corruption
         CSTK.popFrame();
         STR.popFrame();
         // --
         return OPCodeReturn::success;
      }

      // Prevent stack value corruption
      CSTK.popFrame();
      STR.popFrame();
      // --

      // If it's not a datablock, allow people to modify bits of it.
      if (!isDataBlock)
      {
         mCurrentNewObject->setModStaticFields(true);
         mCurrentNewObject->setModDynamicFields(true);
      }
   }
   else
   {
      mCurrentNewObject->reloadReset(); // AFX (reload-reset)
                                       // Does it have a parent object? (ie, the copy constructor : syntax, not inheriance)
      if (*objParent)
      {
         // Find it!
         SimObject *parent;
         if (Sim::findObject(objParent, parent))
         {
            // Con::printf(" - Parent object found: %s", parent->getClassName());

            // temporarily block name change
            SimObject::preventNameChanging = true;
            mCurrentNewObject->setCopySource(parent);
            mCurrentNewObject->assignFieldsFrom(parent);
            // restore name changing
            SimObject::preventNameChanging = false;

            // copy any substitution statements
            SimDataBlock* parent_db = dynamic_cast<SimDataBlock*>(parent);
            if (parent_db)
            {
               SimDataBlock* currentNewObject_db = dynamic_cast<SimDataBlock*>(mCurrentNewObject);
               if (currentNewObject_db)
                  currentNewObject_db->copySubstitutionsFrom(parent_db);
            }
         }
         else
            Con::errorf(ConsoleLogEntry::General, "%d: Unable to find parent object %s for %s.", lineNumber, objParent, (const char*)mCallArgv[1]);
      }
   }

   // Advance the IP past the create info...
   ip += 7;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_add_object(U32 &ip)
{
   // See OP_SETCURVAR for why we do this.
   mCurFNDocBlock = NULL;
   mCurNSDocBlock = NULL;

   // Do we place this object at the root?
   bool placeAtRoot = mCodeBlock->code[ip++];

   // Con::printf("Adding object %s", currentNewObject->getName());

   // Prevent stack value corruption
   CSTK.pushFrame();
   STR.pushFrame();
   // --

   // Make sure it wasn't already added, then add it.
   if (mCurrentNewObject->isProperlyAdded() == false)
   {
      bool ret = false;

      Message *msg = dynamic_cast<Message *>(mCurrentNewObject);
      if (msg)
      {
         SimObjectId id = Message::getNextMessageID();
         if (id != 0xffffffff)
            ret = mCurrentNewObject->registerObject(id);
         else
            Con::errorf("%s: No more object IDs available for messages", mCodeBlock->getFileLine(ip));
      }
      else
         ret = mCurrentNewObject->registerObject();

      if (!ret)
      {
         // This error is usually caused by failing to call Parent::initPersistFields in the class' initPersistFields().
         Con::warnf(ConsoleLogEntry::General, "%s: Register object failed for object %s of class %s.", mCodeBlock->getFileLine(ip), mCurrentNewObject->getName(), mCurrentNewObject->getClassName());
         delete mCurrentNewObject;
         mCurrentNewObject = NULL;
         ip = mFailJump;
         // Prevent stack value corruption
         CSTK.popFrame();
         STR.popFrame();
         // --
         return OPCodeReturn::success;
      }
   }

   // Are we dealing with a datablock?
   SimDataBlock *dataBlock = dynamic_cast<SimDataBlock *>(mCurrentNewObject);
   static String errorStr;

   // If so, preload it.
   if (dataBlock && !dataBlock->preload(true, errorStr))
   {
      Con::errorf(ConsoleLogEntry::General, "%s: preload failed for %s: %s.", mCodeBlock->getFileLine(ip),
         mCurrentNewObject->getName(), errorStr.c_str());
      dataBlock->deleteObject();
      mCurrentNewObject = NULL;
      ip = mFailJump;

      // Prevent stack value corruption
      CSTK.popFrame();
      STR.popFrame();
      // --
      return OPCodeReturn::success;
   }

   // What group will we be added to, if any?
   U32 groupAddId = intStack[_UINT];
   SimGroup *grp = NULL;
   SimSet   *set = NULL;
   bool isMessage = dynamic_cast<Message *>(mCurrentNewObject) != NULL;

   if (!placeAtRoot || !mCurrentNewObject->getGroup())
   {
      if (!isMessage)
      {
         if (!placeAtRoot)
         {
            // Otherwise just add to the requested group or set.
            if (!Sim::findObject(groupAddId, grp))
               Sim::findObject(groupAddId, set);
         }

         if (placeAtRoot)
         {
            // Deal with the instantGroup if we're being put at the root or we're adding to a component.
            if (Con::gInstantGroup.isEmpty()
               || !Sim::findObject(Con::gInstantGroup, grp))
               grp = Sim::getRootGroup();
         }
      }

      // If we didn't get a group, then make sure we have a pointer to
      // the rootgroup.
      if (!grp)
         grp = Sim::getRootGroup();

      // add to the parent group
      grp->addObject(mCurrentNewObject);

      // If for some reason the add failed, add the object to the
      // root group so it won't leak.
      if (!mCurrentNewObject->getGroup())
         Sim::getRootGroup()->addObject(mCurrentNewObject);

      // add to any set we might be in
      if (set)
         set->addObject(mCurrentNewObject);
   }

   // store the new object's ID on the stack (overwriting the group/set
   // id, if one was given, otherwise getting pushed)
   if (placeAtRoot)
      intStack[_UINT] = mCurrentNewObject->getId();
   else
      intStack[++_UINT] = mCurrentNewObject->getId();

   // Prevent stack value corruption
   CSTK.popFrame();
   STR.popFrame();
   // --
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_end_object(U32 &ip)
{
   // If we're not to be placed at the root, make sure we clean up
   // our group reference.
   bool placeAtRoot = mCodeBlock->code[ip++];
   if (!placeAtRoot)
      _UINT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_finish_object(U32 &ip)
{
   if (mCurrentNewObject)
      mCurrentNewObject->onPostAdd();

   //Assert( objectCreationStackIndex >= 0 );
   // Restore the object info from the stack [7/9/2007 Black]
   mCurrentNewObject = mObjectCreationStack[--mObjectCreationStackIndex].newObject;
   mFailJump = mObjectCreationStack[mObjectCreationStackIndex].failJump;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_jmpiffnot(U32 &ip)
{
   if (floatStack[_FLT--])
   {
      ip++;
      return OPCodeReturn::success;
   }
   ip = mCodeBlock->code[ip];
   return OPCodeReturn::success;
}


OPCodeReturn CodeInterpreter::op_jmpifnot(U32 &ip)
{
   if (intStack[_UINT--])
   {
      ip++;
      return OPCodeReturn::success;
   }
   ip = mCodeBlock->code[ip];
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_jmpiff(U32 &ip)
{
   if (!floatStack[_FLT--])
   {
      ip++;
      return OPCodeReturn::success;
   }
   ip = mCodeBlock->code[ip];
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_jmpif(U32 &ip)
{
   if (!intStack[_UINT--])
   {
      ip++;
      return OPCodeReturn::success;
   }
   ip = mCodeBlock->code[ip];
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_jmpifnot_np(U32 &ip)
{
   if (intStack[_UINT])
   {
      _UINT--;
      ip++;
      return OPCodeReturn::success;
   }
   ip = mCodeBlock->code[ip];
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_jmpif_np(U32 &ip)
{
   if (!intStack[_UINT])
   {
      _UINT--;
      ip++;
      return OPCodeReturn::success;
   }
   ip = mCodeBlock->code[ip];
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_jmp(U32 &ip)
{
   ip = mCodeBlock->code[ip];
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_return_void(U32 &ip)
{
   STR.setStringValue("");
   // We're falling thru here on purpose.

   OPCodeReturn ret = op_return(ip);

   return ret;
}

OPCodeReturn CodeInterpreter::op_return(U32 &ip)
{
   StringStackPtr retValue = STR.getStringValuePtr();

   if (mIterDepth > 0)
   {
      // Clear iterator state.
      while (mIterDepth > 0)
      {
         iterStack[--_ITER].mIsStringIter = false;
         --mIterDepth;
      }

      STR.rewind();
      STR.setStringValue(StringStackPtrRef(retValue).getPtr(&STR)); // Not nice but works.
      retValue = STR.getStringValuePtr();
   }

   // Previously the return value was on the stack and would be returned using STR.getStringValue().
   // Now though we need to wrap it in a ConsoleValueRef 
   mReturnValue.value = CSTK.pushStringStackPtr(retValue);

   return OPCodeReturn::exitCode;
}

OPCodeReturn CodeInterpreter::op_return_flt(U32 &ip)
{
   if (mIterDepth > 0)
   {
      // Clear iterator state.
      while (mIterDepth > 0)
      {
         iterStack[--_ITER].mIsStringIter = false;
         --mIterDepth;
      }

   }

   mReturnValue.value = CSTK.pushFLT(floatStack[_FLT]);
   _FLT--;

   return OPCodeReturn::exitCode;
}

OPCodeReturn CodeInterpreter::op_return_uint(U32 &ip)
{
   if (mIterDepth > 0)
   {
      // Clear iterator state.
      while (mIterDepth > 0)
      {
         iterStack[--_ITER].mIsStringIter = false;
         --mIterDepth;
      }
   }

   mReturnValue.value = CSTK.pushUINT(intStack[_UINT]);
   _UINT--;

   return OPCodeReturn::exitCode;
}

OPCodeReturn CodeInterpreter::op_cmpeq(U32 &ip)
{
   intStack[_UINT + 1] = bool(floatStack[_FLT] == floatStack[_FLT - 1]);
   _UINT++;
   _FLT -= 2;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_cmpgr(U32 &ip)
{
   intStack[_UINT + 1] = bool(floatStack[_FLT] > floatStack[_FLT - 1]);
   _UINT++;
   _FLT -= 2;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_cmpge(U32 &ip)
{
   intStack[_UINT + 1] = bool(floatStack[_FLT] >= floatStack[_FLT - 1]);
   _UINT++;
   _FLT -= 2;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_cmplt(U32 &ip)
{
   intStack[_UINT + 1] = bool(floatStack[_FLT] < floatStack[_FLT - 1]);
   _UINT++;
   _FLT -= 2;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_cmple(U32 &ip)
{
   intStack[_UINT + 1] = bool(floatStack[_FLT] <= floatStack[_FLT - 1]);
   _UINT++;
   _FLT -= 2;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_cmpne(U32 &ip)
{
   intStack[_UINT + 1] = bool(floatStack[_FLT] != floatStack[_FLT - 1]);
   _UINT++;
   _FLT -= 2;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_xor(U32 &ip)
{
   intStack[_UINT - 1] = intStack[_UINT] ^ intStack[_UINT - 1];
   _UINT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_mod(U32 &ip)
{
   if (intStack[_UINT - 1] != 0)
      intStack[_UINT - 1] = intStack[_UINT] % intStack[_UINT - 1];
   else
      intStack[_UINT - 1] = 0;
   _UINT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_bitand(U32 &ip)
{
   intStack[_UINT - 1] = intStack[_UINT] & intStack[_UINT - 1];
   _UINT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_bitor(U32 &ip)
{
   intStack[_UINT - 1] = intStack[_UINT] | intStack[_UINT - 1];
   _UINT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_not(U32 &ip)
{
   intStack[_UINT] = !intStack[_UINT];
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_notf(U32 &ip)
{
   intStack[_UINT + 1] = !floatStack[_FLT];
   _FLT--;
   _UINT++;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_onescomplement(U32 &ip)
{
   intStack[_UINT] = ~intStack[_UINT];
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_shr(U32 &ip)
{
   intStack[_UINT - 1] = intStack[_UINT] >> intStack[_UINT - 1];
   _UINT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_shl(U32 &ip)
{
   intStack[_UINT - 1] = intStack[_UINT] << intStack[_UINT - 1];
   _UINT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_and(U32 &ip)
{
   intStack[_UINT - 1] = intStack[_UINT] && intStack[_UINT - 1];
   _UINT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_or(U32 &ip)
{
   intStack[_UINT - 1] = intStack[_UINT] || intStack[_UINT - 1];
   _UINT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_add(U32 &ip)
{
   floatStack[_FLT - 1] = floatStack[_FLT] + floatStack[_FLT - 1];
   _FLT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_sub(U32 &ip)
{
   floatStack[_FLT - 1] = floatStack[_FLT] - floatStack[_FLT - 1];
   _FLT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_mul(U32 &ip)
{
   floatStack[_FLT - 1] = floatStack[_FLT] * floatStack[_FLT - 1];
   _FLT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_div(U32 &ip)
{
   floatStack[_FLT - 1] = floatStack[_FLT] / floatStack[_FLT - 1];
   _FLT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_neg(U32 &ip)
{
   floatStack[_FLT] = -floatStack[_FLT];
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_inc(U32 &ip)
{
   StringTableEntry var = CodeToSTE(mCodeBlock->code, ip);
   ip += 2;

   // If a variable is set, then these must be NULL. It is necessary
   // to set this here so that the vector parser can appropriately
   // identify whether it's dealing with a vector.
   mPrevField = NULL;
   mPrevObject = NULL;
   mCurObject = NULL;

   gEvalState.setCurVarNameCreate(var);

   // In order to let docblocks work properly with variables, we have
   // clear the current docblock when we do an assign. This way it 
   // won't inappropriately carry forward to following function decls.
   mCurFNDocBlock = NULL;
   mCurNSDocBlock = NULL;

   F64 val = gEvalState.getFloatVariable() + 1.0;
   gEvalState.setFloatVariable(val);

   // We gotta push val onto the stack. What if we have
   // more expressions that have to use this.
   // If we don't, we send out an op code to pop it.
   floatStack[_FLT + 1] = val;
   _FLT++;

   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_dec(U32 &ip)
{
   StringTableEntry var = CodeToSTE(mCodeBlock->code, ip);
   ip += 2;

   // If a variable is set, then these must be NULL. It is necessary
   // to set this here so that the vector parser can appropriately
   // identify whether it's dealing with a vector.
   mPrevField = NULL;
   mPrevObject = NULL;
   mCurObject = NULL;

   gEvalState.setCurVarNameCreate(var);

   // In order to let docblocks work properly with variables, we have
   // clear the current docblock when we do an assign. This way it 
   // won't inappropriately carry forward to following function decls.
   mCurFNDocBlock = NULL;
   mCurNSDocBlock = NULL;

   F64 val = gEvalState.getFloatVariable() - 1.0;
   gEvalState.setFloatVariable(val);

   // We gotta push val onto the stack. What if we have
   // more expressions that have to use this.
   // If we don't, we send out an op code to pop it.
   floatStack[_FLT + 1] = val;
   _FLT++;

   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurvar(U32 &ip)
{
   StringTableEntry var = CodeToSTE(mCodeBlock->code, ip);
   ip += 2;

   // If a variable is set, then these must be NULL. It is necessary
   // to set this here so that the vector parser can appropriately
   // identify whether it's dealing with a vector.
   mPrevField = NULL;
   mPrevObject = NULL;
   mCurObject = NULL;

   gEvalState.setCurVarName(var);

   // In order to let docblocks work properly with variables, we have
   // clear the current docblock when we do an assign. This way it 
   // won't inappropriately carry forward to following function decls.
   mCurFNDocBlock = NULL;
   mCurNSDocBlock = NULL;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurvar_create(U32 &ip)
{
   StringTableEntry var = CodeToSTE(mCodeBlock->code, ip);
   ip += 2;

   // See OP_SETCURVAR
   mPrevField = NULL;
   mPrevObject = NULL;
   mCurObject = NULL;

   gEvalState.setCurVarNameCreate(var);

   // See OP_SETCURVAR for why we do this.
   mCurFNDocBlock = NULL;
   mCurNSDocBlock = NULL;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurvar_array(U32 &ip)
{
   StringTableEntry var = STR.getSTValue();

   // See OP_SETCURVAR
   mPrevField = NULL;
   mPrevObject = NULL;
   mCurObject = NULL;

   gEvalState.setCurVarName(var);

   // See OP_SETCURVAR for why we do this.
   mCurFNDocBlock = NULL;
   mCurNSDocBlock = NULL;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurvar_array_varlookup(U32 &ip)
{
   StringTableEntry arrayName = CodeToSTE(mCodeBlock->code, ip);
   StringTableEntry arrayLookup = CodeToSTE(mCodeBlock->code, ip + 2);
   ip += 4;

   STR.setStringValue(arrayName);
   STR.advance();

   // See OP_SETCURVAR
   mPrevField = NULL;
   mPrevObject = NULL;
   mCurObject = NULL;

   // resolve arrayLookup to get the 'value'
   // Note: we have to setCurVarNameCreate in case the var doesn't exist.
   // this won't cause much of a performance hit since vars are hashed.
   gEvalState.setCurVarNameCreate(arrayLookup);
   StringTableEntry hash = gEvalState.getStringVariable();

   STR.setStringValue(hash);
   STR.rewind();

   // Generate new array name.
   StringTableEntry var = STR.getSTValue();
   gEvalState.setCurVarName(var);

   // See OP_SETCURVAR for why we do this.
   mCurFNDocBlock = NULL;
   mCurNSDocBlock = NULL;

   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurvar_array_create(U32 &ip)
{
   StringTableEntry var = STR.getSTValue();

   // See OP_SETCURVAR
   mPrevField = NULL;
   mPrevObject = NULL;
   mCurObject = NULL;

   gEvalState.setCurVarNameCreate(var);

   // See OP_SETCURVAR for why we do this.
   mCurFNDocBlock = NULL;
   mCurNSDocBlock = NULL;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurvar_array_create_varlookup(U32 &ip)
{
   StringTableEntry arrayName = CodeToSTE(mCodeBlock->code, ip);
   StringTableEntry arrayLookup = CodeToSTE(mCodeBlock->code, ip + 2);
   ip += 4;

   // See OP_SETCURVAR
   mPrevField = NULL;
   mPrevObject = NULL;
   mCurObject = NULL;

   STR.setStringValue(arrayName);
   STR.advance();

   // resolve arrayLookup to get the 'value'
   // Note: we have to setCurVarNameCreate in case the var doesn't exist.
   // this won't cause much of a performance hit since vars are hashed.
   gEvalState.setCurVarNameCreate(arrayLookup);
   StringTableEntry hash = gEvalState.getStringVariable();

   STR.setStringValue(hash);
   STR.rewind();

   // Generate new array name.
   StringTableEntry var = STR.getSTValue();
   gEvalState.setCurVarNameCreate(var);

   // See OP_SETCURVAR for why we do this.
   mCurFNDocBlock = NULL;
   mCurNSDocBlock = NULL;

   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_loadvar_uint(U32 &ip)
{
   intStack[_UINT + 1] = gEvalState.getIntVariable();
   _UINT++;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_loadvar_flt(U32 &ip)
{
   floatStack[_FLT + 1] = gEvalState.getFloatVariable();
   _FLT++;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_loadvar_str(U32 &ip)
{
   StringTableEntry val = gEvalState.getStringVariable();
   STR.setStringValue(val);
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_loadvar_var(U32 &ip)
{
   // Sets current source of OP_SAVEVAR_VAR
   gEvalState.copyVariable = gEvalState.currentVariable;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_savevar_uint(U32 &ip)
{
   gEvalState.setIntVariable(intStack[_UINT]);
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_savevar_flt(U32 &ip)
{
   gEvalState.setFloatVariable(floatStack[_FLT]);
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_savevar_str(U32 &ip)
{
   gEvalState.setStringVariable(STR.getStringValue());
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_savevar_var(U32 &ip)
{
   // this basically handles %var1 = %var2
   gEvalState.setCopyVariable();
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurobject(U32 &ip)
{
   // Save the previous object for parsing vector fields.
   mPrevObject = mCurObject;
   StringTableEntry val = STR.getStringValue();

   // Sim::findObject will sometimes find valid objects from
   // multi-component strings. This makes sure that doesn't
   // happen.
   for (const char* check = val; *check; check++)
   {
      if (*check == ' ')
      {
         val = "";
         break;
      }
   }
   mCurObject = Sim::findObject(val);
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurobject_internal(U32 &ip)
{
   ++ip; // To skip the recurse flag if the object wasn't found
   if (mCurObject)
   {
      SimSet *set = dynamic_cast<SimSet *>(mCurObject);
      if (set)
      {
         StringTableEntry intName = StringTable->insert(STR.getStringValue());
         bool recurse = mCodeBlock->code[ip - 1];
         SimObject *obj = set->findObjectByInternalName(intName, recurse);
         intStack[_UINT + 1] = obj ? obj->getId() : 0;
         _UINT++;
      }
      else
      {
         Con::errorf(ConsoleLogEntry::Script, "%s: Attempt to use -> on non-set %s of class %s.", mCodeBlock->getFileLine(ip - 2), mCurObject->getName(), mCurObject->getClassName());
         intStack[_UINT] = 0;
      }
   }
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurobject_new(U32 &ip)
{
   mCurObject = mCurrentNewObject;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurfield(U32 &ip)
{
   // Save the previous field for parsing vector fields.
   mPrevField = mCurField;
   dStrcpy(prevFieldArray, curFieldArray, 256);
   mCurField = CodeToSTE(mCodeBlock->code, ip);
   curFieldArray[0] = 0;
   ip += 2;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurfield_array(U32 &ip)
{
   dStrcpy(curFieldArray, STR.getStringValue(), 256);
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurfield_type(U32 &ip)
{
   if (mCurObject)
      mCurObject->setDataFieldType(mCodeBlock->code[ip], mCurField, curFieldArray);
   ip++;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurfield_array_var(U32 &ip)
{
   StringTableEntry var = CodeToSTE(mCodeBlock->code, ip);
   ip += 2;

   // We set the current var name (create it as well in case if it doesn't exist,
   // otherwise we will crash).
   gEvalState.setCurVarNameCreate(var);

   // Then load the var and copy the contents to the current field array
   dStrncpy(curFieldArray, gEvalState.currentVariable->getStringValue(), sizeof(curFieldArray));

   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_setcurfield_this(U32 &ip)
{
   // set the 'this pointer' as the current object.
   mCurObject = mThisObject;

   mPrevField = mCurField;
   dStrcpy(prevFieldArray, curFieldArray, 256);
   mCurField = CodeToSTE(mCodeBlock->code, ip);
   curFieldArray[0] = 0;
   ip += 2;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_loadfield_uint(U32 &ip)
{
   if (mCurObject)
      intStack[_UINT + 1] = U32(dAtoi(mCurObject->getDataField(mCurField, curFieldArray)));
   else
   {
      // The field is not being retrieved from an object. Maybe it's
      // a special accessor?
      char buff[FieldBufferSizeNumeric];
      memset(buff, 0, sizeof(buff));
      getFieldComponent(mPrevObject, mPrevField, prevFieldArray, mCurField, buff);
      intStack[_UINT + 1] = dAtoi(buff);
   }
   _UINT++;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_loadfield_flt(U32 &ip)
{
   if (mCurObject)
      floatStack[_FLT + 1] = dAtof(mCurObject->getDataField(mCurField, curFieldArray));
   else
   {
      // The field is not being retrieved from an object. Maybe it's
      // a special accessor?
      char buff[FieldBufferSizeNumeric];
      memset(buff, 0, sizeof(buff));
      getFieldComponent(mPrevObject, mPrevField, prevFieldArray, mCurField, buff);
      floatStack[_FLT + 1] = dAtof(buff);
   }
   _FLT++;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_loadfield_str(U32 &ip)
{
   if (mCurObject)
   {
      StringTableEntry val = mCurObject->getDataField(mCurField, curFieldArray);
      STR.setStringValue(val);
   }
   else
   {
      // The field is not being retrieved from an object. Maybe it's
      // a special accessor?
      char buff[FieldBufferSizeString];
      memset(buff, 0, sizeof(buff));
      getFieldComponent(mPrevObject, mPrevField, prevFieldArray, mCurField, buff);
      STR.setStringValue(buff);
   }
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_savefield_uint(U32 &ip)
{
   STR.setIntValue(intStack[_UINT]);
   if (mCurObject)
      mCurObject->setDataField(mCurField, curFieldArray, STR.getStringValue());
   else
   {
      // The field is not being set on an object. Maybe it's
      // a special accessor?
      setFieldComponent(mPrevObject, mPrevField, prevFieldArray, mCurField);
      mPrevObject = NULL;
   }
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_savefield_flt(U32 &ip)
{
   STR.setFloatValue(floatStack[_FLT]);
   if (mCurObject)
      mCurObject->setDataField(mCurField, curFieldArray, STR.getStringValue());
   else
   {
      // The field is not being set on an object. Maybe it's
      // a special accessor?
      setFieldComponent(mPrevObject, mPrevField, prevFieldArray, mCurField);
      mPrevObject = NULL;
   }
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_savefield_str(U32 &ip)
{
   if (mCurObject)
      mCurObject->setDataField(mCurField, curFieldArray, STR.getStringValue());
   else
   {
      // The field is not being set on an object. Maybe it's
      // a special accessor?
      setFieldComponent(mPrevObject, mPrevField, prevFieldArray, mCurField);
      mPrevObject = NULL;
   }
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_str_to_uint(U32 &ip)
{
   intStack[_UINT + 1] = STR.getIntValue();
   _UINT++;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_str_to_flt(U32 &ip)
{
   floatStack[_FLT + 1] = STR.getFloatValue();
   _FLT++;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_str_to_none(U32 &ip)
{
   // This exists simply to deal with certain typecast situations.
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_flt_to_uint(U32 &ip)
{
   intStack[_UINT + 1] = (S64)floatStack[_FLT];
   _FLT--;
   _UINT++;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_flt_to_str(U32 &ip)
{
   STR.setFloatValue(floatStack[_FLT]);
   _FLT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_flt_to_none(U32 &ip)
{
   _FLT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_uint_to_flt(U32 &ip)
{
   floatStack[_FLT + 1] = (F32)intStack[_UINT];
   _UINT--;
   _FLT++;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_uint_to_str(U32 &ip)
{
   STR.setIntValue(intStack[_UINT]);
   _UINT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_uint_to_none(U32 &ip)
{
   _UINT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_copyvar_to_none(U32 &ip)
{
   gEvalState.copyVariable = NULL;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_loadimmed_uint(U32 &ip)
{
   intStack[_UINT + 1] = mCodeBlock->code[ip++];
   _UINT++;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_loadimmed_flt(U32 &ip)
{
   floatStack[_FLT + 1] = mCurFloatTable[mCodeBlock->code[ip]];
   ip++;
   _FLT++;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_tag_to_str(U32 &ip)
{
   mCodeBlock->code[ip - 1] = OP_LOADIMMED_STR;
   // it's possible the string has already been converted
   if (U8(mCurStringTable[mCodeBlock->code[ip]]) != StringTagPrefixByte)
   {
      U32 id = GameAddTaggedString(mCurStringTable + mCodeBlock->code[ip]);
      dSprintf(mCurStringTable + mCodeBlock->code[ip] + 1, 7, "%d", id);
      *(mCurStringTable + mCodeBlock->code[ip]) = StringTagPrefixByte;
   }

   // Fallthrough
   OPCodeReturn ret = op_loadimmed_str(ip);

   return ret;
}

OPCodeReturn CodeInterpreter::op_loadimmed_str(U32 &ip)
{
   STR.setStringValue(mCurStringTable + mCodeBlock->code[ip++]);
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_docblock_str(U32 &ip)
{
   // If the first word of the doc is '\class' or '@class', then this
   // is a namespace doc block, otherwise it is a function doc block.
   const char* docblock = mCurStringTable + mCodeBlock->code[ip++];

   const char* sansClass = dStrstr(docblock, "@class");
   if (!sansClass)
      sansClass = dStrstr(docblock, "\\class");

   if (sansClass)
   {
      // Don't save the class declaration. Scan past the 'class'
      // keyword and up to the first whitespace.
      sansClass += 7;
      S32 index = 0;
      while ((*sansClass != ' ') && (*sansClass != '\n') && *sansClass && (index < (nsDocLength - 1)))
      {
         mNSDocBlockClass[index++] = *sansClass;
         sansClass++;
      }
      mNSDocBlockClass[index] = '\0';

      mCurNSDocBlock = sansClass + 1;
   }
   else
      mCurFNDocBlock = docblock;

   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_loadimmed_ident(U32 &ip)
{
   STR.setStringValue(CodeToSTE(mCodeBlock->code, ip));
   ip += 2;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_callfunc_resolve(U32 &ip)
{
   // This deals with a function that is potentially living in a namespace.
   StringTableEntry fnNamespace = CodeToSTE(mCodeBlock->code, ip + 2);
   StringTableEntry fnName = CodeToSTE(mCodeBlock->code, ip);

   // Try to look it up.
   mNSEntry = Namespace::find(fnNamespace)->lookup(fnName);
   if (!CInterface::GetCInterface().isMethod(fnNamespace, fnName) && !mNSEntry)
   {
      ip += 5;
      Con::warnf(ConsoleLogEntry::General,
         "%s: Unable to find function %s%s%s",
         mCodeBlock->getFileLine(ip - 7), fnNamespace ? fnNamespace : "",
         fnNamespace ? "::" : "", fnName);
      STR.popFrame();
      CSTK.popFrame();
      return OPCodeReturn::success;
   }

   // Fallthrough to op_callfunc_resolve
   OPCodeReturn ret = op_callfunc(ip);

   return ret;
}

OPCodeReturn CodeInterpreter::op_callfunc(U32 &ip)
{
   // This routingId is set when we query the object as to whether
   // it handles this method.  It is set to an enum from the table
   // above indicating whether it handles it on a component it owns
   // or just on the object.
   S32 routingId = 0;

   U32 *code = mCodeBlock->code;

   StringTableEntry fnNamespace = CodeToSTE(mCodeBlock->code, ip + 2);
   StringTableEntry fnName = CodeToSTE(code, ip);

   //if this is called from inside a function, append the ip and codeptr
   if (gEvalState.getStackDepth() > 0)
   {
      gEvalState.getCurrentFrame().code = mCodeBlock;
      gEvalState.getCurrentFrame().ip = ip - 1;
   }

   U32 callType = code[ip + 4];

   ip += 5;
   CSTK.getArgcArgv(fnName, &mCallArgc, &mCallArgv);

   const char *componentReturnValue = "";
   Namespace *ns = NULL;

   bool cFunctionRes = false;
   const char* cRetRes = NULL;

   if (callType == FuncCallExprNode::FunctionCall)
   {
      if (!mNSEntry)
         mNSEntry = Namespace::global()->lookup(fnName);

      StringStackWrapper args(mCallArgc, mCallArgv);
      cRetRes = CInterface::GetCInterface().CallFunction(fnNamespace, fnName, args.argv, args.argc, &cFunctionRes);
   }
   else if (callType == FuncCallExprNode::MethodCall)
   {
      mSaveObject = gEvalState.thisObject;
      gEvalState.thisObject = Sim::findObject((const char*)mCallArgv[1]);
      if (!gEvalState.thisObject)
      {
         // Go back to the previous saved object.
         gEvalState.thisObject = mSaveObject;

         Con::warnf(ConsoleLogEntry::General, "%s: Unable to find object: '%s' attempting to call function '%s'", mCodeBlock->getFileLine(ip - 4), (const char*)mCallArgv[1], fnName);
         STR.popFrame();
         CSTK.popFrame();
         STR.setStringValue("");
         return OPCodeReturn::success;
      }

      bool handlesMethod = gEvalState.thisObject->handlesConsoleMethod(fnName, &routingId);
      if (handlesMethod && routingId == MethodOnComponent)
      {
         ICallMethod *pComponent = dynamic_cast<ICallMethod *>(gEvalState.thisObject);
         if (pComponent)
            componentReturnValue = pComponent->callMethodArgList(mCallArgc, mCallArgv, false);
      }

      ns = gEvalState.thisObject->getNamespace();
      if (ns)
         mNSEntry = ns->lookup(fnName);
      else
         mNSEntry = NULL;

      StringStackWrapper args(mCallArgc, mCallArgv);
      cRetRes = CInterface::GetCInterface().CallMethod(gEvalState.thisObject, fnName, args.argv, args.argc, &cFunctionRes);
   }
   else // it's a ParentCall
   {
      if (mExec.thisNamespace)
      {
         ns = mExec.thisNamespace->mParent;
         if (ns)
            mNSEntry = ns->lookup(fnName);
         else
            mNSEntry = NULL;
      }
      else
      {
         ns = NULL;
         mNSEntry = NULL;
      }
   }

   Namespace::Entry::CallbackUnion * nsCb = NULL;
   const char * nsUsage = NULL;
   if (mNSEntry)
   {
      nsCb = &mNSEntry->cb;
      nsUsage = mNSEntry->mUsage;
      routingId = 0;
   }
   if (!cFunctionRes && (!mNSEntry || mExec.noCalls))
   {
      if (!mExec.noCalls && !(routingId == MethodOnComponent))
      {
         if (callType == FuncCallExprNode::MethodCall)
         {
            if (gEvalState.thisObject != NULL)
            {
               // Try to use the name instead of the id
               StringTableEntry name = gEvalState.thisObject->getName() ? gEvalState.thisObject->getName() : gEvalState.thisObject->getIdString();
               Con::warnf(ConsoleLogEntry::General, "%s: Unknown method %s.%s Namespace List: %s", mCodeBlock->getFileLine(ip - 6), name, fnName, Con::getNamespaceList(ns));
            }
            else
            {
               // NULL.
               Con::warnf(ConsoleLogEntry::General, "%s: Unknown method NULL.%s", mCodeBlock->getFileLine(ip - 6), fnName);
            }
         }
         else if (callType == FuncCallExprNode::ParentCall)
         {
            Con::warnf(ConsoleLogEntry::General, "%s: Unknown parent call %s.", mCodeBlock->getFileLine(ip - 6), fnName);
         }
         else 
         {
            Con::warnf(ConsoleLogEntry::General, "%s: Unknown function %s.", mCodeBlock->getFileLine(ip - 6), fnName);
         }
      }
      STR.popFrame();
      CSTK.popFrame();

      if (routingId == MethodOnComponent)
         STR.setStringValue(componentReturnValue);
      else
         STR.setStringValue("");
      return OPCodeReturn::success;
   }

   // ConsoleFunctionType is for any function defined by script.
   // Any 'callback' type is an engine function that is exposed to script.
   if (mNSEntry->mType == Namespace::Entry::ConsoleFunctionType
      || cFunctionRes)
   {
      ConsoleValueRef ret;
      if (cFunctionRes)
      {
         StringStackConsoleWrapper retVal(1, &cRetRes);
         ret = retVal.argv[0];
      }
      else if (mNSEntry->mFunctionOffset)
      {
         ret = mNSEntry->mCode->exec(mNSEntry->mFunctionOffset, fnName, mNSEntry->mNamespace, mCallArgc, mCallArgv, false, mNSEntry->mPackage);
      }

      STR.popFrame();
      // Functions are assumed to return strings, so look ahead to see if we can skip the conversion
      if (code[ip] == OP_STR_TO_UINT)
      {
         ip++;
         intStack[++_UINT] = (U32)((S32)ret);
      }
      else if (code[ip] == OP_STR_TO_FLT)
      {
         ip++;
         floatStack[++_FLT] = (F32)ret;
      }
      else if (code[ip] == OP_STR_TO_NONE)
      {
         STR.setStringValue(ret.getStringValue());
         ip++;
      }
      else
         STR.setStringValue((const char*)ret);

      // This will clear everything including returnValue
      CSTK.popFrame();
      //STR.clearFunctionOffset();
   }
   else
   {
      const char* nsName = ns ? ns->mName : "";
#ifndef TORQUE_DEBUG
      // [tom, 12/13/2006] This stops tools functions from working in the console,
      // which is useful behavior when debugging so I'm ifdefing this out for debug builds.
      if (mNSEntry->mToolOnly && !Con::isCurrentScriptToolScript())
      {
         Con::errorf(ConsoleLogEntry::Script, "%s: %s::%s - attempting to call tools only function from outside of tools.", mCodeBlock->getFileLine(ip - 6), nsName, fnName);
      }
      else
#endif
      if ((mNSEntry->mMinArgs && S32(mCallArgc) < mNSEntry->mMinArgs) || (mNSEntry->mMaxArgs && S32(mCallArgc) > mNSEntry->mMaxArgs))
      {
         Con::warnf(ConsoleLogEntry::Script, "%s: %s::%s - wrong number of arguments (got %i, expected min %i and max %i).",
            mCodeBlock->getFileLine(ip - 6), nsName, fnName,
            mCallArgc, mNSEntry->mMinArgs, mNSEntry->mMaxArgs);
         Con::warnf(ConsoleLogEntry::Script, "%s: usage: %s", mCodeBlock->getFileLine(ip - 6), mNSEntry->mUsage);
         STR.popFrame();
         CSTK.popFrame();
      }
      else
      {
         switch (mNSEntry->mType)
         {
         case Namespace::Entry::StringCallbackType:
         {
            const char *ret = mNSEntry->cb.mStringCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
            STR.popFrame();
            CSTK.popFrame();
            if (ret != STR.getStringValue())
               STR.setStringValue(ret);
            //else
            //   sSTR.setLen(dStrlen(ret));
            break;
         }
         case Namespace::Entry::IntCallbackType:
         {
            S32 result = mNSEntry->cb.mIntCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
            STR.popFrame();
            CSTK.popFrame();
            if (code[ip] == OP_STR_TO_UINT)
            {
               ip++;
               intStack[++_UINT] = result;
               break;
            }
            else if (code[ip] == OP_STR_TO_FLT)
            {
               ip++;
               floatStack[++_FLT] = result;
               break;
            }
            else if (code[ip] == OP_STR_TO_NONE)
               ip++;
            else
               STR.setIntValue(result);
            break;
         }
         case Namespace::Entry::FloatCallbackType:
         {
            F64 result = mNSEntry->cb.mFloatCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
            STR.popFrame();
            CSTK.popFrame();
            if (code[ip] == OP_STR_TO_UINT)
            {
               ip++;
               intStack[++_UINT] = (S64)result;
               break;
            }
            else if (code[ip] == OP_STR_TO_FLT)
            {
               ip++;
               floatStack[++_FLT] = result;
               break;
            }
            else if (code[ip] == OP_STR_TO_NONE)
               ip++;
            else
               STR.setFloatValue(result);
            break;
         }
         case Namespace::Entry::VoidCallbackType:
            mNSEntry->cb.mVoidCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
            if (code[ip] != OP_STR_TO_NONE && Con::getBoolVariable("$Con::warnVoidAssignment", true))
               Con::warnf(ConsoleLogEntry::General, "%s: Call to %s in %s uses result of void function call.", mCodeBlock->getFileLine(ip - 6), fnName, mExec.functionName);

            STR.popFrame();
            CSTK.popFrame();
            STR.setStringValue("");
            break;
         case Namespace::Entry::BoolCallbackType:
         {
            bool result = mNSEntry->cb.mBoolCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
            STR.popFrame();
            CSTK.popFrame();
            if (code[ip] == OP_STR_TO_UINT)
            {
               ip++;
               intStack[++_UINT] = result;
               break;
            }
            else if (code[ip] == OP_STR_TO_FLT)
            {
               ip++;
               floatStack[++_FLT] = result;
               break;
            }
            else if (code[ip] == OP_STR_TO_NONE)
               ip++;
            else
               STR.setIntValue(result);
            break;
         }
         }
      }
   }

   if (callType == FuncCallExprNode::MethodCall)
      gEvalState.thisObject = mSaveObject;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_callfunc_pointer(U32 &ip)
{
   // get function name. This is the 'function pointer'.
   StringTableEntry fnName = StringTable->insert(STR.getStringValue());

   U32 *code = mCodeBlock->code;

   mNSEntry = Namespace::global()->lookup(fnName);

   //if this is called from inside a function, append the ip and codeptr
   if (gEvalState.getStackDepth() > 0)
   {
      gEvalState.getCurrentFrame().code = mCodeBlock;
      gEvalState.getCurrentFrame().ip = ip - 1;
   }

   CSTK.getArgcArgv(fnName, &mCallArgc, &mCallArgv);


   if (!mNSEntry || mExec.noCalls)
   {
      if (!mExec.noCalls)
      {
         Con::warnf(ConsoleLogEntry::General, "%s: Unknown function %s.", mCodeBlock->getFileLine(ip - 6), fnName);
      }
      STR.popFrame();
      CSTK.popFrame();

      STR.setStringValue("");
      return OPCodeReturn::success;
   }

   // ConsoleFunctionType is for any function defined by script.
   // Any 'callback' type is an engine function that is exposed to script.
   if (mNSEntry->mType == Namespace::Entry::ConsoleFunctionType)
   {
      ConsoleValueRef ret;
      if (mNSEntry->mFunctionOffset)
         ret = mNSEntry->mCode->exec(mNSEntry->mFunctionOffset, fnName, mNSEntry->mNamespace, mCallArgc, mCallArgv, false, mNSEntry->mPackage);

      STR.popFrame();
      // Functions are assumed to return strings, so look ahead to see if we can skip the conversion
      if (code[ip] == OP_STR_TO_UINT)
      {
         ip++;
         intStack[++_UINT] = (U32)((S32)ret);
      }
      else if (code[ip] == OP_STR_TO_FLT)
      {
         ip++;
         floatStack[++_FLT] = (F32)ret;
      }
      else if (code[ip] == OP_STR_TO_NONE)
      {
         STR.setStringValue(ret.getStringValue());
         ip++;
      }
      else
         STR.setStringValue((const char*)ret);

      // This will clear everything including returnValue
      CSTK.popFrame();
      //STR.clearFunctionOffset();
   }
   else
   {
      const char* nsName = "";

#ifndef TORQUE_DEBUG
      // [tom, 12/13/2006] This stops tools functions from working in the console,
      // which is useful behavior when debugging so I'm ifdefing this out for debug builds.
      if (mNSEntry->mToolOnly && !Con::isCurrentScriptToolScript())
      {
         Con::errorf(ConsoleLogEntry::Script, "%s: %s::%s - attempting to call tools only function from outside of tools.", mCodeBlock->getFileLine(ip - 6), nsName, fnName);
      }
      else
#endif
         if ((mNSEntry->mMinArgs && S32(mCallArgc) < mNSEntry->mMinArgs) || (mNSEntry->mMaxArgs && S32(mCallArgc) > mNSEntry->mMaxArgs))
         {
            Con::warnf(ConsoleLogEntry::Script, "%s: %s::%s - wrong number of arguments (got %i, expected min %i and max %i).",
               mCodeBlock->getFileLine(ip - 6), nsName, fnName,
               mCallArgc, mNSEntry->mMinArgs, mNSEntry->mMaxArgs);
            Con::warnf(ConsoleLogEntry::Script, "%s: usage: %s", mCodeBlock->getFileLine(ip - 6), mNSEntry->mUsage);
            STR.popFrame();
            CSTK.popFrame();
         }
         else
         {
            switch (mNSEntry->mType)
            {
            case Namespace::Entry::StringCallbackType:
            {
               const char *ret = mNSEntry->cb.mStringCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
               STR.popFrame();
               CSTK.popFrame();
               if (ret != STR.getStringValue())
                  STR.setStringValue(ret);
               //else
               //   sSTR.setLen(dStrlen(ret));
               break;
            }
            case Namespace::Entry::IntCallbackType:
            {
               S32 result = mNSEntry->cb.mIntCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
               STR.popFrame();
               CSTK.popFrame();
               if (code[ip] == OP_STR_TO_UINT)
               {
                  ip++;
                  intStack[++_UINT] = result;
                  break;
               }
               else if (code[ip] == OP_STR_TO_FLT)
               {
                  ip++;
                  floatStack[++_FLT] = result;
                  break;
               }
               else if (code[ip] == OP_STR_TO_NONE)
                  ip++;
               else
                  STR.setIntValue(result);
               break;
            }
            case Namespace::Entry::FloatCallbackType:
            {
               F64 result = mNSEntry->cb.mFloatCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
               STR.popFrame();
               CSTK.popFrame();
               if (code[ip] == OP_STR_TO_UINT)
               {
                  ip++;
                  intStack[++_UINT] = (S64)result;
                  break;
               }
               else if (code[ip] == OP_STR_TO_FLT)
               {
                  ip++;
                  floatStack[++_FLT] = result;
                  break;
               }
               else if (code[ip] == OP_STR_TO_NONE)
                  ip++;
               else
                  STR.setFloatValue(result);
               break;
            }
            case Namespace::Entry::VoidCallbackType:
               mNSEntry->cb.mVoidCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
               if (code[ip] != OP_STR_TO_NONE && Con::getBoolVariable("$Con::warnVoidAssignment", true))
                  Con::warnf(ConsoleLogEntry::General, "%s: Call to %s in %s uses result of void function call.", mCodeBlock->getFileLine(ip - 6), fnName, mExec.functionName);

               STR.popFrame();
               CSTK.popFrame();
               STR.setStringValue("");
               break;
            case Namespace::Entry::BoolCallbackType:
            {
               bool result = mNSEntry->cb.mBoolCallbackFunc(gEvalState.thisObject, mCallArgc, mCallArgv);
               STR.popFrame();
               CSTK.popFrame();
               if (code[ip] == OP_STR_TO_UINT)
               {
                  ip++;
                  intStack[++_UINT] = result;
                  break;
               }
               else if (code[ip] == OP_STR_TO_FLT)
               {
                  ip++;
                  floatStack[++_FLT] = result;
                  break;
               }
               else if (code[ip] == OP_STR_TO_NONE)
                  ip++;
               else
                  STR.setIntValue(result);
               break;
            }
            }
         }
   }


   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_callfunc_this(U32 &ip)
{
   U32 *code = mCodeBlock->code;

   StringTableEntry fnName = CodeToSTE(code, ip);

   //if this is called from inside a function, append the ip and codeptr
   if (gEvalState.getStackDepth() > 0)
   {
      gEvalState.getCurrentFrame().code = mCodeBlock;
      gEvalState.getCurrentFrame().ip = ip - 1;
   }

   ip += 2;
   CSTK.getArgcArgv(fnName, &mCallArgc, &mCallArgv);

   Namespace *ns = mThisObject ? mThisObject->getNamespace() : NULL;
   if (ns)
      mNSEntry = ns->lookup(fnName);
   else
      mNSEntry = NULL;

   if (!mNSEntry || mExec.noCalls)
   {
      if (!mExec.noCalls)
      {
         if (mThisObject)
         {
            // Try to use the name instead of the id
            StringTableEntry name = mThisObject->getName() ? mThisObject->getName() : mThisObject->getIdString();
            Con::warnf(ConsoleLogEntry::General, "%s: Unknown method %s.%s Namespace List: %s", mCodeBlock->getFileLine(ip - 6), name, fnName, Con::getNamespaceList(ns));
         }
         else
         {
            // At least let the scripter know that they access the object.
            Con::warnf(ConsoleLogEntry::General, "%s: Unknown method NULL.%s", mCodeBlock->getFileLine(ip - 6), fnName);
         }
      }
      STR.popFrame();
      CSTK.popFrame();

      STR.setStringValue("");
      return OPCodeReturn::success;
   }

   // ConsoleFunctionType is for any function defined by script.
   // Any 'callback' type is an engine function that is exposed to script.
   if (mNSEntry->mType == Namespace::Entry::ConsoleFunctionType)
   {
      ConsoleValueRef ret;
      if (mNSEntry->mFunctionOffset)
         ret = mNSEntry->mCode->exec(mNSEntry->mFunctionOffset, fnName, mNSEntry->mNamespace, mCallArgc, mCallArgv, false, mNSEntry->mPackage);

      STR.popFrame();
      // Functions are assumed to return strings, so look ahead to see if we can skip the conversion
      if (code[ip] == OP_STR_TO_UINT)
      {
         ip++;
         intStack[++_UINT] = (U32)((S32)ret);
      }
      else if (code[ip] == OP_STR_TO_FLT)
      {
         ip++;
         floatStack[++_FLT] = (F32)ret;
      }
      else if (code[ip] == OP_STR_TO_NONE)
      {
         STR.setStringValue(ret.getStringValue());
         ip++;
      }
      else
         STR.setStringValue((const char*)ret);

      // This will clear everything including returnValue
      CSTK.popFrame();
      //STR.clearFunctionOffset();
   }
   else
   {
      const char* nsName = ns ? ns->mName : "";
#ifndef TORQUE_DEBUG
      // [tom, 12/13/2006] This stops tools functions from working in the console,
      // which is useful behavior when debugging so I'm ifdefing this out for debug builds.
      if (mNSEntry->mToolOnly && !Con::isCurrentScriptToolScript())
      {
         Con::errorf(ConsoleLogEntry::Script, "%s: %s::%s - attempting to call tools only function from outside of tools.", mCodeBlock->getFileLine(ip - 6), nsName, fnName);
      }
      else
#endif
         if ((mNSEntry->mMinArgs && S32(mCallArgc) < mNSEntry->mMinArgs) || (mNSEntry->mMaxArgs && S32(mCallArgc) > mNSEntry->mMaxArgs))
         {
            Con::warnf(ConsoleLogEntry::Script, "%s: %s::%s - wrong number of arguments (got %i, expected min %i and max %i).",
               mCodeBlock->getFileLine(ip - 6), nsName, fnName,
               mCallArgc, mNSEntry->mMinArgs, mNSEntry->mMaxArgs);
            Con::warnf(ConsoleLogEntry::Script, "%s: usage: %s", mCodeBlock->getFileLine(ip - 6), mNSEntry->mUsage);
            STR.popFrame();
            CSTK.popFrame();
         }
         else
         {
            switch (mNSEntry->mType)
            {
            case Namespace::Entry::StringCallbackType:
            {
               const char *ret = mNSEntry->cb.mStringCallbackFunc(mThisObject, mCallArgc, mCallArgv);
               STR.popFrame();
               CSTK.popFrame();
               if (ret != STR.getStringValue())
                  STR.setStringValue(ret);
               //else
               //   sSTR.setLen(dStrlen(ret));
               break;
            }
            case Namespace::Entry::IntCallbackType:
            {
               S32 result = mNSEntry->cb.mIntCallbackFunc(mThisObject, mCallArgc, mCallArgv);
               STR.popFrame();
               CSTK.popFrame();
               if (code[ip] == OP_STR_TO_UINT)
               {
                  ip++;
                  intStack[++_UINT] = result;
                  break;
               }
               else if (code[ip] == OP_STR_TO_FLT)
               {
                  ip++;
                  floatStack[++_FLT] = result;
                  break;
               }
               else if (code[ip] == OP_STR_TO_NONE)
                  ip++;
               else
                  STR.setIntValue(result);
               break;
            }
            case Namespace::Entry::FloatCallbackType:
            {
               F64 result = mNSEntry->cb.mFloatCallbackFunc(mThisObject, mCallArgc, mCallArgv);
               STR.popFrame();
               CSTK.popFrame();
               if (code[ip] == OP_STR_TO_UINT)
               {
                  ip++;
                  intStack[++_UINT] = (S64)result;
                  break;
               }
               else if (code[ip] == OP_STR_TO_FLT)
               {
                  ip++;
                  floatStack[++_FLT] = result;
                  break;
               }
               else if (code[ip] == OP_STR_TO_NONE)
                  ip++;
               else
                  STR.setFloatValue(result);
               break;
            }
            case Namespace::Entry::VoidCallbackType:
               mNSEntry->cb.mVoidCallbackFunc(mThisObject, mCallArgc, mCallArgv);
               if (code[ip] != OP_STR_TO_NONE && Con::getBoolVariable("$Con::warnVoidAssignment", true))
                  Con::warnf(ConsoleLogEntry::General, "%s: Call to %s in %s uses result of void function call.", mCodeBlock->getFileLine(ip - 6), fnName, mExec.functionName);

               STR.popFrame();
               CSTK.popFrame();
               STR.setStringValue("");
               break;
            case Namespace::Entry::BoolCallbackType:
            {
               bool result = mNSEntry->cb.mBoolCallbackFunc(mThisObject, mCallArgc, mCallArgv);
               STR.popFrame();
               CSTK.popFrame();
               if (code[ip] == OP_STR_TO_UINT)
               {
                  ip++;
                  intStack[++_UINT] = result;
                  break;
               }
               else if (code[ip] == OP_STR_TO_FLT)
               {
                  ip++;
                  floatStack[++_FLT] = result;
                  break;
               }
               else if (code[ip] == OP_STR_TO_NONE)
                  ip++;
               else
                  STR.setIntValue(result);
               break;
            }
            }
         }
   }

   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_advance_str(U32 &ip)
{
   STR.advance();
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_advance_str_appendchar(U32 &ip)
{
   STR.advanceChar(mCodeBlock->code[ip++]);
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_advance_str_comma(U32 &ip)
{
   STR.advanceChar('_');
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_advance_str_nul(U32 &ip)
{
   STR.advanceChar(0);
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_rewind_str(U32 &ip)
{
   STR.rewind();
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_terminate_rewind_str(U32 &ip)
{
   STR.rewindTerminate();
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_compare_str(U32 &ip)
{
   intStack[++_UINT] = STR.compare();
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_push(U32 &ip)
{
   STR.push();
   CSTK.pushStringStackPtr(STR.getPreviousStringValuePtr());
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_push_uint(U32 &ip)
{
   CSTK.pushUINT(intStack[_UINT]);
   _UINT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_push_flt(U32 &ip)
{
   CSTK.pushFLT(floatStack[_FLT]);
   _FLT--;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_push_var(U32 &ip)
{
   if (gEvalState.currentVariable)
      CSTK.pushValue(gEvalState.currentVariable->value);
   else
      CSTK.pushString("");
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_push_this(U32 &ip)
{
   StringTableEntry varName = CodeToSTE(mCodeBlock->code, ip);
   ip += 2;

   // shorthand OP_SETCURVAR

   // If a variable is set, then these must be NULL. It is necessary
   // to set this here so that the vector parser can appropriately
   // identify whether it's dealing with a vector.
   mPrevField = NULL;
   mPrevObject = NULL;
   mCurObject = NULL;

   gEvalState.setCurVarName(varName);

   // In order to let docblocks work properly with variables, we have
   // clear the current docblock when we do an assign. This way it 
   // won't inappropriately carry forward to following function decls.
   mCurFNDocBlock = NULL;
   mCurNSDocBlock = NULL;

   // shorthand OP_LOADVAR_STR (since objs can be by name we can't assume uint)
   STR.setStringValue(gEvalState.getStringVariable());

   // shorthand OP_PUSH
   STR.push();
   CSTK.pushStringStackPtr(STR.getPreviousStringValuePtr());

   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_push_frame(U32 &ip)
{
   STR.pushFrame();
   CSTK.pushFrame();
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_assert(U32 &ip)
{
   if (!intStack[_UINT--])
   {
      const char *message = mCurStringTable + mCodeBlock->code[ip];

      U32 breakLine, inst;
      mCodeBlock->findBreakLine(ip - 1, breakLine, inst);

      if (PlatformAssert::processAssert(PlatformAssert::Fatal,
         mCodeBlock->name ? mCodeBlock->name : "eval",
         breakLine,
         message))
      {
         if (TelDebugger && TelDebugger->isConnected() && breakLine > 0)
         {
            TelDebugger->breakProcess();
         }
         else
            Platform::debugBreak();
      }
   }

   ip++;

   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_break(U32 &ip)
{
   //append the ip and codeptr before managing the breakpoint!
   AssertFatal(gEvalState.getStackDepth() > 0, "Empty eval stack on break!");
   gEvalState.getCurrentFrame().code = mCodeBlock;
   gEvalState.getCurrentFrame().ip = ip - 1;

   U32 breakLine;
   mCodeBlock->findBreakLine(ip - 1, breakLine, mCurrentInstruction);
   if (!breakLine)
      return OPCodeReturn::breakContinue;
   TelDebugger->executionStopped(mCodeBlock, breakLine);
   return OPCodeReturn::breakContinue;
}

OPCodeReturn CodeInterpreter::op_iter_begin_str(U32 &ip)
{
   iterStack[_ITER].mIsStringIter = true;

   // Emulate fallthrough:
   OPCodeReturn fallthrough = op_iter_begin(ip);

   return fallthrough;
}

OPCodeReturn CodeInterpreter::op_iter_begin(U32 &ip)
{
   StringTableEntry varName = CodeToSTE(mCodeBlock->code, ip);
   U32 failIp = mCodeBlock->code[ip + 2];

   IterStackRecord& iter = iterStack[_ITER];

   iter.mVariable = gEvalState.getCurrentFrame().add(varName);

   if (iter.mIsStringIter)
   {
      iter.mData.mStr.mString = STR.getStringValuePtr();
      iter.mData.mStr.mIndex = 0;
   }
   else
   {
      // Look up the object.

      SimSet* set;
      if (!Sim::findObject(STR.getStringValue(), set))
      {
         Con::errorf(ConsoleLogEntry::General, "No SimSet object '%s'", STR.getStringValue());
         Con::errorf(ConsoleLogEntry::General, "Did you mean to use 'foreach$' instead of 'foreach'?");
         ip = failIp;
         return OPCodeReturn::success;
      }

      // Set up.

      iter.mData.mObj.mSet = set;
      iter.mData.mObj.mIndex = 0;
   }

   _ITER++;
   mIterDepth++;

   STR.push();

   ip += 3;

   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_iter(U32 &ip)
{
   U32 breakIp = mCodeBlock->code[ip];
   IterStackRecord& iter = iterStack[_ITER - 1];

   if (iter.mIsStringIter)
   {
      const char* str = StringStackPtrRef(iter.mData.mStr.mString).getPtr(&STR);

      U32 startIndex = iter.mData.mStr.mIndex;
      U32 endIndex = startIndex;

      // Break if at end.

      if (!str[startIndex])
      {
         ip = breakIp;
         return OPCodeReturn::success; // continue in old interpreter
      }

      // Find right end of current component.

      if (!dIsspace(str[endIndex]))
         do ++endIndex;
      while (str[endIndex] && !dIsspace(str[endIndex]));

      // Extract component.

      if (endIndex != startIndex)
      {
         char savedChar = str[endIndex];
         const_cast< char* >(str)[endIndex] = '\0'; // We are on the string stack so this is okay.
         iter.mVariable->setStringValue(&str[startIndex]);
         const_cast< char* >(str)[endIndex] = savedChar;
      }
      else
         iter.mVariable->setStringValue("");

      // Skip separator.
      if (str[endIndex] != '\0')
         ++endIndex;

      iter.mData.mStr.mIndex = endIndex;
   }
   else
   {
      U32 index = iter.mData.mObj.mIndex;
      SimSet* set = iter.mData.mObj.mSet;

      if (index >= set->size())
      {
         ip = breakIp;
         return OPCodeReturn::success; // continue in old interpreter
      }

      iter.mVariable->setIntValue(set->at(index)->getId());
      iter.mData.mObj.mIndex = index + 1;
   }

   ++ip;

   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_iter_end(U32 &ip)
{
   --_ITER;
   --mIterDepth;
   STR.rewind();
   iterStack[_ITER].mIsStringIter = false;
   return OPCodeReturn::success;
}

OPCodeReturn CodeInterpreter::op_invalid(U32 &ip)
{
   // Invalid does nothing.
   return OPCodeReturn::exitCode;
}
