TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-04-29 16:25:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

more console refactor.

Browse source
This commit is contained in:
Jeff Hutchinson 2021-03-31 21:09:23 -04:00
parent 5e81c021f5
commit 50df52ecfc
15 changed files with 150 additions and 158 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Engine/source/T3D/assets/assetImporter.cpp
View file

@ -2546,8 +2546,8 @@ void AssetImporter::importAssets(AssetImportObject* assetItem)
processCommand += childItem->assetType; processCommand += childItem->assetType;
if (isMethod(processCommand.c_str())) if (isMethod(processCommand.c_str()))
{ {
ConsoleValueRef importReturnVal = Con::executef(this, processCommand.c_str(), childItem); const char* importReturnVal = Con::executef(this, processCommand.c_str(), childItem).getString();
assetPath = Torque::Path(importReturnVal.getStringValue()); assetPath = Torque::Path(importReturnVal);
} }
} }

2
Engine/source/afx/afxSelectron.cpp
View file

@ -1070,7 +1070,7 @@ afxSelectron::start_selectron(SceneObject* picked, U8 subcode, SimObject* extra)
// CALL SCRIPT afxSelectronData::onPreactivate(%params, %extra) // CALL SCRIPT afxSelectronData::onPreactivate(%params, %extra)
const char* result = Con::executef(datablock, "onPreactivate", const char* result = Con::executef(datablock, "onPreactivate",
Con::getIntArg(param_holder->getId()), Con::getIntArg(param_holder->getId()),
(extra) ? Con::getIntArg(extra->getId()) : ""); (extra) ? Con::getIntArg(extra->getId()) : "").getString();
if (result && result[0] != '\0' && !dAtob(result)) if (result && result[0] != '\0' && !dAtob(result))
{ {
#if defined(TORQUE_DEBUG) #if defined(TORQUE_DEBUG)

4
Engine/source/console/ICallMethod.h
View file

@ -27,7 +27,7 @@ class ICallMethod
{ {
public: public:
virtual const char* callMethod( S32 argc, const char* methodName, ... ) = 0; virtual const char* callMethod( S32 argc, const char* methodName, ... ) = 0;
virtual const char* callMethodArgList( U32 argc, ConsoleValueRef argv[], bool callThis = true ) = 0; virtual const char* callMethodArgList( U32 argc, ConsoleValue argv[], bool callThis = true ) = 0;
}; };
#endif #endif

4
Engine/source/console/console.cpp
View file

@ -2592,7 +2592,7 @@ ConsoleValue _BaseEngineConsoleCallbackHelper::_exec()
{ {
ConsoleValue returnValue = std::move(Con::_internalExecute( mThis, mArgc, mArgv, false )); ConsoleValue returnValue = std::move(Con::_internalExecute( mThis, mArgc, mArgv, false ));
mArgc = mInitialArgc; // reset mArgc = mInitialArgc; // reset
return returnValue; return std::move(returnValue);
} }
STR.clearFunctionOffset(); STR.clearFunctionOffset();
@ -2609,7 +2609,7 @@ ConsoleValue _BaseEngineConsoleCallbackHelper::_execLater(SimConsoleThreadExecEv
{ {
mArgc = mInitialArgc; // reset args mArgc = mInitialArgc; // reset args
Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime()); Sim::postEvent((SimObject*)Sim::getRootGroup(), evt, Sim::getCurrentTime());
return evt->getCB().waitForResult(); return std::move(evt->getCB().waitForResult());
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------

18
Engine/source/console/console.h
View file

@ -1254,9 +1254,9 @@ public:
static ConsoleConstructor cfg_ConsoleFunctionGroup_##groupName##_GroupBegin(NULL,#groupName,usage) static ConsoleConstructor cfg_ConsoleFunctionGroup_##groupName##_GroupBegin(NULL,#groupName,usage)
# define ConsoleToolFunction(name,returnType,minArgs,maxArgs,usage1) \ # define ConsoleToolFunction(name,returnType,minArgs,maxArgs,usage1) \
returnType ctf_##name(SimObject *, S32, ConsoleValueRef *argv); \ returnType ctf_##name(SimObject *, S32, ConsoleValue *argv); \
ConsoleConstructor cc_##name##_obj(NULL,#name,ctf_##name,usage1,minArgs,maxArgs, true); \ ConsoleConstructor cc_##name##_obj(NULL,#name,ctf_##name,usage1,minArgs,maxArgs, true); \
returnType ctf_##name(SimObject *, S32 argc, ConsoleValueRef *argv) returnType ctf_##name(SimObject *, S32 argc, ConsoleValue *argv)
# define ConsoleFunctionGroupEnd(groupName) \ # define ConsoleFunctionGroupEnd(groupName) \
static ConsoleConstructor cfg_##groupName##_GroupEnd(NULL,#groupName,NULL) static ConsoleConstructor cfg_##groupName##_GroupEnd(NULL,#groupName,NULL)
@ -1289,23 +1289,23 @@ public:
// These are identical to what's above, we just want to null out the usage strings. // These are identical to what's above, we just want to null out the usage strings.
# define ConsoleFunction(name,returnType,minArgs,maxArgs,usage1) \ # define ConsoleFunction(name,returnType,minArgs,maxArgs,usage1) \
static returnType c##name(SimObject *, S32, ConsoleValueRef*); \ static returnType c##name(SimObject *, S32, ConsoleValue*); \
static ConsoleConstructor g##name##obj(NULL,#name,c##name,"",minArgs,maxArgs);\ static ConsoleConstructor g##name##obj(NULL,#name,c##name,"",minArgs,maxArgs);\
static returnType c##name(SimObject *, S32 argc, ConsoleValueRef *argv) static returnType c##name(SimObject *, S32 argc, ConsoleValue *argv)
# define ConsoleToolFunction(name,returnType,minArgs,maxArgs,usage1) \ # define ConsoleToolFunction(name,returnType,minArgs,maxArgs,usage1) \
static returnType c##name(SimObject *, S32, ConsoleValueRef*); \ static returnType c##name(SimObject *, S32, ConsoleValue*); \
static ConsoleConstructor g##name##obj(NULL,#name,c##name,"",minArgs,maxArgs, true);\ static ConsoleConstructor g##name##obj(NULL,#name,c##name,"",minArgs,maxArgs, true);\
static returnType c##name(SimObject *, S32 argc, ConsoleValueRef *argv) static returnType c##name(SimObject *, S32 argc, ConsoleValue *argv)
# define ConsoleMethod(className,name,returnType,minArgs,maxArgs,usage1) \ # define ConsoleMethod(className,name,returnType,minArgs,maxArgs,usage1) \
static inline returnType c##className##name(className *, S32, ConsoleValueRef *argv); \ static inline returnType c##className##name(className *, S32, ConsoleValue *argv); \
static returnType c##className##name##caster(SimObject *object, S32 argc, ConsoleValueRef *argv) { \ static returnType c##className##name##caster(SimObject *object, S32 argc, ConsoleValue *argv) { \
conmethod_return_##returnType ) c##className##name(static_cast<className*>(object),argc,argv); \ conmethod_return_##returnType ) c##className##name(static_cast<className*>(object),argc,argv); \
}; \ }; \
static ConsoleConstructor \ static ConsoleConstructor \
className##name##obj(#className,#name,c##className##name##caster,"",minArgs,maxArgs); \ className##name##obj(#className,#name,c##className##name##caster,"",minArgs,maxArgs); \
static inline returnType c##className##name(className *object, S32 argc, ConsoleValueRef *argv) static inline returnType c##className##name(className *object, S32 argc, ConsoleValue *argv)
#define ConsoleDoc( text ) #define ConsoleDoc( text )

30
Engine/source/console/consoleInternal.cpp
View file

@ -613,7 +613,7 @@ void Dictionary::validate()
"Dictionary::validate() - Dictionary not owner of own hashtable!"); "Dictionary::validate() - Dictionary not owner of own hashtable!");
} }
void ExprEvalState::pushFrame(StringTableEntry frameName, Namespace *ns) void ExprEvalState::pushFrame(StringTableEntry frameName, Namespace *ns, S32 registerCount)
{ {
#ifdef DEBUG_SPEW #ifdef DEBUG_SPEW
validate(); validate();
@ -1266,7 +1266,7 @@ void Namespace::markGroup(const char* name, const char* usage)
extern S32 executeBlock(StmtNode *block, ExprEvalState *state); extern S32 executeBlock(StmtNode *block, ExprEvalState *state);
ConsoleValueRef Namespace::Entry::execute(S32 argc, ConsoleValueRef *argv, ExprEvalState *state) ConsoleValue Namespace::Entry::execute(S32 argc, ConsoleValue *argv, ExprEvalState *state)
{ {
STR.clearFunctionOffset(); STR.clearFunctionOffset();
@ -1274,11 +1274,11 @@ ConsoleValueRef Namespace::Entry::execute(S32 argc, ConsoleValueRef *argv, ExprE
{ {
if (mFunctionOffset) if (mFunctionOffset)
{ {
return mCode->exec(mFunctionOffset, argv[0], mNamespace, argc, argv, false, mPackage); return std::move(mCode->exec(mFunctionOffset, argv[0].getString(), mNamespace, argc, argv, false, mPackage));
} }
else else
{ {
return ConsoleValueRef(); return std::move(ConsoleValue());
} }
} }
@ -1288,7 +1288,7 @@ ConsoleValueRef Namespace::Entry::execute(S32 argc, ConsoleValueRef *argv, ExprE
if (mToolOnly && !Con::isCurrentScriptToolScript()) if (mToolOnly && !Con::isCurrentScriptToolScript())
{ {
Con::errorf(ConsoleLogEntry::Script, "%s::%s - attempting to call tools only function from outside of tools", mNamespace->mName, mFunctionName); Con::errorf(ConsoleLogEntry::Script, "%s::%s - attempting to call tools only function from outside of tools", mNamespace->mName, mFunctionName);
return ConsoleValueRef(); return std::move(ConsoleValue());
} }
#endif #endif
@ -1296,25 +1296,31 @@ ConsoleValueRef Namespace::Entry::execute(S32 argc, ConsoleValueRef *argv, ExprE
{ {
Con::warnf(ConsoleLogEntry::Script, "%s::%s - wrong number of arguments.", mNamespace->mName, mFunctionName); Con::warnf(ConsoleLogEntry::Script, "%s::%s - wrong number of arguments.", mNamespace->mName, mFunctionName);
Con::warnf(ConsoleLogEntry::Script, "usage: %s", mUsage); Con::warnf(ConsoleLogEntry::Script, "usage: %s", mUsage);
return ConsoleValueRef(); return std::move(ConsoleValue());
} }
ConsoleValue result;
switch (mType) switch (mType)
{ {
case StringCallbackType: case StringCallbackType:
return ConsoleValueRef::fromValue(CSTK.pushStackString(cb.mStringCallbackFunc(state->thisObject, argc, argv))); const char* str = cb.mStringCallbackFunc(state->thisObject, argc, argv);
result.setString(str, dStrlen(str));
break;
case IntCallbackType: case IntCallbackType:
return ConsoleValueRef::fromValue(CSTK.pushUINT((U32)cb.mBoolCallbackFunc(state->thisObject, argc, argv))); result.setInt(cb.mIntCallbackFunc(state->thisObject, argc, argv));
break;
case FloatCallbackType: case FloatCallbackType:
return ConsoleValueRef::fromValue(CSTK.pushFLT((U32)cb.mBoolCallbackFunc(state->thisObject, argc, argv))); result.setFloat(cb.mBoolCallbackFunc(state->thisObject, argc, argv));
break;
case VoidCallbackType: case VoidCallbackType:
cb.mVoidCallbackFunc(state->thisObject, argc, argv); cb.mVoidCallbackFunc(state->thisObject, argc, argv);
return ConsoleValueRef(); break;
case BoolCallbackType: case BoolCallbackType:
return ConsoleValueRef::fromValue(CSTK.pushUINT((U32)cb.mBoolCallbackFunc(state->thisObject, argc, argv))); result.setBool(cb.mBoolCallbackFunc(state->thisObject, argc, argv));
break;
} }
return ConsoleValueRef(); return std::move(result);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------

2
Engine/source/console/consoleInternal.h
View file

@ -150,7 +150,7 @@ public:
void clear(); void clear();
/// ///
ConsoleValueRef execute(S32 argc, ConsoleValueRef* argv, ExprEvalState* state); ConsoleValue execute(S32 argc, ConsoleValue* argv, ExprEvalState* state);
/// Return a one-line documentation text string for the function. /// Return a one-line documentation text string for the function.
String getBriefDescription(String* outRemainingDocText = NULL) const; String getBriefDescription(String* outRemainingDocText = NULL) const;

135
Engine/source/console/engineAPI.h
View file

@ -148,55 +148,45 @@ inline const char* EngineMarshallData( U32 value )
/// Marshal data from native into client form stored directly in /// Marshal data from native into client form stored directly in
/// client function invocation vector. /// client function invocation vector.
template< typename T > template< typename T >
inline void EngineMarshallData( const T& arg, S32& argc, ConsoleValueRef *argv ) inline void EngineMarshallData( const T& arg, S32& argc, ConsoleValue *argv )
{ {
argv[ argc ] = castConsoleTypeToString( arg ); const char* str = castConsoleTypeToString(arg);;
argc ++; argv[ argc++ ].setString(str, dStrlen(str));
} }
inline void EngineMarshallData( bool arg, S32& argc, ConsoleValueRef *argv ) inline void EngineMarshallData( bool arg, S32& argc, ConsoleValue *argv )
{ {
if( arg ) argv[ argc++ ].setBool(arg);
argv[ argc ] = 1;
else
argv[ argc ] = 0;
argc ++;
} }
inline void EngineMarshallData( S32 arg, S32& argc, ConsoleValueRef *argv ) inline void EngineMarshallData( S32 arg, S32& argc, ConsoleValue *argv )
{ {
argv[ argc ] = arg; argv[ argc++ ].setInt(arg);
argc ++;
} }
inline void EngineMarshallData( U32 arg, S32& argc, ConsoleValueRef *argv ) inline void EngineMarshallData( U32 arg, S32& argc, ConsoleValue *argv )
{ {
EngineMarshallData( S32( arg ), argc, argv ); EngineMarshallData( S32( arg ), argc, argv );
} }
inline void EngineMarshallData( F32 arg, S32& argc, ConsoleValueRef *argv ) inline void EngineMarshallData( F32 arg, S32& argc, ConsoleValue *argv )
{ {
argv[ argc ] = arg; argv[ argc++ ].setFloat(arg);
argc ++;
} }
inline void EngineMarshallData( const char* arg, S32& argc, ConsoleValueRef *argv ) inline void EngineMarshallData( const char* arg, S32& argc, ConsoleValue *argv )
{ {
argv[ argc ] = arg; argv[ argc++ ].setString(arg, dStrlen(arg));
argc ++;
} }
inline void EngineMarshallData( char* arg, S32& argc, ConsoleValueRef *argv ) inline void EngineMarshallData( char* arg, S32& argc, ConsoleValue *argv )
{ {
argv[ argc ] = arg; argv[ argc++ ].setString(arg, dStrlen(arg));
argc ++;
} }
template< typename T > template< typename T >
inline void EngineMarshallData( T* object, S32& argc, ConsoleValueRef *argv ) inline void EngineMarshallData( T* object, S32& argc, ConsoleValue *argv )
{ {
argv[ argc ] = object ? object->getId() : 0; argv[ argc++ ].setInt(object ? object->getId() : 0);
argc ++;
} }
template< typename T > template< typename T >
inline void EngineMarshallData( const T* object, S32& argc, ConsoleValueRef *argv ) inline void EngineMarshallData( const T* object, S32& argc, ConsoleValue *argv )
{ {
argv[ argc ] = object ? object->getId() : 0; argv[ argc++ ].setInt(object ? object->getId() : 0);
argc ++;
} }
/// Unmarshal data from client form to engine form. /// Unmarshal data from client form to engine form.
@ -216,9 +206,9 @@ struct EngineUnmarshallData
template<> template<>
struct EngineUnmarshallData< S32 > struct EngineUnmarshallData< S32 >
{ {
S32 operator()( ConsoleValueRef &ref ) const S32 operator()( ConsoleValue &ref ) const
{ {
return (S32)ref; return (S32)ref.getInt();
} }
S32 operator()( const char* str ) const S32 operator()( const char* str ) const
@ -229,9 +219,9 @@ struct EngineUnmarshallData< S32 >
template<> template<>
struct EngineUnmarshallData< U32 > struct EngineUnmarshallData< U32 >
{ {
U32 operator()( ConsoleValueRef &ref ) const U32 operator()( ConsoleValue &ref ) const
{ {
return (U32)((S32)ref); return (U32)ref.getInt();
} }
U32 operator()( const char* str ) const U32 operator()( const char* str ) const
@ -242,9 +232,9 @@ struct EngineUnmarshallData< U32 >
template<> template<>
struct EngineUnmarshallData< F32 > struct EngineUnmarshallData< F32 >
{ {
F32 operator()( ConsoleValueRef &ref ) const F32 operator()( ConsoleValue &ref ) const
{ {
return (F32)ref; return (F32)ref.getFloat();
} }
F32 operator()( const char* str ) const F32 operator()( const char* str ) const
@ -255,9 +245,9 @@ struct EngineUnmarshallData< F32 >
template<> template<>
struct EngineUnmarshallData< U8 > struct EngineUnmarshallData< U8 >
{ {
U8 operator()( ConsoleValueRef &ref ) const U8 operator()( ConsoleValue &ref ) const
{ {
return (U8)((S32)ref); return (U8)((S32)ref.getInt());
} }
U8 operator()( const char* str ) const U8 operator()( const char* str ) const
@ -268,9 +258,9 @@ struct EngineUnmarshallData< U8 >
template<> template<>
struct EngineUnmarshallData< const char* > struct EngineUnmarshallData< const char* >
{ {
const char* operator()( ConsoleValueRef &ref ) const const char* operator()( ConsoleValue &ref ) const
{ {
return ref.getStringValue(); return ref.getString();
} }
const char* operator()( const char* str ) const const char* operator()( const char* str ) const
@ -281,9 +271,9 @@ struct EngineUnmarshallData< const char* >
template< typename T > template< typename T >
struct EngineUnmarshallData< T* > struct EngineUnmarshallData< T* >
{ {
T* operator()( ConsoleValueRef &ref ) const T* operator()( ConsoleValue &ref ) const
{ {
return dynamic_cast< T* >( Sim::findObject( ref.getStringValue() ) ); return dynamic_cast< T* >( Sim::findObject( ref ) );
} }
T* operator()( const char* str ) const T* operator()( const char* str ) const
@ -294,17 +284,17 @@ struct EngineUnmarshallData< T* >
template<> template<>
struct EngineUnmarshallData< void > struct EngineUnmarshallData< void >
{ {
void operator()( ConsoleValueRef& ) const {} void operator()( ConsoleValue& ) const {}
void operator()( const char* ) const {} void operator()( const char* ) const {}
}; };
template<> template<>
struct EngineUnmarshallData< ConsoleValueRef > struct EngineUnmarshallData< ConsoleValue >
{ {
ConsoleValueRef operator()( ConsoleValueRef ref ) const ConsoleValue operator()( ConsoleValue &ref ) const
{ {
return ref; return std::move(ref);
} }
}; };
@ -548,7 +538,7 @@ namespace engineAPI{
static const S32 NUM_ARGS = sizeof...(ArgTs) + startArgc; static const S32 NUM_ARGS = sizeof...(ArgTs) + startArgc;
template<size_t index, size_t method_offset = 0, typename ...RealArgTs> template<size_t index, size_t method_offset = 0, typename ...RealArgTs>
static IthArgType<index> getRealArgValue(S32 argc, ConsoleValueRef *argv, const _EngineFunctionDefaultArguments< void(RealArgTs...) >& defaultArgs) static IthArgType<index> getRealArgValue(S32 argc, ConsoleValue *argv, const _EngineFunctionDefaultArguments< void(RealArgTs...) >& defaultArgs)
{ {
if((startArgc + index) < argc) if((startArgc + index) < argc)
{ {
@ -559,12 +549,12 @@ namespace engineAPI{
} }
template<size_t ...I> template<size_t ...I>
static R dispatchHelper(S32 argc, ConsoleValueRef *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs, Seq<I...>){ static R dispatchHelper(S32 argc, ConsoleValue *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs, Seq<I...>){
return fn(SelfType::getRealArgValue<I>(argc, argv, defaultArgs) ...); return fn(SelfType::getRealArgValue<I>(argc, argv, defaultArgs) ...);
} }
template<typename Frame, size_t ...I> template<typename Frame, size_t ...I>
static R dispatchHelper(S32 argc, ConsoleValueRef *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs, Seq<I...>){ static R dispatchHelper(S32 argc, ConsoleValue *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs, Seq<I...>){
return (frame->*fn)(SelfType::getRealArgValue<I,1>(argc, argv, defaultArgs) ...); return (frame->*fn)(SelfType::getRealArgValue<I,1>(argc, argv, defaultArgs) ...);
} }
@ -579,9 +569,9 @@ namespace engineAPI{
} }
}; };
template<> struct MarshallHelpers<ConsoleValueRef> { template<> struct MarshallHelpers<ConsoleValue> {
template<typename ...ArgTs> static void marshallEach(S32 &argc, ConsoleValueRef *argv, const ArgTs& ...args){} template<typename ...ArgTs> static void marshallEach(S32 &argc, ConsoleValue *argv, const ArgTs& ...args){}
template<typename H, typename ...Tail> static void marshallEach(S32 &argc, ConsoleValueRef *argv, const H& head, const Tail& ...tail){ template<typename H, typename ...Tail> static void marshallEach(S32 &argc, ConsoleValue *argv, const H& head, const Tail& ...tail){
EngineMarshallData(head, argc, argv); EngineMarshallData(head, argc, argv);
marshallEach(argc, argv, tail...); marshallEach(argc, argv, tail...);
} }
@ -604,12 +594,12 @@ public:
template<typename Frame> using MethodType = typename Helper::template MethodType<Frame>; template<typename Frame> using MethodType = typename Helper::template MethodType<Frame>;
static const S32 NUM_ARGS = Helper::NUM_ARGS; static const S32 NUM_ARGS = Helper::NUM_ARGS;
static ReturnType thunk( S32 argc, ConsoleValueRef *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs) static ReturnType thunk( S32 argc, ConsoleValue *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs)
{ {
return _EngineConsoleThunkReturnValue( Helper::dispatchHelper(argc, argv, fn, defaultArgs, SeqType())); return _EngineConsoleThunkReturnValue( Helper::dispatchHelper(argc, argv, fn, defaultArgs, SeqType()));
} }
template< typename Frame > template< typename Frame >
static ReturnType thunk( S32 argc, ConsoleValueRef *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs) static ReturnType thunk( S32 argc, ConsoleValue *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs)
{ {
return _EngineConsoleThunkReturnValue( Helper::dispatchHelper(argc, argv, fn, frame, defaultArgs, SeqType())); return _EngineConsoleThunkReturnValue( Helper::dispatchHelper(argc, argv, fn, frame, defaultArgs, SeqType()));
} }
@ -627,12 +617,12 @@ public:
template<typename Frame> using MethodType = typename Helper::template MethodType<Frame>; template<typename Frame> using MethodType = typename Helper::template MethodType<Frame>;
static const S32 NUM_ARGS = Helper::NUM_ARGS; static const S32 NUM_ARGS = Helper::NUM_ARGS;
static void thunk( S32 argc, ConsoleValueRef *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs) static void thunk( S32 argc, ConsoleValue *argv, FunctionType fn, const _EngineFunctionDefaultArguments< void(ArgTs...) >& defaultArgs)
{ {
Helper::dispatchHelper(argc, argv, fn, defaultArgs, SeqType()); Helper::dispatchHelper(argc, argv, fn, defaultArgs, SeqType());
} }
template< typename Frame > template< typename Frame >
static void thunk( S32 argc, ConsoleValueRef *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs) static void thunk( S32 argc, ConsoleValue *argv, MethodType<Frame> fn, Frame* frame, const _EngineFunctionDefaultArguments< void( typename Frame::ObjectType*, ArgTs...) >& defaultArgs)
{ {
Helper::dispatchHelper(argc, argv, fn, frame, defaultArgs, SeqType()); Helper::dispatchHelper(argc, argv, fn, frame, defaultArgs, SeqType());
} }
@ -705,7 +695,7 @@ public:
( void* ) &fn ## name, \ ( void* ) &fn ## name, \
0 \ 0 \
); \ ); \
static _EngineConsoleThunkType< returnType >::ReturnType _ ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv ) \ static _EngineConsoleThunkType< returnType >::ReturnType _ ## name ## caster( SimObject*, S32 argc, ConsoleValue *argv ) \
{ \ { \
return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk( \ return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk( \
argc, argv, &_fn ## name ## impl, _fn ## name ## DefaultArgs \ argc, argv, &_fn ## name ## impl, _fn ## name ## DefaultArgs \
@ -785,7 +775,7 @@ public:
( void* ) &fn ## className ## _ ## name, \ ( void* ) &fn ## className ## _ ## name, \
0 \ 0 \
); \ ); \
static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject* object, S32 argc, ConsoleValueRef *argv ) \ static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject* object, S32 argc, ConsoleValue *argv ) \
{ \ { \
_ ## className ## name ## frame frame; \ _ ## className ## name ## frame frame; \
frame.object = static_cast< className* >( object ); \ frame.object = static_cast< className* >( object ); \
@ -842,7 +832,7 @@ public:
( void* ) &fn ## className ## _ ## name, \ ( void* ) &fn ## className ## _ ## name, \
0 \ 0 \
); \ ); \
static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject*, S32 argc, ConsoleValueRef *argv )\ static _EngineConsoleThunkType< returnType >::ReturnType _ ## className ## name ## caster( SimObject*, S32 argc, ConsoleValue *argv )\
{ \ { \
return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk( \ return _EngineConsoleThunkType< returnType >::ReturnType( _EngineConsoleThunk< 1, returnType args >::thunk( \
argc, argv, &_fn ## className ## name ## impl, _fn ## className ## name ## DefaultArgs \ argc, argv, &_fn ## className ## name ## impl, _fn ## className ## name ## DefaultArgs \
@ -859,7 +849,7 @@ public:
static inline returnType _fn ## className ## name ## impl args static inline returnType _fn ## className ## name ## impl args
# define DefineEngineStringlyVariadicFunction(name,returnType,minArgs,maxArgs,usage) \ # define DefineEngineStringlyVariadicFunction(name,returnType,minArgs,maxArgs,usage) \
static inline returnType _fn ## name ## impl (SimObject *, S32 argc, ConsoleValueRef *argv); \ static inline returnType _fn ## name ## impl (SimObject *, S32 argc, ConsoleValue *argv); \
TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## name \ TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## name \
(Vector<const char*>* vec) \ (Vector<const char*>* vec) \
{ \ { \
@ -882,14 +872,14 @@ public:
0 \ 0 \
); \ ); \
ConsoleConstructor cc_##name##_obj(NULL,#name,_fn ## name ## impl,usage,minArgs,maxArgs); \ ConsoleConstructor cc_##name##_obj(NULL,#name,_fn ## name ## impl,usage,minArgs,maxArgs); \
returnType _fn ## name ## impl(SimObject *, S32 argc, ConsoleValueRef *argv) returnType _fn ## name ## impl(SimObject *, S32 argc, ConsoleValue *argv)
# define DefineEngineStringlyVariadicMethod(className, name,returnType,minArgs,maxArgs,usage) \ # define DefineEngineStringlyVariadicMethod(className, name,returnType,minArgs,maxArgs,usage) \
struct _ ## className ## name ## frame \ struct _ ## className ## name ## frame \
{ \ { \
typedef className ObjectType; \ typedef className ObjectType; \
className* object; \ className* object; \
inline returnType _exec (S32 argc, ConsoleValueRef* argv) const; \ inline returnType _exec (S32 argc, ConsoleValue* argv) const; \
}; \ }; \
TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## className ## _ ## name \ TORQUE_API EngineTypeTraits< returnType >::ReturnValueType fn ## className ## _ ## name \
(className* object, Vector<const char*>* vec) \ (className* object, Vector<const char*>* vec) \
@ -915,14 +905,14 @@ public:
( void* ) &fn ## className ## _ ## name, \ ( void* ) &fn ## className ## _ ## name, \
0 \ 0 \
); \ ); \
returnType cm_##className##_##name##_caster(SimObject* object, S32 argc, ConsoleValueRef* argv) { \ returnType cm_##className##_##name##_caster(SimObject* object, S32 argc, ConsoleValue* argv) { \
AssertFatal( dynamic_cast<className*>( object ), "Object passed to " #name " is not a " #className "!" ); \ AssertFatal( dynamic_cast<className*>( object ), "Object passed to " #name " is not a " #className "!" ); \
_ ## className ## name ## frame frame {}; \ _ ## className ## name ## frame frame {}; \
frame.object = static_cast< className* >( object ); \ frame.object = static_cast< className* >( object ); \
conmethod_return_##returnType ) frame._exec(argc,argv); \ conmethod_return_##returnType ) frame._exec(argc,argv); \
}; \ }; \
ConsoleConstructor cc_##className##_##name##_obj(#className,#name,cm_##className##_##name##_caster,usage,minArgs,maxArgs); \ ConsoleConstructor cc_##className##_##name##_obj(#className,#name,cm_##className##_##name##_caster,usage,minArgs,maxArgs); \
inline returnType _ ## className ## name ## frame::_exec(S32 argc, ConsoleValueRef *argv) const inline returnType _ ## className ## name ## frame::_exec(S32 argc, ConsoleValue *argv) const
@ -1167,10 +1157,10 @@ public:
S32 mInitialArgc; S32 mInitialArgc;
S32 mArgc; S32 mArgc;
StringTableEntry mCallbackName; StringTableEntry mCallbackName;
ConsoleValueRef mArgv[ MAX_ARGUMENTS + 2 ]; ConsoleValue mArgv[ MAX_ARGUMENTS + 2 ];
ConsoleValueRef _exec(); ConsoleValue _exec();
ConsoleValueRef _execLater(SimConsoleThreadExecEvent *evt); ConsoleValue _execLater(SimConsoleThreadExecEvent *evt);
_BaseEngineConsoleCallbackHelper(): mThis(NULL), mInitialArgc(0), mArgc(0), mCallbackName(StringTable->EmptyString()){;} _BaseEngineConsoleCallbackHelper(): mThis(NULL), mInitialArgc(0), mArgc(0), mCallbackName(StringTable->EmptyString()){;}
}; };
@ -1181,7 +1171,7 @@ public:
struct _EngineConsoleCallbackHelper : public _BaseEngineConsoleCallbackHelper struct _EngineConsoleCallbackHelper : public _BaseEngineConsoleCallbackHelper
{ {
private: private:
using Helper = engineAPI::detail::MarshallHelpers<ConsoleValueRef>; using Helper = engineAPI::detail::MarshallHelpers<ConsoleValue>;
public: public:
_EngineConsoleCallbackHelper( StringTableEntry callbackName, SimObject* pThis ) _EngineConsoleCallbackHelper( StringTableEntry callbackName, SimObject* pThis )
@ -1244,7 +1234,7 @@ public:
{ {
ConsoleStackFrameSaver sav; sav.save(); ConsoleStackFrameSaver sav; sav.save();
CSTK.reserveValues(mArgc+sizeof...(ArgTs), mArgv); CSTK.reserveValues(mArgc+sizeof...(ArgTs), mArgv);
mArgv[ 0 ].value->setStackStringValue(simCB); mArgv[ 0 ].setString(simCB, dStrlen(simCB));
Helper::marshallEach(mArgc, mArgv, args...); Helper::marshallEach(mArgc, mArgv, args...);
@ -1255,7 +1245,7 @@ public:
SimConsoleThreadExecCallback cb; SimConsoleThreadExecCallback cb;
SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+sizeof...(ArgTs), NULL, true, &cb); SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+sizeof...(ArgTs), NULL, true, &cb);
evt->populateArgs(mArgv); evt->populateArgs(mArgv);
mArgv[ 0 ].value->setStackStringValue(simCB); mArgv[ 0 ].setString(simCB, dStrlen(simCB));
Helper::marshallEach(mArgc, mArgv, args...); Helper::marshallEach(mArgc, mArgv, args...);
@ -1270,7 +1260,7 @@ public:
template<> struct _EngineConsoleExecCallbackHelper<const char*> : public _BaseEngineConsoleCallbackHelper template<> struct _EngineConsoleExecCallbackHelper<const char*> : public _BaseEngineConsoleCallbackHelper
{ {
private: private:
using Helper = engineAPI::detail::MarshallHelpers<ConsoleValueRef>; using Helper = engineAPI::detail::MarshallHelpers<ConsoleValue>;
public: public:
_EngineConsoleExecCallbackHelper( const char *callbackName ) _EngineConsoleExecCallbackHelper( const char *callbackName )
{ {
@ -1285,10 +1275,9 @@ public:
if (Con::isMainThread()) if (Con::isMainThread())
{ {
ConsoleStackFrameSaver sav; sav.save(); ConsoleStackFrameSaver sav; sav.save();
CSTK.reserveValues(mArgc+sizeof...(ArgTs), mArgv); mArgv[ 0 ].setStringTableEntry(mCallbackName);
mArgv[ 0 ].value->setStackStringValue(mCallbackName);
Helper::marshallEach(mArgc, mArgv, args...); Helper::marshallEach(mArgc, mArgv, args...);
return R( EngineUnmarshallData< R >()( _exec() ) ); return R( EngineUnmarshallData< R >()( _exec() ) );
} }
@ -1297,7 +1286,7 @@ public:
SimConsoleThreadExecCallback cb; SimConsoleThreadExecCallback cb;
SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+sizeof...(ArgTs), NULL, false, &cb); SimConsoleThreadExecEvent *evt = new SimConsoleThreadExecEvent(mArgc+sizeof...(ArgTs), NULL, false, &cb);
evt->populateArgs(mArgv); evt->populateArgs(mArgv);
mArgv[ 0 ].value->setStackStringValue(mCallbackName); mArgv[ 0 ].setStringTableEntry(mCallbackName);
Helper::marshallEach(mArgc, mArgv, args...); Helper::marshallEach(mArgc, mArgv, args...);

59
Engine/source/console/simEvents.cpp
View file

@ -28,30 +28,23 @@
// Stupid globals not declared in a header // Stupid globals not declared in a header
extern ExprEvalState gEvalState; extern ExprEvalState gEvalState;
SimConsoleEvent::SimConsoleEvent(S32 argc, ConsoleValueRef *argv, bool onObject) SimConsoleEvent::SimConsoleEvent(S32 argc, ConsoleValue *argv, bool onObject)
{ {
mOnObject = onObject; mOnObject = onObject;
mArgc = argc; mArgc = argc;
mArgv = new ConsoleValueRef[argc]; mArgv = new ConsoleValue[argc];
for (int i=0; i<argc; i++) for (int i=0; i<argc; i++)
{ {
mArgv[i].value = new ConsoleValue(); if (argv)
mArgv[i].value->type = ConsoleValue::TypeInternalString; {
mArgv[i].value->init(); mArgv->setString(argv[i].getString(), dStrlen(argv[i].getString()));
if (argv) }
{
mArgv[i].value->setStringValue((const char*)argv[i]);
}
} }
} }
SimConsoleEvent::~SimConsoleEvent() SimConsoleEvent::~SimConsoleEvent()
{ {
for (int i=0; i<mArgc; i++)
{
delete mArgv[i].value;
}
delete[] mArgv; delete[] mArgv;
} }
@ -67,7 +60,7 @@ void SimConsoleEvent::process(SimObject* object)
// Grab the function name. If '::' doesn't exist, then the schedule is // Grab the function name. If '::' doesn't exist, then the schedule is
// on a global function. // on a global function.
char funcName[256]; char funcName[256];
dStrncpy(funcName, (const char*)mArgv[0], 256); dStrncpy(funcName, mArgv[0].getString(), 256);
char* func = dStrstr( funcName, (char*)"::" ); char* func = dStrstr( funcName, (char*)"::" );
if( func ) if( func )
{ {
@ -95,11 +88,11 @@ void SimConsoleEvent::process(SimObject* object)
} }
} }
void SimConsoleEvent::populateArgs(ConsoleValueRef *argv) void SimConsoleEvent::populateArgs(ConsoleValue *argv)
{ {
for (U32 i=0; i<mArgc; i++) for (U32 i=0; i<mArgc; i++)
{ {
argv[i].value = mArgv[i].value; argv[i].setString(mArgv[i].getString(), dStrlen(mArgv[i].getString()));
} }
} }
@ -107,7 +100,6 @@ void SimConsoleEvent::populateArgs(ConsoleValueRef *argv)
SimConsoleThreadExecCallback::SimConsoleThreadExecCallback() SimConsoleThreadExecCallback::SimConsoleThreadExecCallback()
{ {
retVal.value = NULL;
sem = new Semaphore(0); sem = new Semaphore(0);
} }
@ -116,37 +108,44 @@ SimConsoleThreadExecCallback::~SimConsoleThreadExecCallback()
delete sem; delete sem;
} }
void SimConsoleThreadExecCallback::handleCallback(ConsoleValueRef ret) void SimConsoleThreadExecCallback::handleCallback(ConsoleValue ret)
{ {
retVal = ret; // can we move this pls?
retVal.setString(ret.getString(), dStrlen(ret.getString()));
sem->release(); sem->release();
} }
ConsoleValueRef SimConsoleThreadExecCallback::waitForResult() ConsoleValue SimConsoleThreadExecCallback::waitForResult()
{ {
if(sem->acquire(true)) if(sem->acquire(true))
{ {
return retVal; return std::move(retVal);
} }
return ConsoleValueRef(); return ConsoleValue();
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
SimConsoleThreadExecEvent::SimConsoleThreadExecEvent(S32 argc, ConsoleValueRef *argv, bool onObject, SimConsoleThreadExecCallback *callback) : SimConsoleThreadExecEvent::SimConsoleThreadExecEvent(S32 argc, ConsoleValue *argv, bool onObject, SimConsoleThreadExecCallback *callback) :
SimConsoleEvent(argc, argv, onObject), cb(callback) SimConsoleEvent(argc, argv, onObject), cb(callback)
{ {
} }
void SimConsoleThreadExecEvent::process(SimObject* object) void SimConsoleThreadExecEvent::process(SimObject* object)
{ {
ConsoleValueRef retVal; if (cb)
if(mOnObject) {
retVal = Con::execute(object, mArgc, mArgv); if (mOnObject)
cb->handleCallback(std::move(Con::execute(object, mArgc, mArgv)));
else
cb->handleCallback(std::move(Con::execute(mArgc, mArgv)));
}
else else
retVal = Con::execute(mArgc, mArgv); {
if (mOnObject)
if(cb) Con::execute(object, mArgc, mArgv);
cb->handleCallback(retVal); else
Con::execute(mArgc, mArgv);
}
} }

14
Engine/source/console/simEvents.h
View file

@ -91,7 +91,7 @@ class SimConsoleEvent : public SimEvent
{ {
protected: protected:
S32 mArgc; S32 mArgc;
ConsoleValueRef *mArgv; ConsoleValue *mArgv;
bool mOnObject; bool mOnObject;
public: public:
@ -108,13 +108,13 @@ public:
/// ///
/// @see Con::execute(S32 argc, const char *argv[]) /// @see Con::execute(S32 argc, const char *argv[])
/// @see Con::execute(SimObject *object, S32 argc, const char *argv[]) /// @see Con::execute(SimObject *object, S32 argc, const char *argv[])
SimConsoleEvent(S32 argc, ConsoleValueRef *argv, bool onObject); SimConsoleEvent(S32 argc, ConsoleValue *argv, bool onObject);
~SimConsoleEvent(); ~SimConsoleEvent();
virtual void process(SimObject *object); virtual void process(SimObject *object);
/// Creates a reference to our internal args list in argv /// Creates a reference to our internal args list in argv
void populateArgs(ConsoleValueRef *argv); void populateArgs(ConsoleValue *argv);
}; };
@ -123,13 +123,13 @@ public:
struct SimConsoleThreadExecCallback struct SimConsoleThreadExecCallback
{ {
Semaphore *sem; Semaphore *sem;
ConsoleValueRef retVal; ConsoleValue retVal;
SimConsoleThreadExecCallback(); SimConsoleThreadExecCallback();
~SimConsoleThreadExecCallback(); ~SimConsoleThreadExecCallback();
void handleCallback(ConsoleValueRef ret); void handleCallback(ConsoleValue ret);
ConsoleValueRef waitForResult(); ConsoleValue waitForResult();
}; };
class SimConsoleThreadExecEvent : public SimConsoleEvent class SimConsoleThreadExecEvent : public SimConsoleEvent
@ -137,7 +137,7 @@ class SimConsoleThreadExecEvent : public SimConsoleEvent
SimConsoleThreadExecCallback *cb; SimConsoleThreadExecCallback *cb;
public: public:
SimConsoleThreadExecEvent(S32 argc, ConsoleValueRef *argv, bool onObject, SimConsoleThreadExecCallback *callback); SimConsoleThreadExecEvent(S32 argc, ConsoleValue *argv, bool onObject, SimConsoleThreadExecCallback *callback);
SimConsoleThreadExecCallback& getCB() { return *cb; } SimConsoleThreadExecCallback& getCB() { return *cb; }
virtual void process(SimObject *object); virtual void process(SimObject *object);

2
Engine/source/console/simObject.cpp
View file

@ -141,7 +141,7 @@ SimObject::~SimObject()
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
bool SimObject::processArguments(S32 argc, ConsoleValueRef *argv) bool SimObject::processArguments(S32 argc, ConsoleValue *argv)
{ {
return argc == 0; return argc == 0;
} }

2
Engine/source/console/simObject.h
View file

@ -587,7 +587,7 @@ class SimObject: public ConsoleObject, public TamlCallbacks
virtual ~SimObject(); virtual ~SimObject();
virtual bool processArguments(S32 argc, ConsoleValueRef *argv); ///< Process constructor options. (ie, new SimObject(1,2,3)) virtual bool processArguments(S32 argc, ConsoleValue *argv); ///< Process constructor options. (ie, new SimObject(1,2,3))
/// @} /// @}

2
Engine/source/console/simPersistSet.cpp
View file

@ -47,7 +47,7 @@ SimPersistSet::SimPersistSet()
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
bool SimPersistSet::processArguments( S32 argc, ConsoleValueRef *argv ) bool SimPersistSet::processArguments( S32 argc, ConsoleValue *argv )
{ {
for( U32 i = 0; i < argc; ++ i ) for( U32 i = 0; i < argc; ++ i )
{ {

2
Engine/source/console/simPersistSet.h
View file

@ -58,7 +58,7 @@ class SimPersistSet : public SimSet
// SimSet. // SimSet.
virtual void addObject( SimObject* ); virtual void addObject( SimObject* );
virtual void write( Stream &stream, U32 tabStop, U32 flags = 0 ); virtual void write( Stream &stream, U32 tabStop, U32 flags = 0 );
virtual bool processArguments( S32 argc, ConsoleValueRef *argv ); virtual bool processArguments( S32 argc, ConsoleValue *argv );
DECLARE_CONOBJECT( SimPersistSet ); DECLARE_CONOBJECT( SimPersistSet );
DECLARE_CATEGORY( "Console" ); DECLARE_CATEGORY( "Console" );

28
Engine/source/console/test/ScriptTest.cpp
View file

@ -20,7 +20,6 @@
// IN THE SOFTWARE. // IN THE SOFTWARE.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#ifdef 0
#ifdef TORQUE_TESTS_ENABLED #ifdef TORQUE_TESTS_ENABLED
#include "testing/unitTesting.h" #include "testing/unitTesting.h"
#include "platform/platform.h" #include "platform/platform.h"
@ -32,40 +31,40 @@
#include "console/stringStack.h" #include "console/stringStack.h"
template<typename T> template<typename T>
inline T Convert(ConsoleValueRef); inline T Convert(ConsoleValue&);
template<> template<>
inline U32 Convert(ConsoleValueRef val) inline U32 Convert(ConsoleValue &val)
{ {
return val.getIntValue(); return val.getInt();
} }
template<> template<>
inline S32 Convert(ConsoleValueRef val) inline S32 Convert(ConsoleValue &val)
{ {
return val.getSignedIntValue(); return val.getInt();
} }
template<> template<>
inline bool Convert(ConsoleValueRef val) inline bool Convert(ConsoleValue &val)
{ {
return val.getBoolValue(); return val.getBool();
} }
template<> template<>
inline F32 Convert(ConsoleValueRef val) inline F32 Convert(ConsoleValue &val)
{ {
return val.getFloatValue(); return val.getFloat();
} }
template<> template<>
inline const char* Convert(ConsoleValueRef val) inline const char* Convert(ConsoleValue &val)
{ {
return val.getStringValue(); return val.getString();
} }
template<> template<>
inline SimObject* Convert(ConsoleValueRef val) inline SimObject* Convert(ConsoleValue &val)
{ {
return Sim::findObject(val); return Sim::findObject(val);
} }
@ -73,7 +72,7 @@ inline SimObject* Convert(ConsoleValueRef val)
template<typename T> template<typename T>
inline T RunScript(const char* str) inline T RunScript(const char* str)
{ {
return Convert<T>(Con::evaluate(str, false, NULL)); return Convert<T>(std::move(Con::evaluate(str, false, NULL)));
} }
TEST(Script, Basic_Arithmetic) TEST(Script, Basic_Arithmetic)
@ -394,4 +393,3 @@ TEST(Script, Basic_Package)
} }
#endif #endif
#endif