1 //========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============//
7 //=============================================================================//
10 #include "xbox/xbox_platform.h"
11 #include "xbox/xbox_win32stubs.h"
12 #include "xbox/xbox_core.h"
17 #include "basetypes.h"
19 #include "vstdlib/strtools.h"
21 #include "tier0/dbg.h"
23 #include "vstdlib/ICommandLine.h"
25 #include "tier0/memdbgon.h"
27 ConCommandBase *ConCommandBase::s_pConCommandBases = NULL;
28 IConCommandBaseAccessor *ConCommandBase::s_pAccessor = NULL;
31 static char const* GetCommandLineValue( char const *pVariableName )
33 int nLen = Q_strlen(pVariableName);
34 char *pSearch = (char*)stackalloc(nLen + 2);
36 memcpy(&pSearch[1], pVariableName, nLen + 1);
37 return CommandLine()->ParmValue(pSearch);
41 #if defined( _XBOX ) && !defined( _RETAIL )
42 void ConCommandBaseMgr::PublishCommands( bool bForce )
45 const char *commands[2048];
46 const char *helptext[2048];
51 for ( pCur=ConCommandBase::s_pConCommandBases; pCur; pCur=pCur->m_pNext )
53 pCur->m_bRegistered = false;
57 // iterate and publish commands to the remote console
58 for ( pCur=ConCommandBase::s_pConCommandBases; pCur; pCur=pCur->m_pNext )
60 if ( !pCur->m_bRegistered )
62 // add unregistered commands to list
63 if ( numCommands < sizeof(commands)/sizeof(commands[0]) )
65 commands[numCommands] = pCur->m_pszName;
66 helptext[numCommands] = pCur->m_pszHelpString;
71 pCur->m_bRegistered = true;
76 XBX_rAddCommands( numCommands, commands, helptext );
82 bool ConCommandBaseMgr::Fixup(ConCommandBase* pConCommand)
85 ConCommandBase *pPrev2;
86 ConCommandBase *pCur2;
87 ConCommandBase *pNext2;
89 static int initCount = 0;
91 // xboxissue - cvars and its class hierarchy could not be made to instance per subsystem
92 // without massive mangling and re-arranging, instead...
93 // there is only a single chain and therefore single /init/fixup
94 // missing: need to identify which subsystem
95 // could pass as part of declaration in constructor, but how to hide parameter for pc
96 // the accessors (aka callbacks to subsystems) to register with engine
97 // cannot be invoked as their unlink logic expect private lists
98 // so this just mimics the expected end result
99 // must handle early and late constructors
100 // late constructors are usually function scoped static
103 // the caller is one-time-init
106 // the list has already been fixed
112 // the caller is a console command constructor
115 // the list has not been fixed yet
116 // no special behavior
121 // the list has already been fixed
122 // the console command is a late constructor
123 // add in to fixed list
124 bool hasParent = false;
125 if (!pConCommand->IsCommand())
127 pCur = ConCommandBase::s_pConCommandBases;
130 if (pCur->IsCommand() && !stricmp(pCur->m_pszName, pConCommand->m_pszName))
133 ((ConVar*)pConCommand)->m_pParent = ((ConVar*)pCur)->m_pParent;
137 pCur = pCur->m_pNext;
142 // add to head of list
143 pConCommand->m_pNext = ConCommandBase::s_pConCommandBases;
144 ConCommandBase::s_pConCommandBases = pConCommand;
153 // iterate the cvars and set their possible proxy parents
154 // skip over registered (fixed) entries
155 pCur = ConCommandBase::s_pConCommandBases;
158 if (!pCur->IsCommand() && !pCur->m_bRegistered)
160 // iterate from the next node until end of list
161 name = pCur->m_pszName;
163 pCur2 = pCur->m_pNext;
166 pNext2 = pCur2->m_pNext;
167 if (!pCur2->IsCommand() && !stricmp(pCur2->m_pszName, name))
171 pCur2->m_pNext = NULL;
172 pPrev2->m_pNext = pNext2;
175 ((ConVar*)pCur2)->m_pParent = ((ConVar*)pCur)->m_pParent;
179 // no unlink, advance to next node
186 char const *pValue = GetCommandLineValue(name);
188 ((ConVar*)pCur)->SetValue(pValue);
190 pCur = pCur->m_pNext;
194 #if !defined( _RETAIL )
195 XBX_rTimeStampLog( Plat_FloatTime(), "xbx PublishCommands:Start" );
197 PublishCommands( false );
199 XBX_rTimeStampLog( Plat_FloatTime(), "xbx PublishCommands:Done" );
202 // fixup has been performed
207 // ----------------------------------------------------------------------------- //
208 // ConCommandBaseMgr.
209 // ----------------------------------------------------------------------------- //
210 void ConCommandBaseMgr::OneTimeInit( IConCommandBaseAccessor *pAccessor )
214 ConCommandBaseMgr::Fixup(NULL);
216 ConCommandBase *pCur, *pNext;
218 ConCommandBase::s_pAccessor = pAccessor;
219 pCur = ConCommandBase::s_pConCommandBases;
222 pNext = pCur->m_pNext;
229 //-----------------------------------------------------------------------------
230 // Purpose: Default constructor
231 //-----------------------------------------------------------------------------
232 ConCommandBase::ConCommandBase( void )
234 m_bRegistered = false;
236 m_pszHelpString = NULL;
242 //-----------------------------------------------------------------------------
243 // Purpose: The base console invoked command/cvar interface
244 // Input : *pName - name of variable/command
245 // *pHelpString - help text
247 //-----------------------------------------------------------------------------
248 ConCommandBase::ConCommandBase( char const *pName, char const *pHelpString /*=0*/, int flags /*= 0*/ )
250 Create( pName, pHelpString, flags );
253 //-----------------------------------------------------------------------------
255 //-----------------------------------------------------------------------------
256 ConCommandBase::~ConCommandBase( void )
260 //-----------------------------------------------------------------------------
262 // Output : Returns true on success, false on failure.
263 //-----------------------------------------------------------------------------
264 bool ConCommandBase::IsCommand( void ) const
266 // Assert( 0 ); This can't assert. . causes a recursive assert in Sys_Printf, etc.
270 //-----------------------------------------------------------------------------
276 //-----------------------------------------------------------------------------
277 void ConCommandBase::Create( char const *pName, char const *pHelpString /*= 0*/, int flags /*= 0*/ )
279 static char *empty_string = "";
281 m_bRegistered = false;
283 // Name should be static data
286 m_pszHelpString = pHelpString ? pHelpString : empty_string;
291 if (ConCommandBaseMgr::Fixup(this))
295 if ( !( m_nFlags & FCVAR_UNREGISTERED ) )
298 m_pNext = s_pConCommandBases;
299 s_pConCommandBases = this;
301 // xboxissue - engine cvars should be at head of list to
302 // ensure they are set as the cvar master/parent during fixup
303 if (!s_pConCommandBases || !(flags & FCVAR_NON_ENGINE))
305 // engine cvars, place at head of list
306 m_pNext = s_pConCommandBases;
307 s_pConCommandBases = this;
311 // non-engine cvars, place at end of list
312 ConCommandBase *cur = s_pConCommandBases;
332 // If s_pAccessor is already set (this ConVar is not a global variable),
340 //-----------------------------------------------------------------------------
341 // Purpose: Used internally by OneTimeInit to initialize.
342 //-----------------------------------------------------------------------------
343 void ConCommandBase::Init()
351 s_pAccessor->RegisterConCommandBase( this );
353 m_bRegistered = true;
356 //-----------------------------------------------------------------------------
359 // Output : ConCommandBase
360 //-----------------------------------------------------------------------------
361 ConCommandBase const *ConCommandBase::FindCommand( char const *name )
363 ConCommandBase const *cmd = GetCommands();
364 for ( ; cmd; cmd = cmd->GetNext() )
366 if ( !stricmp( name, cmd->GetName() ) )
372 //-----------------------------------------------------------------------------
374 // Output : ConCommandBase
375 //-----------------------------------------------------------------------------
376 const ConCommandBase *ConCommandBase::GetCommands( void )
378 return s_pConCommandBases;
381 //-----------------------------------------------------------------------------
385 //-----------------------------------------------------------------------------
386 void ConCommandBase::AddToList( ConCommandBase *var )
388 // This routine is only valid on root ConCommandBases
389 var->m_pNext = s_pConCommandBases;
390 s_pConCommandBases = var;
393 //-----------------------------------------------------------------------------
394 // Purpose: Return name of the command/var
395 // Output : char const
396 //-----------------------------------------------------------------------------
397 char const *ConCommandBase::GetName( void ) const
402 //-----------------------------------------------------------------------------
405 //-----------------------------------------------------------------------------
406 void ConCommandBase::RemoveFlaggedCommands( int flag )
408 ConCommandBase *pNewList;
409 ConCommandBase *pCommand, *pNext;
413 pCommand = s_pConCommandBases;
416 pNext = pCommand->m_pNext;
417 if ( !( pCommand->m_nFlags & flag ) )
419 pCommand->m_pNext = pNewList;
425 pCommand->m_pNext = NULL;
431 s_pConCommandBases = pNewList;
434 void ConCommandBase::RevertFlaggedCvars( int flag )
436 for (const ConCommandBase *var= GetCommands() ; var ; var=var->GetNext())
438 if ( var->IsCommand() )
441 ConVar *cvar = ( ConVar * )var;
443 if ( !cvar->IsBitSet( flag ) )
446 // It's == to the default value, don't count
447 if ( !Q_strcasecmp( cvar->GetDefault(), cvar->GetString() ) )
452 // DevMsg( "%s = \"%s\" (reverted)\n", cvar->GetName(), cvar->GetString() );
456 //-----------------------------------------------------------------------------
459 // Output : Returns true on success, false on failure.
460 //-----------------------------------------------------------------------------
461 bool ConCommandBase::IsBitSet( int flag ) const
463 return ( flag & m_nFlags ) ? true : false;
466 //-----------------------------------------------------------------------------
469 //-----------------------------------------------------------------------------
470 void ConCommandBase::AddFlags( int flags )
475 //-----------------------------------------------------------------------------
477 // Output : const ConCommandBase
478 //-----------------------------------------------------------------------------
479 const ConCommandBase *ConCommandBase::GetNext( void ) const
484 //-----------------------------------------------------------------------------
487 //-----------------------------------------------------------------------------
488 void ConCommandBase::SetNext( ConCommandBase *next )
493 //-----------------------------------------------------------------------------
494 // Purpose: Copies string using local new/delete operators
497 //-----------------------------------------------------------------------------
498 char *ConCommandBase::CopyString( char const *from )
503 len = strlen( from );
511 to = new char[len+1];
512 Q_strncpy( to, from, len+1 );
517 //-----------------------------------------------------------------------------
519 // Output : char const
520 //-----------------------------------------------------------------------------
521 char const *ConCommandBase::GetHelpText( void ) const
523 return m_pszHelpString;
526 //-----------------------------------------------------------------------------
527 // Purpose: Has this cvar been registered
528 // Output : Returns true on success, false on failure.
529 //-----------------------------------------------------------------------------
530 bool ConCommandBase::IsRegistered( void ) const
532 return m_bRegistered;
535 //-----------------------------------------------------------------------------
536 // Purpose: Constructs a console command
537 // Input : *pName - name of command
538 // callback - function to call upon execution
539 // *pHelpString - help text for command
540 // flags - command flags, if any
541 //-----------------------------------------------------------------------------
542 ConCommand::ConCommand( char const *pName, FnCommandCallback callback, char const *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*= 0*/ )
544 Create( pName, callback, pHelpString, flags, completionFunc );
547 //-----------------------------------------------------------------------------
549 //-----------------------------------------------------------------------------
550 ConCommand::~ConCommand( void )
554 //-----------------------------------------------------------------------------
556 // Output : Returns true on success, false on failure.
557 //-----------------------------------------------------------------------------
558 bool ConCommand::IsCommand( void ) const
563 //-----------------------------------------------------------------------------
564 // Purpose: Invoke the function if there is one
565 //-----------------------------------------------------------------------------
566 void ConCommand::Dispatch( void )
568 if ( m_fnCommandCallback )
570 ( *m_fnCommandCallback )();
574 // Command without callback!!!
579 //-----------------------------------------------------------------------------
581 // Input : *partial -
587 //-----------------------------------------------------------------------------
588 int DefaultCompletionFunc( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
593 //-----------------------------------------------------------------------------
594 // Purpose: Create the named command
599 //-----------------------------------------------------------------------------
600 void ConCommand::Create( char const *pName, FnCommandCallback callback, char const *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*=0*/ )
603 m_fnCommandCallback = callback;
605 m_fnCompletionCallback = completionFunc ? completionFunc : DefaultCompletionFunc;
606 m_bHasCompletionCallback = completionFunc != 0 ? true : false;
609 BaseClass::Create( pName, pHelpString, flags );
612 //-----------------------------------------------------------------------------
614 // Input : *partial -
619 //-----------------------------------------------------------------------------
620 int ConCommand::AutoCompleteSuggest( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
622 Assert( m_fnCompletionCallback );
623 if ( !m_fnCompletionCallback )
626 return ( m_fnCompletionCallback )( partial, commands );
629 //-----------------------------------------------------------------------------
631 // Output : Returns true on success, false on failure.
632 //-----------------------------------------------------------------------------
633 bool ConCommand::CanAutoComplete( void )
635 return m_bHasCompletionCallback;
638 // ----------------------------------------------------------------------------- //
640 // ----------------------------------------------------------------------------- //
641 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags /* = 0 */ )
643 Create( pName, pDefaultValue, flags );
646 // ----------------------------------------------------------------------------- //
648 // ----------------------------------------------------------------------------- //
649 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString )
651 Create( pName, pDefaultValue, flags, pHelpString );
654 // ----------------------------------------------------------------------------- //
656 // ----------------------------------------------------------------------------- //
657 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, bool bMin, float fMin, bool bMax, float fMax )
659 Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax );
662 // ----------------------------------------------------------------------------- //
664 // ----------------------------------------------------------------------------- //
665 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, FnChangeCallback callback )
667 Create( pName, pDefaultValue, flags, pHelpString, false, 0.0, false, 0.0, callback );
670 // ----------------------------------------------------------------------------- //
672 // ----------------------------------------------------------------------------- //
673 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, bool bMin, float fMin, bool bMax, float fMax, FnChangeCallback callback )
675 Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax, callback );
678 //-----------------------------------------------------------------------------
679 // Purpose: Free dynamic memory
680 //-----------------------------------------------------------------------------
681 ConVar::~ConVar( void )
685 delete[] m_pszString;
691 //-----------------------------------------------------------------------------
692 // Install a change callback (there shouldn't already be one....)
693 //-----------------------------------------------------------------------------
695 void ConVar::InstallChangeCallback( FnChangeCallback callback )
697 Assert( !m_fnChangeCallback || !callback );
698 m_fnChangeCallback = callback;
700 if (m_fnChangeCallback)
702 // Call it immediately to set the initial value...
703 m_fnChangeCallback( this, m_pszString );
707 bool ConVar::IsBitSet( int flag ) const
709 return ( flag & m_pParent->m_nFlags ) ? true : false;
712 char const *ConVar::GetHelpText( void ) const
714 return m_pParent->m_pszHelpString;
717 void ConVar::AddFlags( int flags )
719 m_pParent->m_nFlags |= flags;
722 bool ConVar::IsRegistered( void ) const
724 return m_pParent->m_bRegistered;
727 char const *ConVar::GetName( void ) const
729 return m_pParent->m_pszName;
732 //-----------------------------------------------------------------------------
734 // Output : Returns true on success, false on failure.
735 //-----------------------------------------------------------------------------
736 bool ConVar::IsCommand( void ) const
741 //-----------------------------------------------------------------------------
744 //-----------------------------------------------------------------------------
750 //-----------------------------------------------------------------------------
753 //-----------------------------------------------------------------------------
754 void ConVar::InternalSetValue( char const *value )
760 Assert(m_pParent == this); // Only valid for root convars.
763 fNewValue = ( float )atof( value );
765 if ( ClampValue( fNewValue ) )
767 Q_snprintf( tempVal,sizeof(tempVal), "%f", fNewValue );
772 m_fValue = fNewValue;
773 m_nValue = ( int )( m_fValue );
775 if ( !(m_nFlags & FCVAR_NEVER_AS_STRING) )
776 ChangeStringValue( val );
779 //-----------------------------------------------------------------------------
781 // Input : *tempVal -
782 //-----------------------------------------------------------------------------
783 void ConVar::ChangeStringValue( char const *tempVal )
785 Assert( !( m_nFlags & FCVAR_NEVER_AS_STRING ) );
787 char* pszOldValue = (char*)stackalloc( m_StringLength );
788 memcpy( pszOldValue, m_pszString, m_StringLength );
790 int len = Q_strlen(tempVal) + 1;
792 if ( len > m_StringLength)
795 delete[] m_pszString;
797 m_pszString = new char[len];
798 m_StringLength = len;
801 memcpy( m_pszString, tempVal, len );
803 // Invoke any necessary callback function
804 if ( m_fnChangeCallback )
806 m_fnChangeCallback( this, pszOldValue );
809 GetCVarIF()->CallGlobalChangeCallback( this, pszOldValue );
811 stackfree( pszOldValue );
814 //-----------------------------------------------------------------------------
815 // Purpose: Check whether to clamp and then perform clamp
817 // Output : Returns true if value changed
818 //-----------------------------------------------------------------------------
819 bool ConVar::ClampValue( float& value )
821 if ( m_bHasMin && ( value < m_fMinVal ) )
827 if ( m_bHasMax && ( value > m_fMaxVal ) )
836 //-----------------------------------------------------------------------------
839 //-----------------------------------------------------------------------------
840 void ConVar::InternalSetFloatValue( float fNewValue )
842 if ( fNewValue == m_fValue )
845 Assert( m_pParent == this ); // Only valid for root convars.
848 ClampValue( fNewValue );
851 m_fValue = fNewValue;
852 m_nValue = ( int )m_fValue;
854 if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
857 Q_snprintf( tempVal, sizeof( tempVal), "%f", m_fValue );
858 ChangeStringValue( tempVal );
862 Assert( !m_fnChangeCallback );
866 //-----------------------------------------------------------------------------
869 //-----------------------------------------------------------------------------
870 void ConVar::InternalSetIntValue( int nValue )
872 if ( nValue == m_nValue )
875 Assert( m_pParent == this ); // Only valid for root convars.
877 float fValue = (float)nValue;
878 if ( ClampValue( fValue ) )
880 nValue = ( int )( fValue );
887 if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
890 Q_snprintf( tempVal, sizeof( tempVal ), "%d", m_nValue );
891 ChangeStringValue( tempVal );
895 Assert( !m_fnChangeCallback );
899 //-----------------------------------------------------------------------------
900 // Purpose: Private creation
901 //-----------------------------------------------------------------------------
902 void ConVar::Create( char const *pName, char const *pDefaultValue, int flags /*= 0*/,
903 char const *pHelpString /*= NULL*/, bool bMin /*= false*/, float fMin /*= 0.0*/,
904 bool bMax /*= false*/, float fMax /*= false*/, FnChangeCallback callback /*= NULL*/ )
906 static char *empty_string = "";
910 // Name should be static data
911 m_pszDefaultValue = pDefaultValue ? pDefaultValue : empty_string;
912 Assert( pDefaultValue );
914 m_StringLength = strlen( m_pszDefaultValue ) + 1;
915 m_pszString = new char[m_StringLength];
916 memcpy( m_pszString, m_pszDefaultValue, m_StringLength );
923 m_fnChangeCallback = callback;
925 m_fValue = ( float )atof( m_pszString );
927 // Bounds Check, should never happen, if it does, no big deal
928 if ( m_bHasMin && ( m_fValue < m_fMinVal ) )
933 if ( m_bHasMax && ( m_fValue > m_fMaxVal ) )
938 m_nValue = ( int )m_fValue;
940 BaseClass::Create( pName, pHelpString, flags );
943 //-----------------------------------------------------------------------------
946 //-----------------------------------------------------------------------------
947 void ConVar::SetValue(char const *value)
949 ConVar *var = ( ConVar * )m_pParent;
950 var->InternalSetValue( value );
953 //-----------------------------------------------------------------------------
956 //-----------------------------------------------------------------------------
957 void ConVar::SetValue( float value )
959 ConVar *var = ( ConVar * )m_pParent;
960 var->InternalSetFloatValue( value );
963 //-----------------------------------------------------------------------------
966 //-----------------------------------------------------------------------------
967 void ConVar::SetValue( int value )
969 ConVar *var = ( ConVar * )m_pParent;
970 var->InternalSetIntValue( value );
973 //-----------------------------------------------------------------------------
974 // Purpose: Reset to default value
975 //-----------------------------------------------------------------------------
976 void ConVar::Revert( void )
978 // Force default value again
979 ConVar *var = ( ConVar * )m_pParent;
980 var->SetValue( var->m_pszDefaultValue );
983 //-----------------------------------------------------------------------------
985 //-----------------------------------------------------------------------------
986 void ConVar::RevertAll( void )
988 ConCommandBase *p = s_pConCommandBases;
991 if ( !p->IsCommand() )
993 ConVar *var = ( ConVar * )p;
1000 //-----------------------------------------------------------------------------
1003 // Output : true if there is a min set
1004 //-----------------------------------------------------------------------------
1005 bool ConVar::GetMin( float& minVal ) const
1007 minVal = m_pParent->m_fMinVal;
1008 return m_pParent->m_bHasMin;
1011 //-----------------------------------------------------------------------------
1014 //-----------------------------------------------------------------------------
1015 bool ConVar::GetMax( float& maxVal ) const
1017 maxVal = m_pParent->m_fMaxVal;
1018 return m_pParent->m_bHasMax;
1021 //-----------------------------------------------------------------------------
1023 // Output : char const
1024 //-----------------------------------------------------------------------------
1025 char const *ConVar::GetDefault( void ) const
1027 return m_pParent->m_pszDefaultValue;