Tribes2/engine
1
0
Fork 0
mirror of https://github.com/tribes2/engine.git synced 2026-01-20 03:34:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
engine/console/compiledEval.cc
loop ff569bd2ae t2 engine svn checkout
2024-01-07 04:36:33 +00:00

1223 lines
36 KiB
C++
Raw Blame History

//-----------------------------------------------------------------------------
// V12 Engine
//
// Copyright (c) 2001 GarageGames.Com
// Portions Copyright (c) 2001 by Sierra Online, Inc.
//-----------------------------------------------------------------------------
#include "platform/platform.h"
#include "console/console.h"
#include "console/ast.h"
#include "core/tAlgorithm.h"
#include "core/resManager.h"
#include "core/findMatch.h"
#include "console/consoleInternal.h"
#include "core/fileStream.h"
#include "console/compiler.h"
#include "console/gram.h"
#include "console/simBase.h"
#include "console/telnetDebugger.h"
#include "sim/netStringTable.h"
enum {
MaxStackSize = 1024
};
F64 floatStack[MaxStackSize];
U32 intStack[MaxStackSize];
U32 FLT = 0;
U32 UINT = 0;
static const char *getNamespaceList(Namespace *ns)
{
U32 size = 1;
Namespace * walk;
for(walk = ns; walk; walk = walk->mParent)
size += dStrlen(walk->mName) + 4;
char *ret = Con::getReturnBuffer(size);
ret[0] = 0;
for(walk = ns; walk; walk = walk->mParent)
{
dStrcat(ret, walk->mName);
if(walk->mParent)
dStrcat(ret, " -> ");
}
return ret;
}
extern U32 GameAddTaggedString(const char *string);
//------------------------------------------------------------
F64 consoleStringToNumber(const char *str, StringTableEntry file, U32 line)
{
F64 val = dAtof(str);
if(val != 0)
return val;
else if(!dStricmp(str, "true"))
return 1;
else if(!dStricmp(str, "false"))
return 0;
else if(file)
{
Con::warnf(ConsoleLogEntry::General, "%s (%d): string always evaluates to 0.", file, line);
return 0;
}
return 0;
}
//------------------------------------------------------------
struct StringStack
{
enum {
MaxStackDepth = 1024,
MaxArgs = 20,
ReturnBufferSpace = 512
};
char *buffer;
U32 bufferSize;
const char *argv[MaxArgs];
U32 frameOffsets[MaxStackDepth];
U32 startOffsets[MaxStackDepth];
U32 numFrames;
U32 argc;
U32 start;
U32 len;
U32 startStackSize;
U32 functionOffset;
U32 argBufferSize;
char *argBuffer;
void validateBufferSize(U32 size)
{
if(size > bufferSize)
{
bufferSize = size + 2048;
buffer = (char *) dRealloc(buffer, bufferSize);
}
}
void validateArgBufferSize(U32 size)
{
if(size > argBufferSize)
{
argBufferSize = size + 2048;
argBuffer = (char *) dRealloc(argBuffer, argBufferSize);
}
}
StringStack()
{
bufferSize = 0;
buffer = NULL;
numFrames = 0;
start = 0;
len = 0;
startStackSize = 0;
functionOffset = 0;
validateBufferSize(8092);
validateArgBufferSize(2048);
}
void setIntValue(U32 i)
{
validateBufferSize(start + 32);
dSprintf(buffer + start, 32, "%d", i);
len = dStrlen(buffer + start);
}
void setFloatValue(F64 v)
{
validateBufferSize(start + 32);
dSprintf(buffer + start, 32, "%g", v);
len = dStrlen(buffer + start);
}
char *getReturnBuffer(U32 size)
{
if(size > ReturnBufferSpace)
{
validateArgBufferSize(size);
return argBuffer;
}
else
{
validateBufferSize(start + size);
return buffer + start;
}
}
char *getArgBuffer(U32 size)
{
validateBufferSize(start + functionOffset + size);
char *ret = buffer + start + functionOffset;
functionOffset += size;
return ret;
}
void clearFunctionOffset()
{
functionOffset = 0;
}
void setStringValue(const char *s)
{
if(!s)
{
len = 0;
buffer[start] = 0;
return;
}
len = dStrlen(s);
validateBufferSize(start + len + 2);
dStrcpy(buffer + start, s);
}
inline StringTableEntry getSTValue()
{
return StringTable->insert(buffer + start);
}
inline U32 getIntValue()
{
return dAtoi(buffer + start);
}
inline F64 getFloatValue()
{
return dAtof(buffer + start);
}
inline const char *getStringValue()
{
return buffer + start;
}
void advance()
{
startOffsets[startStackSize++] = start;
start += len;
len = 0;
}
void advanceChar(char c)
{
startOffsets[startStackSize++] = start;
start += len;
buffer[start] = c;
buffer[start+1] = 0;
start += 1;
len = 0;
}
void push()
{
advanceChar(0);
}
inline void setLen(U32 newlen)
{
len = newlen;
}
void rewind()
{
start = startOffsets[--startStackSize];
len = dStrlen(buffer + start);
}
void rewindTerminate()
{
buffer[start] = 0;
start = startOffsets[--startStackSize];
len = dStrlen(buffer + start);
}
U32 compare()
{
U32 oldStart = start;
start = startOffsets[--startStackSize];
U32 ret = !dStricmp(buffer + start, buffer + oldStart);
len = 0;
buffer[start] = 0;
return ret;
}
void pushFrame()
{
frameOffsets[numFrames++] = startStackSize;
startOffsets[startStackSize++] = start;
start += ReturnBufferSpace;
validateBufferSize(0);
}
void getArgcArgv(StringTableEntry name, U32 *argc, const char ***in_argv);
} STR;
void StringStack::getArgcArgv(StringTableEntry name, U32 *argc, const char ***in_argv)
{
U32 startStack = frameOffsets[--numFrames] + 1;
U32 argCount = getMin(startStackSize - startStack, (U32)MaxArgs);
*in_argv = argv;
argv[0] = name;
for(U32 i = 0; i < argCount; i++)
argv[i+1] = buffer + startOffsets[startStack + i];
argCount++;
startStackSize = startStack - 1;
*argc = argCount;
start = startOffsets[startStackSize];
len = 0;
}
//------------------------------------------------------------
namespace Con
{
char *getReturnBuffer(U32 bufferSize)
{
return STR.getReturnBuffer(bufferSize);
}
char *getArgBuffer(U32 bufferSize)
{
return STR.getArgBuffer(bufferSize);
}
char *getFloatArg(F64 arg)
{
char *ret = STR.getArgBuffer(32);
dSprintf(ret, 32, "%g", arg);
return ret;
}
char *getIntArg(S32 arg)
{
char *ret = STR.getArgBuffer(32);
dSprintf(ret, 32, "%d", arg);
return ret;
}
}
//------------------------------------------------------------
inline void ExprEvalState::setCurVarName(StringTableEntry name)
{
if(name[0] == '$')
currentVariable = globalVars.lookup(name);
else if(stack.size())
currentVariable = stack.last()->lookup(name);
// if(!currentVariable)
// Con::warnf(ConsoleLogEntry::Script, "Variable referenced before assignment: %s", name);
}
inline void ExprEvalState::setCurVarNameCreate(StringTableEntry name)
{
if(name[0] == '$')
currentVariable = globalVars.add(name);
else if(stack.size())
currentVariable = stack.last()->add(name);
else
{
currentVariable = NULL;
Con::warnf(ConsoleLogEntry::Script, "Accessing local variable in global scope... failed: %s", name);
}
}
//------------------------------------------------------------
inline S32 ExprEvalState::getIntVariable()
{
return currentVariable ? currentVariable->getIntValue() : 0;
}
inline F64 ExprEvalState::getFloatVariable()
{
return currentVariable ? currentVariable->getFloatValue() : 0;
}
inline const char *ExprEvalState::getStringVariable()
{
return currentVariable ? currentVariable->getStringValue() : "";
}
//------------------------------------------------------------
inline void ExprEvalState::setIntVariable(S32 val)
{
AssertFatal(currentVariable != NULL, "Invalid evaluator state.");
currentVariable->setIntValue(val);
}
inline void ExprEvalState::setFloatVariable(F64 val)
{
AssertFatal(currentVariable != NULL, "Invalid evaluator state.");
currentVariable->setFloatValue(val);
}
inline void ExprEvalState::setStringVariable(const char *val)
{
AssertFatal(currentVariable != NULL, "Invalid evaluator state.");
currentVariable->setStringValue(val);
}
//------------------------------------------------------------
const char *CodeBlock::exec(U32 ip, const char *functionName, Namespace *thisNamespace, U32 argc, const char **argv, bool noCalls)
{
static char traceBuffer[1024];
U32 i;
incRefCount();
F64 *curFloatTable;
char *curStringTable;
STR.clearFunctionOffset();
StringTableEntry thisFunctionName = NULL;
if(argv)
{
// assume this points into a function decl:
U32 fnArgc = code[ip + 5];
thisFunctionName = U32toSTE(code[ip]);
argc = getMin(argc-1, fnArgc); // argv[0] is func name
gEvalState.pushFrame(thisFunctionName, thisNamespace);
if(gEvalState.traceOn)
{
traceBuffer[0] = 0;
for(i = 0; i < gEvalState.stack.size() - 1; i++)
dStrcat(traceBuffer, " ");
dSprintf(traceBuffer + dStrlen(traceBuffer), sizeof(traceBuffer) - dStrlen(traceBuffer),
"Entering %s::%s(", thisNamespace ? thisNamespace->mName : "", thisFunctionName);
for(i = 0; i < argc; i++)
{
dStrcat(traceBuffer, argv[i+1]);
if(i != argc - 1)
dStrcat(traceBuffer, ", ");
}
dStrcat(traceBuffer, ")");
Con::printf("%s", traceBuffer);
}
for(i = 0; i < argc; i++)
{
StringTableEntry var = U32toSTE(code[ip + i + 6]);
gEvalState.setCurVarNameCreate(var);
gEvalState.setStringVariable(argv[i+1]);
}
ip = ip + fnArgc + 6;
curFloatTable = functionFloats;
curStringTable = functionStrings;
}
else
{
curFloatTable = globalFloats;
curStringTable = globalStrings;
}
StringTableEntry var, objParent;
U32 failJump;
StringTableEntry fnName;
StringTableEntry fnNamespace, fnPackage;
SimObject *currentNewObject = 0;
StringTableEntry curField;
SimObject *curObject;
SimObject *saveObject=NULL;
Namespace::Entry *nsEntry;
Namespace *ns;
U32 callArgc;
const char **callArgv;
static char curFieldArray[256];
const char * val;
for(;;)
{
U32 instruction = code[ip++];
breakContinue:
switch(instruction)
{
case OP_FUNC_DECL:
if(!noCalls)
{
fnName = U32toSTE(code[ip]);
fnNamespace = U32toSTE(code[ip+1]);
fnPackage = U32toSTE(code[ip+2]);
bool hasBody = bool(code[ip+3]);
Namespace::unlinkPackages();
ns = Namespace::find(fnNamespace, fnPackage);
// if no body, set the IP to 0
ns->addFunction(fnName, this, hasBody ? ip : 0);
Namespace::relinkPackages();
//Con::printf("Adding function %s::%s (%d)", fnNamespace, fnName, ip);
}
ip = code[ip + 4];
break;
case OP_CREATE_OBJECT:
{
if(noCalls)
{
ip = failJump;
break;
}
objParent = U32toSTE(code[ip]);
bool dataBlock = code[ip + 1];
failJump = code[ip + 2];
STR.getArgcArgv(NULL, &callArgc, &callArgv);
//Con::printf("Creating object %s of class %s", argv[1], objClass);
// objectName = argv[1]...
currentNewObject = NULL;
if(dataBlock)
{
SimObject *db = Sim::getDataBlockGroup()->findObject(callArgv[2]);
if(db && dStricmp(db->getClassName(), callArgv[1]))
{
Con::errorf(ConsoleLogEntry::General, "Cannot re-declare data block %s with a different class.", callArgv[2]);
ip = failJump;
break;
}
if(db)
currentNewObject = db;
}
if(!currentNewObject)
{
ConsoleObject *object = ConsoleObject::create(callArgv[1]);
if(!object)
{
Con::warnf(ConsoleLogEntry::General, "%s: Unable to instantiate non-conobject class %s.", getFileLine(ip-1), callArgv[1]);
ip = failJump;
break;
}
if(dataBlock)
{
SimDataBlock *dataBlock = dynamic_cast<SimDataBlock *>(object);
if(dataBlock)
{
dataBlock->assignId();
if(*objParent) // it has a parent object
{
SimDataBlock *parent;
if(Sim::findObject(objParent, parent))
{
// now loop through all the fields:
dataBlock->assignFieldsFrom(parent);
}
else
{
Con::warnf(ConsoleLogEntry::General, "%s: Unable to find parent object %s for %s.", getFileLine(ip-1), objParent, callArgv[1]);
}
}
}
else
{
Con::warnf(ConsoleLogEntry::General, "%s: Unable to instantiate non-datablock class %s.", getFileLine(ip-1), callArgv[1]);
delete object;
ip = failJump;
break;
}
}
currentNewObject = dynamic_cast<SimObject *>(object);
if(!currentNewObject)
{
Con::warnf(ConsoleLogEntry::General, "%s: Unable to instantiate non-SimObject class %s.", getFileLine(ip-1), callArgv[1]);
delete object;
ip = failJump;
break;
}
if(callArgv[2][0])
currentNewObject->assignName(callArgv[2]);
if(!currentNewObject->processArguments(callArgc-3, callArgv+3))
{
delete currentNewObject;
currentNewObject = NULL;
ip = failJump;
break;
}
if(!dataBlock)
{
currentNewObject->setModStaticFields(true);
currentNewObject->setModDynamicFields(true);
}
}
ip += 3;
break;
}
case OP_CREATE_DATABLOCK:
break;
case OP_NAME_OBJECT:
break;
case OP_ADD_OBJECT:
{
bool root = code[ip++];
//Con::printf("Adding object %s", currentNewObject->getName());
if(currentNewObject->isProperlyAdded() == false && !currentNewObject->registerObject())
{
Con::warnf(ConsoleLogEntry::General, "%s: Register object failed for object %s.", getFileLine(ip-2), currentNewObject->getName());
delete currentNewObject;
ip = failJump;
break;
}
SimDataBlock *dataBlock = dynamic_cast<SimDataBlock *>(currentNewObject);
static char errorBuffer[256];
if(dataBlock && !dataBlock->preload(true, errorBuffer))
{
Con::errorf(ConsoleLogEntry::General, "%s: preload failed for %s: %s.", getFileLine(ip-2),
currentNewObject->getName(), errorBuffer);
dataBlock->deleteObject();
ip = failJump;
break;
}
U32 groupAddId = intStack[UINT];
SimGroup *grp = NULL;
SimSet *set = NULL;
if(!root || !currentNewObject->getGroup())
{
if(root)
{
const char *addGroupName = Con::getVariable("instantGroup");
if(!Sim::findObject(addGroupName, grp))
Sim::findObject(RootGroupId, grp);
}
else
{
if(!Sim::findObject(groupAddId, grp))
Sim::findObject(groupAddId, set);
}
if(!grp)
Sim::findObject(RootGroupId, grp);
// add to the parent group
grp->addObject(currentNewObject);
// add to any set we might be in
if(set)
set->addObject(currentNewObject);
}
if(root) // root object
intStack[UINT] = currentNewObject->getId();
else
intStack[++UINT] = currentNewObject->getId();
break;
}
case OP_END_OBJECT:
{
bool root = code[ip++];
if(!root)
UINT--;
// set the parent group to this object's parent.
break;
}
case OP_JMPIFFNOT:
if(floatStack[FLT--])
{
ip++;
break;
}
ip = code[ip];
break;
case OP_JMPIFNOT:
if(intStack[UINT--])
{
ip++;
break;
}
ip = code[ip];
break;
case OP_JMPIFF:
if(!floatStack[FLT--])
{
ip++;
break;
}
ip = code[ip];
break;
case OP_JMPIF:
if(!intStack[UINT--])
{
ip ++;
break;
}
ip = code[ip];
break;
case OP_JMPIFNOT_NP:
if(intStack[UINT])
{
UINT--;
ip++;
break;
}
ip = code[ip];
break;
case OP_JMPIF_NP:
if(!intStack[UINT])
{
UINT--;
ip++;
break;
}
ip = code[ip];
break;
case OP_JMP:
ip = code[ip];
break;
case OP_RETURN:
goto execFinished;
case OP_CMPEQ:
intStack[UINT+1] = bool(floatStack[FLT] == floatStack[FLT-1]);
UINT++;
FLT -= 2;
break;
case OP_CMPGR:
intStack[UINT+1] = bool(floatStack[FLT] > floatStack[FLT-1]);
UINT++;
FLT -= 2;
break;
case OP_CMPGE:
intStack[UINT+1] = bool(floatStack[FLT] >= floatStack[FLT-1]);
UINT++;
FLT -= 2;
break;
case OP_CMPLT:
intStack[UINT+1] = bool(floatStack[FLT] < floatStack[FLT-1]);
UINT++;
FLT -= 2;
break;
case OP_CMPLE:
intStack[UINT+1] = bool(floatStack[FLT] <= floatStack[FLT-1]);
UINT++;
FLT -= 2;
break;
case OP_CMPNE:
intStack[UINT+1] = bool(floatStack[FLT] != floatStack[FLT-1]);
UINT++;
FLT -= 2;
break;
case OP_XOR:
intStack[UINT-1] = intStack[UINT] ^ intStack[UINT-1];
UINT--;
break;
case OP_MOD:
intStack[UINT-1] = intStack[UINT] % intStack[UINT-1];
UINT--;
break;
case OP_BITAND:
intStack[UINT-1] = intStack[UINT] & intStack[UINT-1];
UINT--;
break;
case OP_BITOR:
intStack[UINT-1] = intStack[UINT] | intStack[UINT-1];
UINT--;
break;
case OP_NOT:
intStack[UINT] = !intStack[UINT];
break;
case OP_NOTF:
intStack[UINT+1] = !floatStack[FLT];
FLT--;
UINT++;
break;
case OP_ONESCOMPLEMENT:
intStack[UINT] = ~intStack[UINT];
break;
case OP_SHR:
intStack[UINT-1] = intStack[UINT] >> intStack[UINT-1];
UINT--;
break;
case OP_SHL:
intStack[UINT-1] = intStack[UINT] << intStack[UINT-1];
UINT--;
break;
case OP_AND:
intStack[UINT-1] = intStack[UINT] && intStack[UINT-1];
UINT--;
break;
case OP_OR:
intStack[UINT-1] = intStack[UINT] || intStack[UINT-1];
UINT--;
break;
case OP_ADD:
floatStack[FLT-1] = floatStack[FLT] + floatStack[FLT-1];
FLT--;
break;
case OP_SUB:
floatStack[FLT-1] = floatStack[FLT] - floatStack[FLT-1];
FLT--;
break;
case OP_MUL:
floatStack[FLT-1] = floatStack[FLT] * floatStack[FLT-1];
FLT--;
break;
case OP_DIV:
floatStack[FLT-1] = floatStack[FLT] / floatStack[FLT-1];
FLT--;
break;
case OP_NEG:
floatStack[FLT] = -floatStack[FLT];
break;
case OP_SETCURVAR:
var = U32toSTE(code[ip]);
ip++;
gEvalState.setCurVarName(var);
break;
case OP_SETCURVAR_CREATE:
var = U32toSTE(code[ip]);
ip++;
gEvalState.setCurVarNameCreate(var);
break;
case OP_SETCURVAR_ARRAY:
var = STR.getSTValue();
gEvalState.setCurVarName(var);
break;
case OP_SETCURVAR_ARRAY_CREATE:
var = STR.getSTValue();
gEvalState.setCurVarNameCreate(var);
break;
case OP_LOADVAR_UINT:
intStack[UINT+1] = gEvalState.getIntVariable();
UINT++;
break;
case OP_LOADVAR_FLT:
floatStack[FLT+1] = gEvalState.getFloatVariable();
FLT++;
break;
case OP_LOADVAR_STR:
val = gEvalState.getStringVariable();
STR.setStringValue(val);
break;
case OP_SAVEVAR_UINT:
gEvalState.setIntVariable(intStack[UINT]);
break;
case OP_SAVEVAR_FLT:
gEvalState.setFloatVariable(floatStack[FLT]);
break;
case OP_SAVEVAR_STR:
gEvalState.setStringVariable(STR.getStringValue());
break;
case OP_SETCUROBJECT:
curObject = Sim::findObject(STR.getStringValue());
break;
case OP_SETCUROBJECT_NEW:
curObject = currentNewObject;
break;
case OP_SETCURFIELD:
curField = U32toSTE(code[ip]);
curFieldArray[0] = 0;
ip++;
break;
case OP_SETCURFIELD_ARRAY:
dStrcpy(curFieldArray, STR.getStringValue());
break;
case OP_LOADFIELD_UINT:
if(curObject)
intStack[UINT+1] = U32(dAtoi(curObject->getDataField(curField, curFieldArray)));
else
intStack[UINT+1] = 0;
UINT++;
break;
case OP_LOADFIELD_FLT:
if(curObject)
floatStack[FLT+1] = dAtof(curObject->getDataField(curField, curFieldArray));
else
floatStack[FLT+1] = 0;
FLT++;
break;
case OP_LOADFIELD_STR:
if(curObject)
val = curObject->getDataField(curField, curFieldArray);
else
val = "";
STR.setStringValue(val);
break;
case OP_SAVEFIELD_UINT:
STR.setIntValue(intStack[UINT]);
if(curObject)
curObject->setDataField(curField, curFieldArray, STR.getStringValue());
break;
case OP_SAVEFIELD_FLT:
STR.setFloatValue(floatStack[FLT]);
if(curObject)
curObject->setDataField(curField, curFieldArray, STR.getStringValue());
break;
case OP_SAVEFIELD_STR:
if(curObject)
curObject->setDataField(curField, curFieldArray, STR.getStringValue());
break;
case OP_STR_TO_UINT:
intStack[UINT+1] = STR.getIntValue();
UINT++;
break;
case OP_STR_TO_FLT:
floatStack[FLT+1] = STR.getFloatValue();
FLT++;
break;
case OP_STR_TO_NONE:
break;
case OP_FLT_TO_UINT:
intStack[UINT+1] = (unsigned int)floatStack[FLT];
FLT--;
UINT++;
break;
case OP_FLT_TO_STR:
STR.setFloatValue(floatStack[FLT]);
FLT--;
break;
case OP_FLT_TO_NONE:
FLT--;
break;
case OP_UINT_TO_FLT:
floatStack[FLT+1] = intStack[UINT];
UINT--;
FLT++;
break;
case OP_UINT_TO_STR:
STR.setIntValue(intStack[UINT]);
UINT--;
break;
case OP_UINT_TO_NONE:
UINT--;
break;
case OP_LOADIMMED_UINT:
intStack[UINT+1] = code[ip++];
UINT++;
break;
case OP_LOADIMMED_FLT:
floatStack[FLT+1] = curFloatTable[code[ip]];
ip++;
FLT++;
break;
case OP_TAG_TO_STR:
code[ip-1] = OP_LOADIMMED_STR;
// it's possible the string has already been converted
if(U8(curStringTable[code[ip]]) != StringTagPrefixByte)
{
U32 id = GameAddTaggedString(curStringTable + code[ip]);
dSprintf(curStringTable + code[ip] + 1, 7, "%d", id);
*(curStringTable + code[ip]) = StringTagPrefixByte;
}
case OP_LOADIMMED_STR:
STR.setStringValue(curStringTable + code[ip++]);
break;
case OP_LOADIMMED_IDENT:
STR.setStringValue(U32toSTE(code[ip++]));
break;
case OP_CALLFUNC_RESOLVE:
fnNamespace = U32toSTE(code[ip+1]);
fnName = U32toSTE(code[ip]);
ns = Namespace::find(fnNamespace);
nsEntry = ns->lookup(fnName);
if(!nsEntry)
{
ip+= 3;
Con::warnf(ConsoleLogEntry::General,
"%s: Unable to find function %s%s%s",
getFileLine(ip-4), fnNamespace ? fnNamespace : "",
fnNamespace ? "::" : "", fnName);
STR.getArgcArgv(fnName, &callArgc, &callArgv);
break;
}
code[ip+1] = *((U32 *) &nsEntry); // fall through
code[ip-1] = OP_CALLFUNC;
case OP_CALLFUNC:
{
fnName = U32toSTE(code[ip]);
if(argv) // if this is called from inside a function, append the ip and codeptr
{
gEvalState.stack.last()->code = this;
gEvalState.stack.last()->ip = ip - 1;
}
U32 callType = code[ip+2];
ip += 3;
STR.getArgcArgv(fnName, &callArgc, &callArgv);
if(callType == FuncCallExprNode::FunctionCall)
nsEntry = *((Namespace::Entry **) &code[ip-2]);
else if(callType == FuncCallExprNode::MethodCall)
{
gEvalState.thisObject = Sim::findObject(callArgv[1]);
if(!gEvalState.thisObject)
{
gEvalState.thisObject = 0;
Con::warnf(ConsoleLogEntry::General,"%s: Unable to find object: '%s' attempting to call function '%s'", getFileLine(ip-4), callArgv[1], fnName);
break;
}
ns = gEvalState.thisObject->getNamespace();
if(ns)
nsEntry = ns->lookup(fnName);
else
nsEntry = NULL;
}
else // it's a ParentCall
{
if(thisNamespace)
{
ns = thisNamespace->mParent;
if(ns)
nsEntry = ns->lookup(fnName);
else
nsEntry = NULL;
}
else
{
ns = NULL;
nsEntry = NULL;
}
}
if(!nsEntry || noCalls)
{
if(!noCalls)
{
Con::warnf(ConsoleLogEntry::General,"%s: Unknown command %s.", getFileLine(ip-4), fnName);
if(callType == FuncCallExprNode::MethodCall)
{
Con::warnf(ConsoleLogEntry::General, " Object %s(%d) %s",
gEvalState.thisObject->getName() ? gEvalState.thisObject->getName() : "",
gEvalState.thisObject->getId(), getNamespaceList(ns) );
}
}
STR.setStringValue("");
break;
}
if(nsEntry->mType == Namespace::Entry::ScriptFunctionType)
{
if(nsEntry->mFunctionOffset)
nsEntry->mCode->exec(nsEntry->mFunctionOffset, fnName, nsEntry->mNamespace, callArgc, callArgv, false);
else // no body
STR.setStringValue("");
}
else
{
if((nsEntry->mMinArgs && S32(callArgc) < nsEntry->mMinArgs) || (nsEntry->mMaxArgs && S32(callArgc) > nsEntry->mMaxArgs))
{
Con::warnf(ConsoleLogEntry::Script, "%s: %s::%s - wrong number of arguments.", getFileLine(ip-4), ns->mName, fnName);
Con::warnf(ConsoleLogEntry::Script, "%s: usage: %s", getFileLine(ip-4), nsEntry->mUsage);
}
else
{
switch(nsEntry->mType)
{
case Namespace::Entry::StringCallbackType:
{
const char *ret = nsEntry->cb.mStringCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
if(ret != STR.getStringValue())
STR.setStringValue(ret);
else
STR.setLen(dStrlen(ret));
break;
}
case Namespace::Entry::IntCallbackType:
{
S32 result = nsEntry->cb.mIntCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
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 = nsEntry->cb.mFloatCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
if(code[ip] == OP_STR_TO_UINT)
{
ip++;
intStack[++UINT] = (unsigned int)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:
nsEntry->cb.mVoidCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
if(code[ip] != OP_STR_TO_NONE)
Con::warnf(ConsoleLogEntry::General, "%s: Call to %s in %s uses result of void function call.", getFileLine(ip-4), fnName, functionName);
STR.setStringValue("");
break;
case Namespace::Entry::BoolCallbackType:
{
bool result = nsEntry->cb.mBoolCallbackFunc(gEvalState.thisObject, callArgc, callArgv);
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 = saveObject;
TelDebugger->popStackFrame();
break;
}
case OP_PROCESS_ARGS:
break;
case OP_ADVANCE_STR:
STR.advance();
break;
case OP_ADVANCE_STR_APPENDCHAR:
STR.advanceChar(code[ip++]);
break;
case OP_ADVANCE_STR_COMMA:
STR.advanceChar('_');
break;
case OP_ADVANCE_STR_NUL:
STR.advanceChar(0);
break;
case OP_REWIND_STR:
STR.rewind();
break;
case OP_TERMINATE_REWIND_STR:
STR.rewindTerminate();
break;
case OP_COMPARE_STR:
intStack[++UINT] = STR.compare();
break;
case OP_PUSH:
STR.push();
break;
case OP_PUSH_FRAME:
STR.pushFrame();
break;
case OP_BREAK:
{
if(argv) // if this is called from inside a function, append the ip and codeptr
{
gEvalState.stack.last()->code = this;
gEvalState.stack.last()->ip = ip - 1;
}
else
goto breakContinue;
U32 breakLine;
findBreakLine(ip-1, breakLine, instruction);
if(!breakLine)
goto breakContinue;
TelDebugger->executionStopped(this, breakLine);
goto breakContinue;
}
case OP_INVALID:
default:
// error!
goto execFinished;
}
}
execFinished:
if(argv)
{
if(gEvalState.traceOn)
{
traceBuffer[0] = 0;
for(U32 i = 0; i < gEvalState.stack.size() - 1; i++)
dStrcat(traceBuffer, " ");
dSprintf(traceBuffer + dStrlen(traceBuffer), sizeof(traceBuffer) - dStrlen(traceBuffer),
"Leaving %s::%s - return %s", thisNamespace ? thisNamespace->mName : "", thisFunctionName, STR.getStringValue());
Con::printf("%s", traceBuffer);
}
gEvalState.popFrame();
}
else
{
delete[] const_cast<char*>(globalStrings);
delete[] globalFloats;
globalStrings = NULL;
globalFloats = NULL;
}
decRefCount();
return STR.getStringValue();
}
//------------------------------------------------------------
Reference in a new issue View git blame Copy permalink