mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 12:44:46 +00:00
50f74368b3
Imageasset text field now displays correctly in inspector previews now use assets again assetBrowser hides previewCache folder
2364 lines
68 KiB
C++
2364 lines
68 KiB
C++
//-----------------------------------------------------------------------------
|
|
// 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.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "platform/platform.h"
|
|
#include "platform/platformTLS.h"
|
|
#include "platform/threads/thread.h"
|
|
#include "console/console.h"
|
|
#include "console/consoleInternal.h"
|
|
#include "console/consoleObject.h"
|
|
#include "console/consoleParser.h"
|
|
#include "core/stream/fileStream.h"
|
|
#include "core/tAlgorithm.h"
|
|
#include "console/consoleTypes.h"
|
|
#include "console/telnetDebugger.h"
|
|
#include "console/simBase.h"
|
|
#include "console/stringStack.h"
|
|
#include "console/ICallMethod.h"
|
|
#include "console/engineAPI.h"
|
|
#include <stdarg.h>
|
|
|
|
#include "returnBuffer.h"
|
|
#include "platform/threads/mutex.h"
|
|
#include "core/util/journal/journal.h"
|
|
#include "console/consoleValueStack.h"
|
|
|
|
extern StringStack STR;
|
|
extern ConsoleValueStack<4096> gCallStack;
|
|
|
|
DataChunker ConsoleValue::sConversionAllocator;
|
|
|
|
void ConsoleValue::init()
|
|
{
|
|
sConversionAllocator.setChunkSize(8092);
|
|
}
|
|
|
|
void ConsoleValue::resetConversionBuffer()
|
|
{
|
|
sConversionAllocator.freeBlocks();
|
|
}
|
|
|
|
char* ConsoleValue::convertToBuffer() const
|
|
{
|
|
char* buffer = static_cast<char*>(sConversionAllocator.alloc(32));
|
|
|
|
if (type == ConsoleValueType::cvFloat)
|
|
dSprintf(buffer, 32, "%.9g", f);
|
|
else
|
|
dSprintf(buffer, 32, "%lld", i);
|
|
|
|
return buffer;
|
|
}
|
|
|
|
const char* ConsoleValue::getConsoleData() const
|
|
{
|
|
return Con::getData(type, dataPtr, 0, enumTable);
|
|
}
|
|
|
|
ConsoleDocFragment* ConsoleDocFragment::smFirst;
|
|
U32 gAnonFunctionID = 0;
|
|
ConsoleConstructor *ConsoleConstructor::mFirst = NULL;
|
|
bool gWarnUndefinedScriptVariables;
|
|
|
|
static char scratchBuffer[4096];
|
|
|
|
CON_DECLARE_PARSER(CMD);
|
|
|
|
static const char * prependDollar ( const char * name )
|
|
{
|
|
if(name[0] != '$')
|
|
{
|
|
U64 len = dStrlen(name);
|
|
AssertFatal(len < sizeof(scratchBuffer)-2, "CONSOLE: name too long");
|
|
scratchBuffer[0] = '$';
|
|
dMemcpy(scratchBuffer + 1, name, len + 1);
|
|
name = scratchBuffer;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
static const char * prependPercent ( const char * name )
|
|
{
|
|
if(name[0] != '%')
|
|
{
|
|
U64 len = dStrlen(name);
|
|
AssertFatal(len < sizeof(scratchBuffer)-2, "CONSOLE: name too long");
|
|
scratchBuffer[0] = '%';
|
|
dMemcpy(scratchBuffer + 1, name, len + 1);
|
|
name = scratchBuffer;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
//--------------------------------------
|
|
void ConsoleConstructor::init( const char *cName, const char *fName, const char *usg, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
mMina = minArgs;
|
|
mMaxa = maxArgs;
|
|
mFuncName = fName;
|
|
mUsage = usg;
|
|
mClassName = cName;
|
|
mSC = 0; mFC = 0; mVC = 0; mBC = 0; mIC = 0;
|
|
mCallback = mGroup = false;
|
|
mNext = mFirst;
|
|
mNS = false;
|
|
mFirst = this;
|
|
mToolOnly = isToolOnly;
|
|
mHeader = header;
|
|
}
|
|
|
|
void ConsoleConstructor::setup()
|
|
{
|
|
for(ConsoleConstructor *walk = mFirst; walk; walk = walk->mNext)
|
|
{
|
|
#ifdef TORQUE_DEBUG
|
|
walk->validate();
|
|
#endif
|
|
|
|
if( walk->mSC )
|
|
Con::addCommand( walk->mClassName, walk->mFuncName, walk->mSC, walk->mUsage, walk->mMina, walk->mMaxa, walk->mToolOnly, walk->mHeader);
|
|
else if( walk->mIC )
|
|
Con::addCommand( walk->mClassName, walk->mFuncName, walk->mIC, walk->mUsage, walk->mMina, walk->mMaxa, walk->mToolOnly, walk->mHeader);
|
|
else if( walk->mFC )
|
|
Con::addCommand( walk->mClassName, walk->mFuncName, walk->mFC, walk->mUsage, walk->mMina, walk->mMaxa, walk->mToolOnly, walk->mHeader);
|
|
else if( walk->mVC )
|
|
Con::addCommand( walk->mClassName, walk->mFuncName, walk->mVC, walk->mUsage, walk->mMina, walk->mMaxa, walk->mToolOnly, walk->mHeader);
|
|
else if( walk->mBC )
|
|
Con::addCommand( walk->mClassName, walk->mFuncName, walk->mBC, walk->mUsage, walk->mMina, walk->mMaxa, walk->mToolOnly, walk->mHeader);
|
|
else if( walk->mGroup )
|
|
Con::markCommandGroup( walk->mClassName, walk->mFuncName, walk->mUsage);
|
|
else if( walk->mClassName)
|
|
Con::noteScriptCallback( walk->mClassName, walk->mFuncName, walk->mUsage, walk->mHeader);
|
|
else if( walk->mNS )
|
|
{
|
|
Namespace* ns = Namespace::find( StringTable->insert( walk->mClassName) );
|
|
if( ns )
|
|
ns->mUsage = walk->mUsage;
|
|
}
|
|
else
|
|
{
|
|
AssertISV( false, "Found a ConsoleConstructor with an indeterminate type!" );
|
|
}
|
|
}
|
|
}
|
|
|
|
ConsoleConstructor::ConsoleConstructor(const char *className, const char *funcName, StringCallback sfunc, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
init( className, funcName, usage, minArgs, maxArgs, isToolOnly, header );
|
|
mSC = sfunc;
|
|
}
|
|
|
|
ConsoleConstructor::ConsoleConstructor(const char *className, const char *funcName, IntCallback ifunc, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
init( className, funcName, usage, minArgs, maxArgs, isToolOnly, header );
|
|
mIC = ifunc;
|
|
}
|
|
|
|
ConsoleConstructor::ConsoleConstructor(const char *className, const char *funcName, FloatCallback ffunc, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
init( className, funcName, usage, minArgs, maxArgs, isToolOnly, header );
|
|
mFC = ffunc;
|
|
}
|
|
|
|
ConsoleConstructor::ConsoleConstructor(const char *className, const char *funcName, VoidCallback vfunc, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
init( className, funcName, usage, minArgs, maxArgs, isToolOnly, header );
|
|
mVC = vfunc;
|
|
}
|
|
|
|
ConsoleConstructor::ConsoleConstructor(const char *className, const char *funcName, BoolCallback bfunc, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
init( className, funcName, usage, minArgs, maxArgs, isToolOnly, header );
|
|
mBC = bfunc;
|
|
}
|
|
|
|
ConsoleConstructor::ConsoleConstructor(const char* className, const char* groupName, const char* aUsage)
|
|
{
|
|
init(className, groupName, mUsage, -1, -2);
|
|
|
|
mGroup = true;
|
|
|
|
// Somewhere, the entry list is getting flipped, partially.
|
|
// so we have to do tricks to deal with making sure usage
|
|
// is properly populated.
|
|
|
|
// This is probably redundant.
|
|
static char * lastUsage = NULL;
|
|
if(aUsage)
|
|
lastUsage = (char *)aUsage;
|
|
|
|
mUsage = lastUsage;
|
|
}
|
|
|
|
ConsoleConstructor::ConsoleConstructor(const char *className, const char *callbackName, const char *usage, ConsoleFunctionHeader* header )
|
|
{
|
|
init( className, callbackName, usage, -2, -3, false, header );
|
|
mCallback = true;
|
|
mNS = true;
|
|
}
|
|
|
|
void ConsoleConstructor::validate()
|
|
{
|
|
#ifdef TORQUE_DEBUG
|
|
// Don't do the following check if we're not a method/func.
|
|
if(mGroup)
|
|
return;
|
|
|
|
// In debug, walk the list and make sure this isn't a duplicate.
|
|
for(ConsoleConstructor *walk = mFirst; walk; walk = walk->mNext)
|
|
{
|
|
// Skip mismatching func/method names.
|
|
if(dStricmp(walk->mFuncName, mFuncName))
|
|
continue;
|
|
|
|
// Don't compare functions with methods or vice versa.
|
|
if(bool(mClassName) != bool(walk->mClassName))
|
|
continue;
|
|
|
|
// Skip mismatching classnames, if they're present.
|
|
if(mClassName && walk->mClassName && dStricmp(walk->mClassName, mClassName))
|
|
continue;
|
|
|
|
// If we encounter ourselves, stop searching; this prevents duplicate
|
|
// firing of the assert, instead only firing for the latter encountered
|
|
// entry.
|
|
if(this == walk)
|
|
break;
|
|
|
|
// Match!
|
|
if(mClassName)
|
|
{
|
|
AssertISV(false, avar("ConsoleConstructor::setup - ConsoleMethod '%s::%s' collides with another of the same name.", mClassName, mFuncName));
|
|
}
|
|
else
|
|
{
|
|
AssertISV(false, avar("ConsoleConstructor::setup - ConsoleFunction '%s' collides with another of the same name.", mFuncName));
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// We comment out the implementation of the Con namespace when doxygenizing because
|
|
// otherwise Doxygen decides to ignore our docs in console.h
|
|
#ifndef DOXYGENIZING
|
|
|
|
namespace Con
|
|
{
|
|
|
|
static Vector<ConsumerCallback> gConsumers(__FILE__, __LINE__);
|
|
static Vector< String > sInstantGroupStack( __FILE__, __LINE__ );
|
|
static DataChunker consoleLogChunker;
|
|
static Vector<ConsoleLogEntry> consoleLog(__FILE__, __LINE__);
|
|
static bool consoleLogLocked;
|
|
bool scriptWarningsAsAsserts = true;
|
|
static bool logBufferEnabled=true;
|
|
static S32 printLevel = 10;
|
|
static FileStream consoleLogFile;
|
|
static const char *defLogFileName = "console.log";
|
|
static S32 consoleLogMode = 0;
|
|
static bool active = false;
|
|
static bool newLogFile;
|
|
static const char *logFileName;
|
|
|
|
static const S32 MaxCompletionBufferSize = 4096;
|
|
static char completionBuffer[MaxCompletionBufferSize];
|
|
static char tabBuffer[MaxCompletionBufferSize] = {0};
|
|
static SimObjectPtr<SimObject> tabObject;
|
|
static U32 completionBaseStart;
|
|
static U32 completionBaseLen;
|
|
|
|
String gInstantGroup;
|
|
Con::ConsoleInputEvent smConsoleInput;
|
|
|
|
/// Current script file name and root, these are registered as
|
|
/// console variables.
|
|
/// @{
|
|
|
|
///
|
|
StringTableEntry gCurrentFile;
|
|
StringTableEntry gCurrentRoot;
|
|
S32 gObjectCopyFailures = -1;
|
|
/// @}
|
|
|
|
bool alwaysUseDebugOutput = true;
|
|
bool useTimestamp = false;
|
|
bool useRealTimestamp = false;
|
|
|
|
static U32 initTime = Platform::getRealMilliseconds();
|
|
static U32 startTime = initTime;
|
|
|
|
ConsoleFunctionGroupBegin( Clipboard, "Miscellaneous functions to control the clipboard and clear the console.");
|
|
|
|
DefineEngineFunction( cls, void, (), , "()"
|
|
"@brief Clears the console output.\n\n"
|
|
"@ingroup Console")
|
|
{
|
|
if(consoleLogLocked)
|
|
return;
|
|
consoleLogChunker.freeBlocks();
|
|
consoleLog.setSize(0);
|
|
};
|
|
|
|
DefineEngineFunction( getClipboard, const char*, (), , "()"
|
|
"@brief Get text from the clipboard.\n\n"
|
|
"@internal")
|
|
{
|
|
return Platform::getClipboard();
|
|
};
|
|
|
|
DefineEngineFunction( setClipboard, bool, (const char* text), , "(string text)"
|
|
"@brief Set the system clipboard.\n\n"
|
|
"@internal")
|
|
{
|
|
return Platform::setClipboard(text);
|
|
};
|
|
|
|
ConsoleFunctionGroupEnd( Clipboard );
|
|
|
|
DefineEngineFunction( resetTimeStamp, void, (), , "()"
|
|
"@brief Reset the timestamp to 0 ms.\n\n"
|
|
"@ingroup Console")
|
|
{
|
|
startTime = Platform::getRealMilliseconds();
|
|
};
|
|
|
|
DefineEngineFunction( getInitTime, int, (), , "()"
|
|
"@brief Get the initialization time in miliseconds.\n\n"
|
|
"@internal")
|
|
{
|
|
return initTime;
|
|
};
|
|
|
|
|
|
void postConsoleInput( RawData data );
|
|
|
|
void init()
|
|
{
|
|
AssertFatal(active == false, "Con::init should only be called once.");
|
|
|
|
// Set up general init values.
|
|
active = true;
|
|
logFileName = NULL;
|
|
newLogFile = true;
|
|
gWarnUndefinedScriptVariables = false;
|
|
|
|
// Initialize subsystems.
|
|
Namespace::init();
|
|
ConsoleConstructor::setup();
|
|
|
|
// Set up the parser(s)
|
|
CON_ADD_PARSER(CMD, (char*)TORQUE_SCRIPT_EXTENSION, true); // TorqueScript
|
|
|
|
// Setup the console types.
|
|
ConsoleBaseType::initialize();
|
|
ConsoleValue::init();
|
|
|
|
// And finally, the ACR...
|
|
AbstractClassRep::initialize();
|
|
|
|
// Variables
|
|
setVariable("Con::prompt", "% ");
|
|
addVariable("Con::logBufferEnabled", TypeBool, &logBufferEnabled, "If true, the log buffer will be enabled.\n"
|
|
"@ingroup Console\n");
|
|
addVariable("Con::printLevel", TypeS32, &printLevel,
|
|
"@brief This is deprecated.\n\n"
|
|
"It is no longer in use and does nothing.\n"
|
|
"@ingroup Console\n");
|
|
addVariable("Con::warnUndefinedVariables", TypeBool, &gWarnUndefinedScriptVariables, "If true, a warning will be displayed in the console whenever a undefined variable is used in script.\n"
|
|
"@ingroup Console\n");
|
|
addVariable( "instantGroup", TypeRealString, &gInstantGroup, "The group that objects will be added to when they are created.\n"
|
|
"@ingroup Console\n");
|
|
addVariable("Con::objectCopyFailures", TypeS32, &gObjectCopyFailures, "If greater than zero then it counts the number of object creation "
|
|
"failures based on a missing copy object and does not report an error..\n"
|
|
"@ingroup Console\n");
|
|
addVariable("Con::scriptWarningsAsAsserts", TypeBool, &scriptWarningsAsAsserts, "If true, script warnings (outside of syntax errors) will be treated as fatal asserts.");
|
|
|
|
// Current script file name and root
|
|
addVariable( "Con::File", TypeString, &gCurrentFile, "The currently executing script file.\n"
|
|
"@ingroup FileSystem\n");
|
|
addVariable( "Con::Root", TypeString, &gCurrentRoot, "The mod folder for the currently executing script file.\n"
|
|
"@ingroup FileSystem\n" );
|
|
|
|
// alwaysUseDebugOutput determines whether to send output to the platform's
|
|
// "debug" system. see winConsole for an example.
|
|
// in ship builds we don't expose this variable to script
|
|
// and we set it to false by default (don't want to provide more information
|
|
// to potential hackers). platform code should also ifdef out the code that
|
|
// pays attention to this in ship builds (see winConsole.cpp)
|
|
// note that enabling this can slow down your game
|
|
// if you are running from the debugger and printing a lot of console messages.
|
|
#ifndef TORQUE_SHIPPING
|
|
addVariable("Con::alwaysUseDebugOutput", TypeBool, &alwaysUseDebugOutput,
|
|
"@brief Determines whether to send output to the platform's \"debug\" system.\n\n"
|
|
"@note This is disabled in shipping builds.\n"
|
|
"@ingroup Console");
|
|
#else
|
|
alwaysUseDebugOutput = false;
|
|
#endif
|
|
|
|
// controls whether a timestamp is prepended to every console message
|
|
addVariable("Con::useTimestamp", TypeBool, &useTimestamp, "If true a timestamp is prepended to every console message.\n"
|
|
"@ingroup Console\n");
|
|
|
|
// controls whether a real date and time is prepended to every console message
|
|
addVariable("Con::useRealTimestamp", TypeBool, &useRealTimestamp, "If true a date and time will be prepended to every console message.\n"
|
|
"@ingroup Console\n");
|
|
|
|
// Plug us into the journaled console input signal.
|
|
smConsoleInput.notify(postConsoleInput);
|
|
}
|
|
|
|
|
|
bool isActive()
|
|
{
|
|
return active;
|
|
}
|
|
|
|
bool isMainThread()
|
|
{
|
|
#ifdef TORQUE_MULTITHREAD
|
|
return ThreadManager::isMainThread();
|
|
#else
|
|
// If we're single threaded we're always in the main thread.
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
//--------------------------------------
|
|
|
|
void getLockLog(ConsoleLogEntry *&log, U32 &size)
|
|
{
|
|
consoleLogLocked = true;
|
|
log = consoleLog.address();
|
|
size = consoleLog.size();
|
|
}
|
|
|
|
void unlockLog()
|
|
{
|
|
consoleLogLocked = false;
|
|
}
|
|
|
|
U32 tabComplete(char* inputBuffer, U32 cursorPos, U32 maxResultLength, bool forwardTab)
|
|
{
|
|
// Check for null input.
|
|
if (!inputBuffer[0])
|
|
{
|
|
return cursorPos;
|
|
}
|
|
|
|
// Cap the max result length.
|
|
if (maxResultLength > MaxCompletionBufferSize)
|
|
{
|
|
maxResultLength = MaxCompletionBufferSize;
|
|
}
|
|
|
|
// See if this is the same partial text as last checked.
|
|
if (String::compare(tabBuffer, inputBuffer))
|
|
{
|
|
// If not...
|
|
// Save it for checking next time.
|
|
dStrcpy(tabBuffer, inputBuffer, MaxCompletionBufferSize);
|
|
// Scan backward from the cursor position to find the base to complete from.
|
|
S32 p = cursorPos;
|
|
while ((p > 0) && (inputBuffer[p - 1] != ' ') && (inputBuffer[p - 1] != '.') && (inputBuffer[p - 1] != '('))
|
|
{
|
|
p--;
|
|
}
|
|
completionBaseStart = p;
|
|
completionBaseLen = cursorPos - p;
|
|
|
|
// Bail if we end up at start of string
|
|
if (p == 0)
|
|
{
|
|
return cursorPos;
|
|
}
|
|
|
|
// Is this function being invoked on an object?
|
|
if (inputBuffer[p - 1] == '.')
|
|
{
|
|
// If so...
|
|
if (p <= 1)
|
|
{
|
|
// Bail if no object identifier.
|
|
return cursorPos;
|
|
}
|
|
|
|
// Find the object identifier.
|
|
U64 objLast = --p;
|
|
while ((p > 0) && (inputBuffer[p - 1] != ' ') && (inputBuffer[p - 1] != '('))
|
|
{
|
|
p--;
|
|
}
|
|
|
|
if (objLast == p)
|
|
{
|
|
// Bail if no object identifier.
|
|
return cursorPos;
|
|
}
|
|
|
|
// Look up the object identifier.
|
|
dStrncpy(completionBuffer, inputBuffer + p, objLast - p);
|
|
completionBuffer[objLast - p] = 0;
|
|
tabObject = Sim::findObject(completionBuffer);
|
|
if (tabObject == NULL)
|
|
{
|
|
// Bail if not found.
|
|
return cursorPos;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Not invoked on an object; we'll use the global namespace.
|
|
tabObject = 0;
|
|
}
|
|
}
|
|
|
|
// Chop off the input text at the cursor position.
|
|
inputBuffer[cursorPos] = 0;
|
|
|
|
// Try to find a completion in the appropriate namespace.
|
|
const char *newText;
|
|
|
|
if (tabObject != 0)
|
|
{
|
|
newText = tabObject->tabComplete(inputBuffer + completionBaseStart, completionBaseLen, forwardTab);
|
|
}
|
|
else
|
|
{
|
|
// In the global namespace, we can complete on global vars as well as functions.
|
|
if (inputBuffer[completionBaseStart] == '$')
|
|
{
|
|
newText = gGlobalVars.tabComplete(inputBuffer + completionBaseStart, completionBaseLen, forwardTab);
|
|
}
|
|
else
|
|
{
|
|
newText = Namespace::global()->tabComplete(inputBuffer + completionBaseStart, completionBaseLen, forwardTab);
|
|
}
|
|
}
|
|
|
|
if (newText)
|
|
{
|
|
// If we got something, append it to the input text.
|
|
S32 len = dStrlen(newText);
|
|
if (len + completionBaseStart > maxResultLength)
|
|
{
|
|
len = maxResultLength - completionBaseStart;
|
|
}
|
|
dStrncpy(inputBuffer + completionBaseStart, newText, len);
|
|
inputBuffer[completionBaseStart + len] = 0;
|
|
// And set the cursor after it.
|
|
cursorPos = completionBaseStart + len;
|
|
}
|
|
|
|
// Save the modified input buffer for checking next time.
|
|
dStrcpy(tabBuffer, inputBuffer, MaxCompletionBufferSize);
|
|
|
|
// Return the new (maybe) cursor position.
|
|
return cursorPos;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
static void log(const char *string)
|
|
{
|
|
// Bail if we ain't logging.
|
|
if (!consoleLogMode)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// In mode 1, we open, append, close on each log write.
|
|
if ((consoleLogMode & 0x3) == 1)
|
|
{
|
|
consoleLogFile.open(defLogFileName, Torque::FS::File::ReadWrite);
|
|
}
|
|
|
|
// Write to the log if its status is hunky-dory.
|
|
if ((consoleLogFile.getStatus() == Stream::Ok) || (consoleLogFile.getStatus() == Stream::EOS))
|
|
{
|
|
consoleLogFile.setPosition(consoleLogFile.getStreamSize());
|
|
// If this is the first write...
|
|
if (newLogFile)
|
|
{
|
|
// Make a header.
|
|
Platform::LocalTime lt;
|
|
Platform::getLocalTime(lt);
|
|
char buffer[128];
|
|
dSprintf(buffer, sizeof(buffer), "//-------------------------- %d/%d/%d -- %02d:%02d:%02d -----\r\n",
|
|
lt.month + 1,
|
|
lt.monthday,
|
|
lt.year + 1900,
|
|
lt.hour,
|
|
lt.min,
|
|
lt.sec);
|
|
consoleLogFile.write(dStrlen(buffer), buffer);
|
|
newLogFile = false;
|
|
if (consoleLogMode & 0x4)
|
|
{
|
|
// Dump anything that has been printed to the console so far.
|
|
consoleLogMode -= 0x4;
|
|
U32 size, line;
|
|
ConsoleLogEntry *log;
|
|
getLockLog(log, size);
|
|
for (line = 0; line < size; line++)
|
|
{
|
|
consoleLogFile.write(dStrlen(log[line].mString), log[line].mString);
|
|
consoleLogFile.write(2, "\r\n");
|
|
}
|
|
unlockLog();
|
|
}
|
|
}
|
|
// Now write what we came here to write.
|
|
consoleLogFile.write(dStrlen(string), string);
|
|
consoleLogFile.write(2, "\r\n");
|
|
}
|
|
|
|
if ((consoleLogMode & 0x3) == 1)
|
|
{
|
|
consoleLogFile.close();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
static void _printf(ConsoleLogEntry::Level level, ConsoleLogEntry::Type type, const char* fmt, va_list argptr)
|
|
{
|
|
if (!active)
|
|
return;
|
|
Con::active = false;
|
|
|
|
char buffer[8192] = {};
|
|
U32 offset = 0;
|
|
if( gTraceOn && !getFrameStack().empty())
|
|
{
|
|
offset = getFrameStack().size() * 3;
|
|
for(U32 i = 0; i < offset; i++)
|
|
buffer[i] = ' ';
|
|
}
|
|
|
|
if (useRealTimestamp)
|
|
{
|
|
Platform::LocalTime lt;
|
|
Platform::getLocalTime(lt);
|
|
offset += dSprintf(buffer + offset, sizeof(buffer) - offset, "[%d-%d-%d %02d:%02d:%02d]", lt.year + 1900, lt.month + 1, lt.monthday, lt.hour, lt.min, lt.sec);
|
|
}
|
|
|
|
if (useTimestamp)
|
|
{
|
|
U32 curTime = Platform::getRealMilliseconds() - startTime;
|
|
offset += dSprintf(buffer + offset, sizeof(buffer) - offset, "[+%4d.%03d]", U32(curTime * 0.001), curTime % 1000);
|
|
}
|
|
|
|
if (useTimestamp || useRealTimestamp)
|
|
{
|
|
offset += dSprintf(buffer + offset, sizeof(buffer) - offset, " ");
|
|
}
|
|
|
|
dVsprintf(buffer + offset, sizeof(buffer) - offset, fmt, argptr);
|
|
|
|
for(S32 i = 0; i < gConsumers.size(); i++)
|
|
gConsumers[i](level, buffer);
|
|
|
|
if(logBufferEnabled || consoleLogMode)
|
|
{
|
|
char *pos = buffer;
|
|
while(*pos)
|
|
{
|
|
if(*pos == '\t')
|
|
*pos = '^';
|
|
pos++;
|
|
}
|
|
pos = buffer;
|
|
|
|
for(;;)
|
|
{
|
|
char *eofPos = dStrchr(pos, '\n');
|
|
if(eofPos)
|
|
*eofPos = 0;
|
|
|
|
log(pos);
|
|
if(logBufferEnabled && !consoleLogLocked)
|
|
{
|
|
ConsoleLogEntry entry;
|
|
entry.mLevel = level;
|
|
entry.mType = type;
|
|
#ifndef TORQUE_SHIPPING // this is equivalent to a memory leak, turn it off in ship build
|
|
U64 logStringLen = dStrlen(pos) + 1;
|
|
entry.mString = (const char *)consoleLogChunker.alloc(logStringLen);
|
|
dStrcpy(const_cast<char*>(entry.mString), pos, logStringLen);
|
|
|
|
// This prevents infinite recursion if the console itself needs to
|
|
// re-allocate memory to accommodate the new console log entry, and
|
|
// LOG_PAGE_ALLOCS is defined. It is kind of a dirty hack, but the
|
|
// uses for LOG_PAGE_ALLOCS are limited, and it is not worth writing
|
|
// a lot of special case code to support this situation. -patw
|
|
const bool save = Con::active;
|
|
Con::active = false;
|
|
consoleLog.push_back(entry);
|
|
Con::active = save;
|
|
#endif
|
|
}
|
|
if(!eofPos)
|
|
break;
|
|
pos = eofPos + 1;
|
|
}
|
|
}
|
|
|
|
Con::active = true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
void printf(const char* fmt,...)
|
|
{
|
|
va_list argptr;
|
|
va_start(argptr, fmt);
|
|
_printf(ConsoleLogEntry::Normal, ConsoleLogEntry::General, fmt, argptr);
|
|
va_end(argptr);
|
|
}
|
|
|
|
void warnf(ConsoleLogEntry::Type type, const char* fmt,...)
|
|
{
|
|
va_list argptr;
|
|
va_start(argptr, fmt);
|
|
_printf(ConsoleLogEntry::Warning, type, fmt, argptr);
|
|
va_end(argptr);
|
|
}
|
|
|
|
void errorf(ConsoleLogEntry::Type type, const char* fmt,...)
|
|
{
|
|
va_list argptr;
|
|
va_start(argptr, fmt);
|
|
_printf(ConsoleLogEntry::Error, type, fmt, argptr);
|
|
va_end(argptr);
|
|
}
|
|
|
|
void warnf(const char* fmt,...)
|
|
{
|
|
va_list argptr;
|
|
va_start(argptr, fmt);
|
|
_printf(ConsoleLogEntry::Warning, ConsoleLogEntry::General, fmt, argptr);
|
|
va_end(argptr);
|
|
}
|
|
|
|
void errorf(const char* fmt,...)
|
|
{
|
|
va_list argptr;
|
|
va_start(argptr, fmt);
|
|
_printf(ConsoleLogEntry::Error, ConsoleLogEntry::General, fmt, argptr);
|
|
va_end(argptr);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
bool getVariableObjectField(const char *name, SimObject **object, const char **field)
|
|
{
|
|
// get the field info from the object..
|
|
const char *dot = dStrchr(name, '.');
|
|
if(name[0] != '$' && dot)
|
|
{
|
|
U64 len = dStrlen(name);
|
|
AssertFatal(len < sizeof(scratchBuffer)-1, "Sim::getVariable - name too long");
|
|
dMemcpy(scratchBuffer, name, len+1);
|
|
|
|
char * token = dStrtok(scratchBuffer, ".");
|
|
SimObject * obj = Sim::findObject(token);
|
|
if(!obj)
|
|
return false;
|
|
|
|
token = dStrtok(0, ".\0");
|
|
if(!token)
|
|
return false;
|
|
|
|
while(token != NULL)
|
|
{
|
|
const char * val = obj->getDataField(StringTable->insert(token), 0);
|
|
if(!val)
|
|
return false;
|
|
|
|
char *fieldToken = token;
|
|
token = dStrtok(0, ".\0");
|
|
if(token)
|
|
{
|
|
obj = Sim::findObject(token);
|
|
if(!obj)
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
*object = obj;
|
|
*field = fieldToken;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
Dictionary::Entry *getVariableEntry(const char *name)
|
|
{
|
|
name = prependDollar(name);
|
|
return gGlobalVars.lookup(StringTable->insert(name));
|
|
}
|
|
|
|
Dictionary::Entry *addVariableEntry(const char *name)
|
|
{
|
|
name = prependDollar(name);
|
|
return gGlobalVars.add(StringTable->insert(name));
|
|
}
|
|
|
|
Dictionary::Entry *getAddVariableEntry(const char *name)
|
|
{
|
|
name = prependDollar(name);
|
|
StringTableEntry stName = StringTable->insert(name);
|
|
Dictionary::Entry *entry = gGlobalVars.lookup(stName);
|
|
if (!entry)
|
|
entry = gGlobalVars.add(stName);
|
|
return entry;
|
|
}
|
|
|
|
void setVariable(const char *name, const char *value)
|
|
{
|
|
SimObject *obj = NULL;
|
|
const char *objField = NULL;
|
|
|
|
if (getVariableObjectField(name, &obj, &objField))
|
|
{
|
|
obj->setDataField(StringTable->insert(objField), 0, value);
|
|
}
|
|
else
|
|
{
|
|
name = prependDollar(name);
|
|
gGlobalVars.setVariable(StringTable->insert(name), value);
|
|
}
|
|
}
|
|
|
|
void setBoolVariable(const char *varName, bool value)
|
|
{
|
|
SimObject *obj = NULL;
|
|
const char *objField = NULL;
|
|
|
|
if (getVariableObjectField(varName, &obj, &objField))
|
|
{
|
|
obj->setDataField(StringTable->insert(objField), 0, value ? "1" : "0");
|
|
}
|
|
else
|
|
{
|
|
varName = prependDollar(varName);
|
|
Dictionary::Entry *entry = getAddVariableEntry(varName);
|
|
entry->setStringValue(value ? "1" : "0");
|
|
}
|
|
}
|
|
|
|
void setIntVariable(const char *varName, S32 value)
|
|
{
|
|
SimObject *obj = NULL;
|
|
const char *objField = NULL;
|
|
|
|
if (getVariableObjectField(varName, &obj, &objField))
|
|
{
|
|
char varBuffer[32];
|
|
dSprintf(varBuffer, sizeof(varBuffer), "%d", value);
|
|
obj->setDataField(StringTable->insert(objField), 0, varBuffer);
|
|
}
|
|
else
|
|
{
|
|
varName = prependDollar(varName);
|
|
Dictionary::Entry *entry = getAddVariableEntry(varName);
|
|
entry->setIntValue(value);
|
|
}
|
|
}
|
|
|
|
void setFloatVariable(const char *varName, F32 value)
|
|
{
|
|
SimObject *obj = NULL;
|
|
const char *objField = NULL;
|
|
|
|
if (getVariableObjectField(varName, &obj, &objField))
|
|
{
|
|
char varBuffer[32];
|
|
dSprintf(varBuffer, sizeof(varBuffer), "%g", value);
|
|
obj->setDataField(StringTable->insert(objField), 0, varBuffer);
|
|
}
|
|
else
|
|
{
|
|
varName = prependDollar(varName);
|
|
Dictionary::Entry *entry = getAddVariableEntry(varName);
|
|
entry->setFloatValue(value);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
void addConsumer(ConsumerCallback consumer)
|
|
{
|
|
gConsumers.push_back(consumer);
|
|
}
|
|
|
|
// dhc - found this empty -- trying what I think is a reasonable impl.
|
|
void removeConsumer(ConsumerCallback consumer)
|
|
{
|
|
for(S32 i = 0; i < gConsumers.size(); i++)
|
|
{
|
|
if (gConsumers[i] == consumer)
|
|
{
|
|
// remove it from the list.
|
|
gConsumers.erase(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void stripColorChars(char* line)
|
|
{
|
|
char* c = line;
|
|
char cp = *c;
|
|
while (cp)
|
|
{
|
|
if (cp < 18)
|
|
{
|
|
// Could be a color control character; let's take a closer look.
|
|
if ((cp != 8) && (cp != 9) && (cp != 10) && (cp != 13))
|
|
{
|
|
// Yep... copy following chars forward over this.
|
|
char* cprime = c;
|
|
char cpp;
|
|
do
|
|
{
|
|
cpp = *++cprime;
|
|
*(cprime - 1) = cpp;
|
|
}
|
|
while (cpp);
|
|
// Back up 1 so we'll check this position again post-copy.
|
|
c--;
|
|
}
|
|
}
|
|
cp = *++c;
|
|
}
|
|
}
|
|
|
|
//
|
|
const char *getObjectTokenField(const char *name)
|
|
{
|
|
const char *dot = dStrchr(name, '.');
|
|
if(name[0] != '$' && dot)
|
|
{
|
|
U64 len = dStrlen(name);
|
|
AssertFatal(len < sizeof(scratchBuffer)-1, "Sim::getVariable - object name too long");
|
|
dMemcpy(scratchBuffer, name, len+1);
|
|
|
|
char * token = dStrtok(scratchBuffer, ".");
|
|
SimObject * obj = Sim::findObject(token);
|
|
if(!obj)
|
|
return("");
|
|
|
|
token = dStrtok(0, ".\0");
|
|
if(!token)
|
|
return("");
|
|
|
|
while(token != NULL)
|
|
{
|
|
const char * val = obj->getDataField(StringTable->insert(token), 0);
|
|
if(!val)
|
|
return("");
|
|
|
|
token = dStrtok(0, ".\0");
|
|
if(token)
|
|
{
|
|
obj = Sim::findObject(token);
|
|
if(!obj)
|
|
return("");
|
|
}
|
|
else
|
|
return(val);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
const char *getVariable(const char *name, const char* def)
|
|
{
|
|
const char *objField = getObjectTokenField(name);
|
|
if (objField)
|
|
{
|
|
return objField;
|
|
}
|
|
else
|
|
{
|
|
Dictionary::Entry *entry = getVariableEntry(name);
|
|
return entry ? entry->getStringValue() : def;
|
|
}
|
|
}
|
|
|
|
const char *getLocalVariable(const char *name)
|
|
{
|
|
name = prependPercent(name);
|
|
|
|
return Con::getCurrentStackFrame()->getVariable(StringTable->insert(name));
|
|
}
|
|
|
|
bool getBoolVariable(const char *varName, bool def)
|
|
{
|
|
const char *objField = getObjectTokenField(varName);
|
|
if (objField)
|
|
{
|
|
return *objField ? dAtob(objField) : def;
|
|
}
|
|
else
|
|
{
|
|
Dictionary::Entry *entry = getVariableEntry(varName);
|
|
objField = entry ? entry->getStringValue() : "";
|
|
return *objField ? dAtob(objField) : def;
|
|
}
|
|
}
|
|
|
|
S32 getIntVariable(const char *varName, S32 def)
|
|
{
|
|
const char *objField = getObjectTokenField(varName);
|
|
if (objField)
|
|
{
|
|
return *objField ? dAtoi(objField) : def;
|
|
}
|
|
else
|
|
{
|
|
Dictionary::Entry *entry = getVariableEntry(varName);
|
|
return entry ? entry->getIntValue() : def;
|
|
}
|
|
}
|
|
|
|
F32 getFloatVariable(const char *varName, F32 def)
|
|
{
|
|
const char *objField = getObjectTokenField(varName);
|
|
if (objField)
|
|
{
|
|
return *objField ? dAtof(objField) : def;
|
|
}
|
|
else
|
|
{
|
|
Dictionary::Entry *entry = getVariableEntry(varName);
|
|
return entry ? entry->getFloatValue() : def;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void addVariable( const char *name,
|
|
S32 type,
|
|
void *dptr,
|
|
const char* usage )
|
|
{
|
|
gGlobalVars.addVariable( name, type, dptr, usage );
|
|
}
|
|
|
|
void addConstant( const char *name,
|
|
S32 type,
|
|
const void *dptr,
|
|
const char* usage )
|
|
{
|
|
Dictionary::Entry* entry = gGlobalVars.addVariable( name, type, const_cast< void* >( dptr ), usage );
|
|
entry->mIsConstant = true;
|
|
}
|
|
|
|
bool removeVariable(const char *name)
|
|
{
|
|
name = StringTable->lookup(prependDollar(name));
|
|
return name!=0 && gGlobalVars.removeVariable(name);
|
|
}
|
|
|
|
void addVariableNotify( const char *name, const NotifyDelegate &callback )
|
|
{
|
|
gGlobalVars.addVariableNotify( name, callback );
|
|
}
|
|
|
|
void removeVariableNotify( const char *name, const NotifyDelegate &callback )
|
|
{
|
|
gGlobalVars.removeVariableNotify( name, callback );
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void addCommand( const char *nsName, const char *name,StringCallback cb, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
Namespace *ns = lookupNamespace(nsName);
|
|
ns->addCommand( StringTable->insert(name), cb, usage, minArgs, maxArgs, isToolOnly, header );
|
|
}
|
|
|
|
void addCommand( const char *nsName, const char *name,VoidCallback cb, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
Namespace *ns = lookupNamespace(nsName);
|
|
ns->addCommand( StringTable->insert(name), cb, usage, minArgs, maxArgs, isToolOnly, header );
|
|
}
|
|
|
|
void addCommand( const char *nsName, const char *name,IntCallback cb, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
Namespace *ns = lookupNamespace(nsName);
|
|
ns->addCommand( StringTable->insert(name), cb, usage, minArgs, maxArgs, isToolOnly, header );
|
|
}
|
|
|
|
void addCommand( const char *nsName, const char *name,FloatCallback cb, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
Namespace *ns = lookupNamespace(nsName);
|
|
ns->addCommand( StringTable->insert(name), cb, usage, minArgs, maxArgs, isToolOnly, header );
|
|
}
|
|
|
|
void addCommand( const char *nsName, const char *name,BoolCallback cb, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
Namespace *ns = lookupNamespace(nsName);
|
|
ns->addCommand( StringTable->insert(name), cb, usage, minArgs, maxArgs, isToolOnly, header );
|
|
}
|
|
|
|
void noteScriptCallback( const char *className, const char *funcName, const char *usage, ConsoleFunctionHeader* header )
|
|
{
|
|
Namespace *ns = lookupNamespace(className);
|
|
ns->addScriptCallback( StringTable->insert(funcName), usage, header );
|
|
}
|
|
|
|
void markCommandGroup(const char * nsName, const char *name, const char* usage)
|
|
{
|
|
Namespace *ns = lookupNamespace(nsName);
|
|
ns->markGroup(name,usage);
|
|
}
|
|
|
|
void beginCommandGroup(const char * nsName, const char *name, const char* usage)
|
|
{
|
|
markCommandGroup(nsName, name, usage);
|
|
}
|
|
|
|
void endCommandGroup(const char * nsName, const char *name)
|
|
{
|
|
markCommandGroup(nsName, name, NULL);
|
|
}
|
|
|
|
void addCommand( const char *name,StringCallback cb,const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
Namespace::global()->addCommand( StringTable->insert(name), cb, usage, minArgs, maxArgs, isToolOnly, header );
|
|
}
|
|
|
|
void addCommand( const char *name,VoidCallback cb,const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
Namespace::global()->addCommand( StringTable->insert(name), cb, usage, minArgs, maxArgs, isToolOnly, header );
|
|
}
|
|
|
|
void addCommand( const char *name,IntCallback cb,const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
Namespace::global()->addCommand( StringTable->insert(name), cb, usage, minArgs, maxArgs, isToolOnly, header );
|
|
}
|
|
|
|
void addCommand( const char *name,FloatCallback cb,const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
Namespace::global()->addCommand( StringTable->insert(name), cb, usage, minArgs, maxArgs, isToolOnly, header );
|
|
}
|
|
|
|
void addCommand( const char *name,BoolCallback cb,const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header )
|
|
{
|
|
Namespace::global()->addCommand( StringTable->insert(name), cb, usage, minArgs, maxArgs, isToolOnly, header );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Internal execute for global function which does not save the stack
|
|
ConsoleValue _internalExecute(S32 argc, ConsoleValue argv[])
|
|
{
|
|
StringTableEntry funcName = StringTable->insert(argv[0].getString());
|
|
Namespace::Entry *ent;
|
|
|
|
ent = Namespace::global()->lookup(funcName);
|
|
|
|
if(!ent)
|
|
{
|
|
warnf(ConsoleLogEntry::Script, "%s: Unknown command.", funcName);
|
|
|
|
STR.clearFunctionOffset();
|
|
return (ConsoleValue());
|
|
}
|
|
|
|
return (ent->execute(argc, argv, NULL));
|
|
}
|
|
|
|
ConsoleValue execute(S32 argc, ConsoleValue argv[])
|
|
{
|
|
#ifdef TORQUE_MULTITHREAD
|
|
if(isMainThread())
|
|
{
|
|
#endif
|
|
ConsoleStackFrameSaver stackSaver;
|
|
stackSaver.save();
|
|
return _internalExecute(argc, argv);
|
|
#ifdef TORQUE_MULTITHREAD
|
|
}
|
|
else
|
|
{
|
|
SimConsoleThreadExecCallback cb;
|
|
SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(argc, argv, false, &cb);
|
|
Sim::postEvent(Sim::getRootGroup(), evt, Sim::getCurrentTime());
|
|
|
|
return cb.waitForResult();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
ConsoleValue execute(S32 argc, const char *argv[])
|
|
{
|
|
ConsoleStackFrameSaver stackSaver;
|
|
stackSaver.save();
|
|
StringArrayToConsoleValueWrapper args(argc, argv);
|
|
return (execute(args.count(), args));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Internal execute for object method which does not save the stack
|
|
static ConsoleValue _internalExecute(SimObject *object, S32 argc, ConsoleValue argv[], bool thisCallOnly)
|
|
{
|
|
if (object == NULL)
|
|
return (ConsoleValue());
|
|
|
|
if(argc < 2)
|
|
{
|
|
STR.clearFunctionOffset();
|
|
return (ConsoleValue());
|
|
}
|
|
|
|
// [neo, 10/05/2007 - #3010]
|
|
// Make sure we don't get recursive calls, respect the flag!
|
|
// Should we be calling handlesMethod() first?
|
|
if( !thisCallOnly )
|
|
{
|
|
ICallMethod *com = dynamic_cast<ICallMethod *>(object);
|
|
if(com)
|
|
{
|
|
ConsoleStackFrameSaver saver;
|
|
saver.save();
|
|
com->callMethodArgList(argc, argv, false);
|
|
}
|
|
}
|
|
|
|
StringTableEntry funcName = StringTable->insert(argv[0].getString());
|
|
|
|
if(object->getNamespace())
|
|
{
|
|
U32 ident = object->getId();
|
|
Namespace::Entry *ent = object->getNamespace()->lookup(funcName);
|
|
|
|
if(ent == NULL)
|
|
{
|
|
//warnf(ConsoleLogEntry::Script, "%s: undefined for object '%s' - id %d", funcName, object->getName(), object->getId());
|
|
STR.clearFunctionOffset();
|
|
return (ConsoleValue());
|
|
}
|
|
|
|
const char* oldIdent = dStrdup(argv[1].getString());
|
|
|
|
// Twiddle %this argument
|
|
argv[1].setInt(ident);
|
|
|
|
ConsoleValue ret = (ent->execute(argc, argv, object));
|
|
|
|
// Twiddle it back
|
|
argv[1].setString(oldIdent);
|
|
dFree(oldIdent);
|
|
|
|
return ret;
|
|
}
|
|
|
|
warnf(ConsoleLogEntry::Script, "Con::execute - %d has no namespace: %s", object->getId(), funcName);
|
|
STR.clearFunctionOffset();
|
|
return (ConsoleValue());
|
|
}
|
|
|
|
ConsoleValue execute(SimObject *object, S32 argc, ConsoleValue argv[], bool thisCallOnly)
|
|
{
|
|
if(argc < 2)
|
|
{
|
|
STR.clearFunctionOffset();
|
|
return (ConsoleValue());
|
|
}
|
|
|
|
ConsoleStackFrameSaver stackSaver;
|
|
stackSaver.save();
|
|
|
|
if (object->getNamespace() || !thisCallOnly)
|
|
{
|
|
if (isMainThread())
|
|
{
|
|
return (_internalExecute(object, argc, argv, thisCallOnly));
|
|
}
|
|
else
|
|
{
|
|
SimConsoleThreadExecCallback cb;
|
|
SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(argc, argv, true, &cb);
|
|
Sim::postEvent(object, evt, Sim::getCurrentTime());
|
|
}
|
|
}
|
|
|
|
warnf(ConsoleLogEntry::Script, "Con::execute - %d has no namespace: %s", object->getId(), argv[0].getString());
|
|
STR.clearFunctionOffset();
|
|
return (ConsoleValue());
|
|
}
|
|
|
|
ConsoleValue execute(SimObject *object, S32 argc, const char *argv[], bool thisCallOnly)
|
|
{
|
|
ConsoleStackFrameSaver stackSaver;
|
|
stackSaver.save();
|
|
StringArrayToConsoleValueWrapper args(argc, argv);
|
|
return (execute(object, args.count(), args, thisCallOnly));
|
|
}
|
|
|
|
inline ConsoleValue _executef(SimObject *obj, S32 checkArgc, S32 argc, ConsoleValue *argv)
|
|
{
|
|
const U32 maxArg = 12;
|
|
AssertFatal(checkArgc == argc, "Incorrect arg count passed to Con::executef(SimObject*)");
|
|
AssertFatal(argc <= maxArg - 1, "Too many args passed to Con::_executef(SimObject*). Please update the function to handle more.");
|
|
return (execute(obj, argc, argv));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
inline ConsoleValue _executef(S32 checkArgc, S32 argc, ConsoleValue *argv)
|
|
{
|
|
const U32 maxArg = 10;
|
|
AssertFatal(checkArgc == argc, "Incorrect arg count passed to Con::executef()");
|
|
AssertFatal(argc <= maxArg, "Too many args passed to Con::_executef(). Please update the function to handle more.");
|
|
return (execute(argc, argv));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
bool isFunction(const char *fn)
|
|
{
|
|
const char *string = StringTable->lookup(fn);
|
|
if(!string)
|
|
return false;
|
|
else
|
|
return Namespace::global()->lookup(string) != NULL;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void setLogMode(S32 newMode)
|
|
{
|
|
if ((newMode & 0x3) != (consoleLogMode & 0x3)) {
|
|
if (newMode && !consoleLogMode) {
|
|
// Enabling logging when it was previously disabled.
|
|
newLogFile = true;
|
|
}
|
|
if ((consoleLogMode & 0x3) == 2) {
|
|
// Changing away from mode 2, must close logfile.
|
|
consoleLogFile.close();
|
|
}
|
|
else if ((newMode & 0x3) == 2) {
|
|
#ifdef _XBOX
|
|
// Xbox is not going to support logging to a file. Use the OutputDebugStr
|
|
// log consumer
|
|
Platform::debugBreak();
|
|
#endif
|
|
// Starting mode 2, must open logfile.
|
|
consoleLogFile.open(defLogFileName, Torque::FS::File::Write);
|
|
}
|
|
consoleLogMode = newMode;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
ReturnBuffer retBuffer;
|
|
|
|
char* getReturnBuffer(U32 bufferSize)
|
|
{
|
|
return retBuffer.getBuffer(bufferSize);
|
|
}
|
|
|
|
char* getReturnBuffer(const char* stringToCopy)
|
|
{
|
|
U32 len = dStrlen(stringToCopy) + 1;
|
|
char* ret = retBuffer.getBuffer(len);
|
|
dMemcpy(ret, stringToCopy, len);
|
|
return ret;
|
|
}
|
|
|
|
char* getReturnBuffer(const String& str)
|
|
{
|
|
const U32 size = str.size();
|
|
char* ret = retBuffer.getBuffer(size);
|
|
dMemcpy(ret, str.c_str(), size);
|
|
return ret;
|
|
}
|
|
|
|
char* getReturnBuffer(const StringBuilder& str)
|
|
{
|
|
char* buffer = Con::getReturnBuffer(str.length() + 1);
|
|
str.copy(buffer);
|
|
buffer[str.length()] = '\0';
|
|
|
|
return buffer;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
char* getBoolArg(bool arg)
|
|
{
|
|
char* ret = STR.getArgBuffer(32);
|
|
dSprintf(ret, 32, "%d", arg);
|
|
return ret;
|
|
}
|
|
|
|
char* getStringArg(const char* arg)
|
|
{
|
|
U32 len = dStrlen(arg) + 1;
|
|
char* ret = STR.getArgBuffer(len);
|
|
dMemcpy(ret, arg, len);
|
|
return ret;
|
|
}
|
|
|
|
char* getStringArg(const String& arg)
|
|
{
|
|
const U32 size = arg.size();
|
|
char* ret = STR.getArgBuffer(size);
|
|
dMemcpy(ret, arg.c_str(), size);
|
|
return ret;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
Namespace *lookupNamespace(const char *ns)
|
|
{
|
|
if(!ns)
|
|
return Namespace::global();
|
|
return Namespace::find(StringTable->insert(ns));
|
|
}
|
|
|
|
bool linkNamespaces(const char *parent, const char *child)
|
|
{
|
|
Namespace *pns = lookupNamespace(parent);
|
|
Namespace *cns = lookupNamespace(child);
|
|
if(pns && cns)
|
|
return cns->classLinkTo(pns);
|
|
return false;
|
|
}
|
|
|
|
bool unlinkNamespaces(const char *parent, const char *child)
|
|
{
|
|
Namespace *pns = lookupNamespace(parent);
|
|
Namespace *cns = lookupNamespace(child);
|
|
|
|
if(pns == cns)
|
|
{
|
|
Con::warnf("Con::unlinkNamespaces - trying to unlink '%s' from itself, aborting.", parent);
|
|
return false;
|
|
}
|
|
|
|
if(pns && cns)
|
|
return cns->unlinkClass(pns);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool classLinkNamespaces(Namespace *parent, Namespace *child)
|
|
{
|
|
if(parent && child)
|
|
return child->classLinkTo(parent);
|
|
return false;
|
|
}
|
|
|
|
void setData(S32 type, void *dptr, S32 index, S32 argc, const char **argv, const EnumTable *tbl, BitSet32 flag)
|
|
{
|
|
ConsoleBaseType *cbt = ConsoleBaseType::getType(type);
|
|
AssertFatal(cbt, "Con::setData - could not resolve type ID!");
|
|
cbt->setData((void *) (((const char *)dptr) + index * cbt->getTypeSize()),argc, argv, tbl, flag);
|
|
}
|
|
|
|
const char *getData(S32 type, void *dptr, S32 index, const EnumTable *tbl, BitSet32 flag)
|
|
{
|
|
ConsoleBaseType *cbt = ConsoleBaseType::getType(type);
|
|
AssertFatal(cbt, "Con::getData - could not resolve type ID!");
|
|
return cbt->getData((void *) (((const char *)dptr) + index * cbt->getTypeSize()), tbl, flag);
|
|
}
|
|
|
|
const char *getFormattedData(S32 type, const char *data, const EnumTable *tbl, BitSet32 flag)
|
|
{
|
|
ConsoleBaseType *cbt = ConsoleBaseType::getType( type );
|
|
AssertFatal(cbt, "Con::getData - could not resolve type ID!");
|
|
|
|
// Datablock types are just a datablock
|
|
// name and don't ever need formatting.
|
|
if ( cbt->isDatablock() )
|
|
return data;
|
|
|
|
bool currWarn = gWarnUndefinedScriptVariables;
|
|
gWarnUndefinedScriptVariables = false;
|
|
|
|
const char* globalValue = Con::getVariable(data);
|
|
|
|
gWarnUndefinedScriptVariables = currWarn;
|
|
|
|
if (dStrlen(globalValue) > 0)
|
|
return globalValue;
|
|
|
|
void* variable = cbt->getNativeVariable();
|
|
|
|
if (variable)
|
|
{
|
|
Con::setData(type, variable, 0, 1, &data, tbl, flag);
|
|
const char* formattedVal = Con::getData(type, variable, 0, tbl, flag);
|
|
|
|
static const U32 bufSize = 2048;
|
|
char* returnBuffer = Con::getReturnBuffer(bufSize);
|
|
dSprintf(returnBuffer, bufSize, "%s\0", formattedVal );
|
|
|
|
cbt->deleteNativeVariable(variable);
|
|
|
|
return returnBuffer;
|
|
}
|
|
else
|
|
return data;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool isCurrentScriptToolScript()
|
|
{
|
|
// With a player build we ALWAYS return false
|
|
#ifndef TORQUE_TOOLS
|
|
return false;
|
|
#else
|
|
const StringTableEntry cbFullPath = getCurrentScriptModulePath();
|
|
if(cbFullPath == NULL)
|
|
return false;
|
|
const StringTableEntry exePath = Platform::getMainDotCsDir();
|
|
|
|
return dStrnicmp(exePath, cbFullPath, dStrlen(exePath)) == 0;
|
|
#endif
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
bool isScriptFile(const char* pFilePath)
|
|
{
|
|
return (Torque::FS::IsFile(pFilePath)
|
|
|| Torque::FS::IsFile(pFilePath + String(".dso"))
|
|
|| Torque::FS::IsFile(pFilePath + String(".mis"))
|
|
|| Torque::FS::IsFile(pFilePath + String(".mis.dso"))
|
|
|| Torque::FS::IsFile(pFilePath + String(".gui"))
|
|
|| Torque::FS::IsFile(pFilePath + String(".gui.dso"))
|
|
|| Torque::FS::IsFile(pFilePath + String("." TORQUE_SCRIPT_EXTENSION))
|
|
|| Torque::FS::IsFile(pFilePath + String("." TORQUE_SCRIPT_EXTENSION) + String(".dso")));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
StringTableEntry getModNameFromPath(const char *path)
|
|
{
|
|
if(path == NULL || *path == 0)
|
|
return NULL;
|
|
|
|
char buf[1024] = {};
|
|
buf[0] = 0;
|
|
|
|
if(path[0] == '/' || path[1] == ':')
|
|
{
|
|
// It's an absolute path
|
|
const StringTableEntry exePath = Platform::getMainDotCsDir();
|
|
U32 len = dStrlen(exePath);
|
|
if(dStrnicmp(exePath, path, len) == 0)
|
|
{
|
|
const char *ptr = path + len + 1;
|
|
const char *slash = dStrchr(ptr, '/');
|
|
if(slash)
|
|
{
|
|
dStrncpy(buf, ptr, slash - ptr);
|
|
buf[slash - ptr] = 0;
|
|
}
|
|
else
|
|
return NULL;
|
|
}
|
|
else
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
const char *slash = dStrchr(path, '/');
|
|
if(slash)
|
|
{
|
|
dStrncpy(buf, path, slash - path);
|
|
buf[slash - path] = 0;
|
|
}
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
return StringTable->insert(buf);
|
|
}
|
|
|
|
void postConsoleInput( RawData data )
|
|
{
|
|
// Schedule this to happen at the next time event.
|
|
ConsoleValue argv[2];
|
|
argv[0].setStringTableEntry("eval");
|
|
argv[1].setString(reinterpret_cast<const char*>(data.data));
|
|
|
|
Sim::postCurrentEvent(Sim::getRootGroup(), new SimConsoleEvent(2, argv, false));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void pushInstantGroup( String name )
|
|
{
|
|
sInstantGroupStack.push_back( gInstantGroup );
|
|
gInstantGroup = name;
|
|
}
|
|
|
|
void popInstantGroup()
|
|
{
|
|
if( sInstantGroupStack.empty() )
|
|
gInstantGroup = String::EmptyString;
|
|
else
|
|
{
|
|
gInstantGroup = sInstantGroupStack.last();
|
|
sInstantGroupStack.pop_back();
|
|
}
|
|
}
|
|
|
|
|
|
typedef HashMap<StringTableEntry, StringTableEntry> typePathExpandoMap;
|
|
static typePathExpandoMap PathExpandos;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void addPathExpando(const char* pExpandoName, const char* pPath)
|
|
{
|
|
// Sanity!
|
|
AssertFatal(pExpandoName != NULL, "Expando name cannot be NULL.");
|
|
AssertFatal(pPath != NULL, "Expando path cannot be NULL.");
|
|
|
|
// Fetch expando name.
|
|
StringTableEntry expandoName = StringTable->insert(pExpandoName);
|
|
|
|
// Fetch the length of the path.
|
|
S32 pathLength = dStrlen(pPath);
|
|
|
|
char pathBuffer[1024];
|
|
|
|
// Sanity!
|
|
if (pathLength == 0 || pathLength >= sizeof(pathBuffer))
|
|
{
|
|
Con::warnf("Cannot add path expando '%s' with path '%s' as the path is an invalid length.", pExpandoName, pPath);
|
|
return;
|
|
}
|
|
|
|
// Strip repeat slashes.
|
|
if (!Con::stripRepeatSlashes(pathBuffer, pPath, sizeof(pathBuffer)))
|
|
{
|
|
Con::warnf("Cannot add path expando '%s' with path '%s' as the path is an invalid length.", pExpandoName, pPath);
|
|
return;
|
|
}
|
|
|
|
// Fetch new path length.
|
|
pathLength = dStrlen(pathBuffer);
|
|
|
|
// Sanity!
|
|
if (pathLength == 0)
|
|
{
|
|
Con::warnf("Cannot add path expando '%s' with path '%s' as the path is an invalid length.", pExpandoName, pPath);
|
|
return;
|
|
}
|
|
|
|
// Remove any terminating slash.
|
|
if (pathBuffer[pathLength - 1] == '/')
|
|
pathBuffer[pathLength - 1] = 0;
|
|
|
|
// Fetch expanded path.
|
|
StringTableEntry expandedPath = StringTable->insert(pathBuffer);
|
|
|
|
// Info.
|
|
#if defined(TORQUE_DEBUG)
|
|
Con::printf("Adding path expando of '%s' as '%s'.", expandoName, expandedPath);
|
|
#endif
|
|
|
|
// Find any existing path expando.
|
|
typePathExpandoMap::iterator expandoItr = PathExpandos.find(pExpandoName);
|
|
|
|
// Does the expando exist?
|
|
if (expandoItr != PathExpandos.end())
|
|
{
|
|
// Yes, so modify the path.
|
|
expandoItr->value = expandedPath;
|
|
return;
|
|
}
|
|
|
|
// Insert expando.
|
|
PathExpandos.insert(expandoName, expandedPath);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
StringTableEntry getPathExpando(const char* pExpandoName)
|
|
{
|
|
// Sanity!
|
|
AssertFatal(pExpandoName != NULL, "Expando name cannot be NULL.");
|
|
|
|
// Fetch expando name.
|
|
StringTableEntry expandoName = StringTable->insert(pExpandoName);
|
|
|
|
// Find any existing path expando.
|
|
typePathExpandoMap::iterator expandoItr = PathExpandos.find(expandoName);
|
|
|
|
// Does the expando exist?
|
|
if (expandoItr != PathExpandos.end())
|
|
{
|
|
// Yes, so return it.
|
|
return expandoItr->value;
|
|
}
|
|
|
|
// Not found.
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void removePathExpando(const char* pExpandoName)
|
|
{
|
|
// Sanity!
|
|
AssertFatal(pExpandoName != NULL, "Expando name cannot be NULL.");
|
|
|
|
// Fetch expando name.
|
|
StringTableEntry expandoName = StringTable->insert(pExpandoName);
|
|
|
|
// Find any existing path expando.
|
|
typePathExpandoMap::iterator expandoItr = PathExpandos.find(expandoName);
|
|
|
|
// Does the expando exist?
|
|
if (expandoItr == PathExpandos.end())
|
|
{
|
|
// No, so warn.
|
|
#if defined(TORQUE_DEBUG)
|
|
Con::warnf("Removing path expando of '%s' but it does not exist.", expandoName);
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
// Info.
|
|
#if defined(TORQUE_DEBUG)
|
|
Con::printf("Removing path expando of '%s' as '%s'.", expandoName, expandoItr->value);
|
|
#endif
|
|
// Remove expando.
|
|
PathExpandos.erase(expandoItr);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool isPathExpando(const char* pExpandoName)
|
|
{
|
|
// Sanity!
|
|
AssertFatal(pExpandoName != NULL, "Expando name cannot be NULL.");
|
|
|
|
// Fetch expando name.
|
|
StringTableEntry expandoName = StringTable->insert(pExpandoName);
|
|
|
|
return PathExpandos.contains(expandoName);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
U32 getPathExpandoCount(void)
|
|
{
|
|
return PathExpandos.size();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
StringTableEntry getPathExpandoKey(U32 expandoIndex)
|
|
{
|
|
// Finish if index is out of range.
|
|
if (expandoIndex >= PathExpandos.size())
|
|
return NULL;
|
|
|
|
// Find indexed iterator.
|
|
typePathExpandoMap::iterator expandoItr = PathExpandos.begin();
|
|
while (expandoIndex > 0) { ++expandoItr; --expandoIndex; }
|
|
|
|
return expandoItr->key;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
StringTableEntry getPathExpandoValue(U32 expandoIndex)
|
|
{
|
|
// Finish if index is out of range.
|
|
if (expandoIndex >= PathExpandos.size())
|
|
return NULL;
|
|
|
|
// Find indexed iterator.
|
|
typePathExpandoMap::iterator expandoItr = PathExpandos.begin();
|
|
while (expandoIndex > 0) { ++expandoItr; --expandoIndex; }
|
|
|
|
return expandoItr->value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool expandPath(char* pDstPath, U32 size, const char* pSrcPath, const char* pWorkingDirectoryHint, const bool ensureTrailingSlash)
|
|
{
|
|
char pathBuffer[2048] = {};
|
|
const char* pSrc = pSrcPath;
|
|
char* pSlash;
|
|
|
|
// Fetch leading character.
|
|
const char leadingToken = *pSrc;
|
|
|
|
// Fetch following token.
|
|
const char followingToken = leadingToken != 0 ? pSrc[1] : 0;
|
|
|
|
// Expando.
|
|
if (leadingToken == '^')
|
|
{
|
|
// Initial prefix search.
|
|
const char* pPrefixSrc = pSrc + 1;
|
|
char* pPrefixDst = pathBuffer;
|
|
|
|
// Search for end of expando.
|
|
while (*pPrefixSrc != '/' && *pPrefixSrc != 0)
|
|
{
|
|
// Copy prefix character.
|
|
*pPrefixDst++ = *pPrefixSrc++;
|
|
}
|
|
|
|
// Yes, so terminate the expando string.
|
|
*pPrefixDst = 0;
|
|
|
|
// Fetch the expando path.
|
|
StringTableEntry expandoPath = getPathExpando(pathBuffer);
|
|
|
|
// Does the expando exist?
|
|
if (expandoPath == NULL)
|
|
{
|
|
// No, so error.
|
|
Con::errorf("expandPath() : Could not find path expando '%s' for path '%s'.", pathBuffer, pSrcPath);
|
|
|
|
// Are we ensuring the trailing slash?
|
|
if (ensureTrailingSlash)
|
|
{
|
|
// Yes, so ensure it.
|
|
Con::ensureTrailingSlash(pDstPath, pSrcPath, size);
|
|
}
|
|
else
|
|
{
|
|
// No, so just use the source path.
|
|
dStrcpy(pDstPath, pSrcPath, size);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Skip the expando and the following slash.
|
|
pSrc += dStrlen(pathBuffer) + 1;
|
|
|
|
// Format the output path.
|
|
dSprintf(pathBuffer, sizeof(pathBuffer), "%s/%s", expandoPath, pSrc);
|
|
|
|
// Are we ensuring the trailing slash?
|
|
if (ensureTrailingSlash)
|
|
{
|
|
// Yes, so ensure it.
|
|
Con::ensureTrailingSlash(pathBuffer, pathBuffer, size);
|
|
}
|
|
|
|
// Strip repeat slashes.
|
|
Con::stripRepeatSlashes(pDstPath, pathBuffer, size);
|
|
|
|
return true;
|
|
}
|
|
|
|
// Script-Relative.
|
|
if (leadingToken == '.')
|
|
{
|
|
// Fetch the code-block file-path.
|
|
const StringTableEntry codeblockFullPath = getCurrentScriptModulePath();
|
|
|
|
// Do we have a code block full path?
|
|
if (codeblockFullPath == NULL)
|
|
{
|
|
// No, so error.
|
|
Con::errorf("expandPath() : Could not find relative path from code-block for path '%s'.", pSrcPath);
|
|
|
|
// Are we ensuring the trailing slash?
|
|
if (ensureTrailingSlash)
|
|
{
|
|
// Yes, so ensure it.
|
|
Con::ensureTrailingSlash(pDstPath, pSrcPath, size);
|
|
}
|
|
else
|
|
{
|
|
// No, so just use the source path.
|
|
dStrcpy(pDstPath, pSrcPath, size);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Yes, so use it as the prefix.
|
|
dStrncpy(pathBuffer, codeblockFullPath, sizeof(pathBuffer) - 1);
|
|
|
|
// Find the final slash in the code-block.
|
|
pSlash = dStrrchr(pathBuffer, '/');
|
|
|
|
// Is this a parent directory token?
|
|
if (followingToken == '.')
|
|
{
|
|
// Yes, so terminate after the slash so we include it.
|
|
pSlash[1] = 0;
|
|
}
|
|
else
|
|
{
|
|
// No, it's a current directory token so terminate at the slash so we don't include it.
|
|
pSlash[0] = 0;
|
|
|
|
// Skip the current directory token.
|
|
pSrc++;
|
|
}
|
|
|
|
// Format the output path.
|
|
dStrncat(pathBuffer, "/", sizeof(pathBuffer) - 1 - strlen(pathBuffer));
|
|
dStrncat(pathBuffer, pSrc, sizeof(pathBuffer) - 1 - strlen(pathBuffer));
|
|
|
|
// Are we ensuring the trailing slash?
|
|
if (ensureTrailingSlash)
|
|
{
|
|
// Yes, so ensure it.
|
|
Con::ensureTrailingSlash(pathBuffer, pathBuffer, size);
|
|
}
|
|
|
|
// Strip repeat slashes.
|
|
Con::stripRepeatSlashes(pDstPath, pathBuffer, size);
|
|
|
|
return true;
|
|
}
|
|
|
|
// All else.
|
|
|
|
//Using a special case here because the code below barfs on trying to build a full path for apk reading
|
|
#ifdef TORQUE_OS_ANDROID
|
|
if (leadingToken == '/' || strstr(pSrcPath, "/") == NULL)
|
|
Platform::makeFullPathName(pSrcPath, pathBuffer, sizeof(pathBuffer), pWorkingDirectoryHint);
|
|
else
|
|
dSprintf(pathBuffer, sizeof(pathBuffer), "/%s", pSrcPath);
|
|
#else
|
|
Platform::makeFullPathName(pSrcPath, pathBuffer, sizeof(pathBuffer), pWorkingDirectoryHint);
|
|
#endif
|
|
|
|
// Are we ensuring the trailing slash?
|
|
if (ensureTrailingSlash)
|
|
{
|
|
// Yes, so ensure it.
|
|
Con::ensureTrailingSlash(pathBuffer, pathBuffer, size);
|
|
}
|
|
|
|
// Strip repeat slashes.
|
|
Con::stripRepeatSlashes(pDstPath, pathBuffer, size);
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool isBasePath(const char* SrcPath, const char* pBasePath)
|
|
{
|
|
char expandBuffer[1024], expandBaseBuffer[1024];
|
|
Con::expandPath(expandBuffer, sizeof(expandBuffer), SrcPath);
|
|
Con::expandPath(expandBaseBuffer, sizeof(expandBaseBuffer), pBasePath);
|
|
return dStrnicmp(expandBaseBuffer, expandBuffer, dStrlen(expandBaseBuffer)) == 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void collapsePath(char* pDstPath, U32 size, const char* pSrcPath, const char* pWorkingDirectoryHint)
|
|
{
|
|
// Check path against expandos. If there are multiple matches, choose the
|
|
// expando that produces the shortest relative path.
|
|
|
|
char pathBuffer[2048];
|
|
|
|
// Fetch expando count.
|
|
const U32 expandoCount = getPathExpandoCount();
|
|
|
|
// Iterate expandos.
|
|
U32 expandoRelativePathLength = U32_MAX;
|
|
for (U32 expandoIndex = 0; expandoIndex < expandoCount; ++expandoIndex)
|
|
{
|
|
// Fetch expando value (path).
|
|
StringTableEntry expandoValue = getPathExpandoValue(expandoIndex);
|
|
|
|
// Skip if not the base path.
|
|
if (!isBasePath(pSrcPath, expandoValue))
|
|
continue;
|
|
|
|
// Fetch path relative to expando path.
|
|
StringTableEntry relativePath = Platform::makeRelativePathName(pSrcPath, expandoValue);
|
|
|
|
// If the relative path is simply a period
|
|
if (relativePath[0] == '.')
|
|
relativePath++;
|
|
|
|
if (dStrlen(relativePath) > expandoRelativePathLength)
|
|
{
|
|
// This expando covers less of the path than any previous one found.
|
|
// We will keep the previous one.
|
|
continue;
|
|
}
|
|
|
|
// Keep track of the relative path length
|
|
expandoRelativePathLength = dStrlen(relativePath);
|
|
|
|
// Fetch expando key (name).
|
|
StringTableEntry expandoName = getPathExpandoKey(expandoIndex);
|
|
|
|
// Format against expando.
|
|
dSprintf(pathBuffer, sizeof(pathBuffer), "^%s/%s", expandoName, relativePath);
|
|
}
|
|
|
|
// Check if we've found a suitable expando
|
|
if (expandoRelativePathLength != U32_MAX)
|
|
{
|
|
// Strip repeat slashes.
|
|
Con::stripRepeatSlashes(pDstPath, pathBuffer, size);
|
|
|
|
return;
|
|
}
|
|
|
|
// Fetch the working directory.
|
|
StringTableEntry workingDirectory = pWorkingDirectoryHint != NULL ? pWorkingDirectoryHint : Platform::getCurrentDirectory();
|
|
|
|
// Fetch path relative to current directory.
|
|
StringTableEntry relativePath = Platform::makeRelativePathName(pSrcPath, workingDirectory);
|
|
|
|
// If the relative path is simply a period
|
|
if (relativePath[0] == '.' && relativePath[1] != '.')
|
|
relativePath++;
|
|
|
|
// Format against expando.
|
|
dSprintf(pathBuffer, sizeof(pathBuffer), "%s/%s", workingDirectory, relativePath);
|
|
|
|
// Strip repeat slashes.
|
|
Con::stripRepeatSlashes(pDstPath, pathBuffer, size);
|
|
}
|
|
|
|
|
|
void ensureTrailingSlash(char* pDstPath, const char* pSrcPath, S32 dstSize)
|
|
{
|
|
// Copy to target.
|
|
dStrcpy(pDstPath, pSrcPath, dstSize);
|
|
|
|
// Find trailing character index.
|
|
S32 trailIndex = dStrlen(pDstPath);
|
|
|
|
// Ignore if empty string.
|
|
if (trailIndex == 0)
|
|
return;
|
|
|
|
// Finish if the trailing slash already exists.
|
|
if (pDstPath[trailIndex - 1] == '/')
|
|
return;
|
|
|
|
// Add trailing slash.
|
|
pDstPath[trailIndex++] = '/';
|
|
pDstPath[trailIndex] = 0;
|
|
}
|
|
|
|
//--------------------------------------
|
|
|
|
void shutdown()
|
|
{
|
|
AssertFatal(active == true, "Con::shutdown should only be called once.");
|
|
active = false;
|
|
|
|
smConsoleInput.remove(postConsoleInput);
|
|
|
|
consoleLogFile.close();
|
|
Namespace::shutdown();
|
|
AbstractClassRep::shutdown();
|
|
Compiler::freeConsoleParserList();
|
|
gGlobalVars.reset();
|
|
PathExpandos.clear();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
StringTableEntry getDSOPath(const char *scriptPath)
|
|
{
|
|
#ifndef TORQUE2D_TOOLS_FIXME
|
|
|
|
// [tom, 11/17/2006] Force old behavior for the player. May not want to do this.
|
|
const char *slash = dStrrchr(scriptPath, '/');
|
|
if (slash != NULL)
|
|
return StringTable->insertn(scriptPath, slash - scriptPath, true);
|
|
|
|
slash = dStrrchr(scriptPath, ':');
|
|
if (slash != NULL)
|
|
return StringTable->insertn(scriptPath, (slash - scriptPath) + 1, true);
|
|
|
|
return "";
|
|
|
|
#else
|
|
|
|
char relPath[1024], dsoPath[1024];
|
|
bool isPrefs = false;
|
|
|
|
// [tom, 11/17/2006] Prefs are handled slightly differently to avoid dso name clashes
|
|
StringTableEntry prefsPath = Platform::getPrefsPath();
|
|
if (dStrnicmp(scriptPath, prefsPath, dStrlen(prefsPath)) == 0)
|
|
{
|
|
relPath[0] = 0;
|
|
isPrefs = true;
|
|
}
|
|
else
|
|
{
|
|
StringTableEntry strippedPath = Platform::stripBasePath(scriptPath);
|
|
dStrcpy(relPath, strippedPath, 1024);
|
|
|
|
char *slash = dStrrchr(relPath, '/');
|
|
if (slash)
|
|
*slash = 0;
|
|
}
|
|
|
|
const char *overridePath;
|
|
if (!isPrefs)
|
|
overridePath = Con::getVariable("$Scripts::OverrideDSOPath");
|
|
else
|
|
overridePath = prefsPath;
|
|
|
|
if (overridePath && *overridePath)
|
|
Platform::makeFullPathName(relPath, dsoPath, sizeof(dsoPath), overridePath);
|
|
else
|
|
{
|
|
char t[1024];
|
|
dSprintf(t, sizeof(t), "compiledScripts/%s", relPath);
|
|
Platform::makeFullPathName(t, dsoPath, sizeof(dsoPath), Platform::getPrefsPath());
|
|
}
|
|
|
|
return StringTable->insert(dsoPath);
|
|
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool stripRepeatSlashes(char* pDstPath, const char* pSrcPath, S32 dstSize)
|
|
{
|
|
// Note original destination.
|
|
char* pOriginalDst = pDstPath;
|
|
|
|
// Reset last source character.
|
|
char lastSrcChar = 0;
|
|
|
|
// Search source...
|
|
while (dstSize > 0)
|
|
{
|
|
// Fetch characters.
|
|
const char srcChar = *pSrcPath++;
|
|
|
|
// Do we have a repeat slash?
|
|
if (srcChar == '/' && lastSrcChar == '/')
|
|
{
|
|
// Yes, so skip it.
|
|
continue;
|
|
}
|
|
|
|
// No, so copy character.
|
|
*pDstPath++ = srcChar;
|
|
|
|
// Finish if end of source.
|
|
if (srcChar == 0)
|
|
return true;
|
|
|
|
// Reduce room left in destination.
|
|
dstSize--;
|
|
|
|
// Set last character.
|
|
lastSrcChar = srcChar;
|
|
}
|
|
|
|
// Terminate the destination string as we ran out of room.
|
|
*pOriginalDst = 0;
|
|
|
|
// Fail!
|
|
return false;
|
|
}
|
|
|
|
} // end of Console namespace
|
|
|
|
#endif
|
|
|
|
//=============================================================================
|
|
// API.
|
|
//=============================================================================
|
|
// MARK: ---- API ----
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DefineEngineFunction(expandPath, const char*, (const char* path),, "(string path) - Expands an expando or relative path into a full path.")
|
|
{
|
|
char* ret = Con::getReturnBuffer(1024);
|
|
Con::expandPath(ret, 1024, path);
|
|
return ret;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DefineEngineFunction(collapsePath, const char*, (const char* path), , "(string path) - Collapses a path into either an expando path or a relative path.")
|
|
{
|
|
char* ret = Con::getReturnBuffer(1024);
|
|
Con::collapsePath(ret, 1024, path);
|
|
return ret;
|
|
}
|
|
|
|
|
|
DefineEngineFunction( log, void, ( const char* message ),,
|
|
"@brief Logs a message to the console.\n\n"
|
|
"@param message The message text.\n"
|
|
"@note By default, messages will appear white in the console.\n"
|
|
"@ingroup Logging")
|
|
{
|
|
Con::printf( "%s", message );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DefineEngineFunction( logError, void, ( const char* message ),,
|
|
"@brief Logs an error message to the console.\n\n"
|
|
"@param message The message text.\n"
|
|
"@note By default, errors will appear red in the console.\n"
|
|
"@ingroup Logging")
|
|
{
|
|
Con::errorf( "%s", message );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DefineEngineFunction( logWarning, void, ( const char* message ),,
|
|
"@brief Logs a warning message to the console.\n\n"
|
|
"@param message The message text.\n\n"
|
|
"@note By default, warnings will appear turquoise in the console.\n"
|
|
"@ingroup Logging")
|
|
{
|
|
Con::warnf( "%s", message );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
ConsoleValueToStringArrayWrapper::ConsoleValueToStringArrayWrapper(int targc, ConsoleValue *targv)
|
|
{
|
|
argv = new const char*[targc];
|
|
argc = targc;
|
|
|
|
for (S32 i = 0; i < targc; i++)
|
|
{
|
|
argv[i] = dStrdup(targv[i].getString());
|
|
}
|
|
}
|
|
|
|
ConsoleValueToStringArrayWrapper::~ConsoleValueToStringArrayWrapper()
|
|
{
|
|
for (S32 i = 0; i< argc; i++)
|
|
{
|
|
dFree(argv[i]);
|
|
}
|
|
delete[] argv;
|
|
}
|
|
|
|
|
|
StringArrayToConsoleValueWrapper::StringArrayToConsoleValueWrapper(int targc, const char** targv)
|
|
{
|
|
argv = new ConsoleValue[targc]();
|
|
argc = targc;
|
|
|
|
for (int i=0; i<targc; i++)
|
|
{
|
|
argv[i].setString(targv[i]);
|
|
}
|
|
}
|
|
|
|
StringArrayToConsoleValueWrapper::~StringArrayToConsoleValueWrapper()
|
|
{
|
|
delete[] argv;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
ConsoleValue _BaseEngineConsoleCallbackHelper::_exec()
|
|
{
|
|
if( mThis )
|
|
{
|
|
// Cannot invoke callback until object has been registered
|
|
if (mThis->isProperlyAdded())
|
|
{
|
|
ConsoleValue returnValue = Con::_internalExecute( mThis, mArgc, mArgv, false );
|
|
mArgc = mInitialArgc; // reset
|
|
return returnValue;
|
|
}
|
|
|
|
STR.clearFunctionOffset();
|
|
mArgc = mInitialArgc; // reset
|
|
return (ConsoleValue());
|
|
}
|
|
|
|
ConsoleValue returnValue = (Con::_internalExecute( mArgc, mArgv ));
|
|
mArgc = mInitialArgc; // reset args
|
|
return returnValue;
|
|
}
|
|
|
|
ConsoleValue _BaseEngineConsoleCallbackHelper::_execLater(SimConsoleThreadExecEvent *evt)
|
|
{
|
|
mArgc = mInitialArgc; // reset args
|
|
Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
|
|
return (evt->getCB().waitForResult());
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void ConsoleStackFrameSaver::save()
|
|
{
|
|
gCallStack.pushFrame(0);
|
|
mSaved = true;
|
|
}
|
|
|
|
void ConsoleStackFrameSaver::restore()
|
|
{
|
|
if (mSaved)
|
|
{
|
|
gCallStack.popFrame();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|