Added macro so that ConCommands created with the SDK's CON_COMMAND and CON_COMMAND_F macros can be properly registered and unregisterd
1 //========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============//
7 //=============================================================================//
12 #include "basetypes.h"
14 #include "vstdlib/strtools.h"
15 #include "tier0/dbg.h"
16 #include "tier0/memdbgon.h"
19 ConCommandBase *ConCommandBase::s_pConCommandBases = NULL;
20 IConCommandBaseAccessor *ConCommandBase::s_pAccessor = NULL;
22 // ----------------------------------------------------------------------------- //
24 // ----------------------------------------------------------------------------- //
25 void ConCommandBaseMgr::OneTimeInit( IConCommandBaseAccessor *pAccessor )
27 ConCommandBase *pCur, *pNext;
29 ConCommandBase::s_pAccessor = pAccessor;
31 pCur = ConCommandBase::s_pConCommandBases;
34 pNext = pCur->m_pNext;
40 //-----------------------------------------------------------------------------
41 // Purpose: Default constructor
42 //-----------------------------------------------------------------------------
43 ConCommandBase::ConCommandBase( void )
45 m_bRegistered = false;
47 m_pszHelpString = NULL;
53 //-----------------------------------------------------------------------------
54 // Purpose: The base console invoked command/cvar interface
55 // Input : *pName - name of variable/command
56 // *pHelpString - help text
58 //-----------------------------------------------------------------------------
59 ConCommandBase::ConCommandBase( char const *pName, char const *pHelpString /*=0*/, int flags /*= 0*/ )
61 Create( pName, pHelpString, flags );
64 //-----------------------------------------------------------------------------
66 //-----------------------------------------------------------------------------
67 ConCommandBase::~ConCommandBase( void )
71 //-----------------------------------------------------------------------------
73 // Output : Returns true on success, false on failure.
74 //-----------------------------------------------------------------------------
75 bool ConCommandBase::IsCommand( void ) const
77 // Assert( 0 ); This can't assert. . causes a recursive assert in Sys_Printf, etc.
81 //-----------------------------------------------------------------------------
87 //-----------------------------------------------------------------------------
88 void ConCommandBase::Create( char const *pName, char const *pHelpString /*= 0*/, int flags /*= 0*/ )
90 static char *empty_string = "";
92 m_bRegistered = false;
94 // Name should be static data
97 m_pszHelpString = pHelpString ? pHelpString : empty_string;
101 if ( !( m_nFlags & FCVAR_UNREGISTERED ) )
103 m_pNext = s_pConCommandBases;
104 s_pConCommandBases = this;
112 // If s_pAccessor is already set (this ConVar is not a global variable),
120 //-----------------------------------------------------------------------------
121 // Purpose: Used internally by OneTimeInit to initialize.
122 //-----------------------------------------------------------------------------
123 void ConCommandBase::Init()
131 s_pAccessor->RegisterConCommandBase( this );
133 m_bRegistered = true;
136 //-----------------------------------------------------------------------------
139 // Output : ConCommandBase
140 //-----------------------------------------------------------------------------
141 ConCommandBase const *ConCommandBase::FindCommand( char const *name )
143 ConCommandBase const *cmd = GetCommands();
144 for ( ; cmd; cmd = cmd->GetNext() )
146 if ( !stricmp( name, cmd->GetName() ) )
152 //-----------------------------------------------------------------------------
154 // Output : ConCommandBase
155 //-----------------------------------------------------------------------------
156 const ConCommandBase *ConCommandBase::GetCommands( void )
158 return s_pConCommandBases;
161 //-----------------------------------------------------------------------------
165 //-----------------------------------------------------------------------------
166 void ConCommandBase::AddToList( ConCommandBase *var )
168 // This routine is only valid on root ConCommandBases
169 var->m_pNext = s_pConCommandBases;
170 s_pConCommandBases = var;
173 //-----------------------------------------------------------------------------
174 // Purpose: Return name of the command/var
175 // Output : char const
176 //-----------------------------------------------------------------------------
177 char const *ConCommandBase::GetName( void ) const
182 //-----------------------------------------------------------------------------
185 //-----------------------------------------------------------------------------
186 void ConCommandBase::RemoveFlaggedCommands( int flag )
188 ConCommandBase *pNewList;
189 ConCommandBase *pCommand, *pNext;
193 pCommand = s_pConCommandBases;
196 pNext = pCommand->m_pNext;
197 if ( !( pCommand->m_nFlags & flag ) )
199 pCommand->m_pNext = pNewList;
205 pCommand->m_pNext = NULL;
211 s_pConCommandBases = pNewList;
214 void ConCommandBase::RevertFlaggedCvars( int flag )
216 for (const ConCommandBase *var= GetCommands() ; var ; var=var->GetNext())
218 if ( var->IsCommand() )
221 ConVar *cvar = ( ConVar * )var;
223 if ( !cvar->IsBitSet( flag ) )
226 // It's == to the default value, don't count
227 if ( !Q_strcasecmp( cvar->GetDefault(), cvar->GetString() ) )
232 // DevMsg( "%s = \"%s\" (reverted)\n", cvar->GetName(), cvar->GetString() );
236 //-----------------------------------------------------------------------------
239 // Output : Returns true on success, false on failure.
240 //-----------------------------------------------------------------------------
241 bool ConCommandBase::IsBitSet( int flag ) const
243 return ( flag & m_nFlags ) ? true : false;
246 //-----------------------------------------------------------------------------
249 //-----------------------------------------------------------------------------
250 void ConCommandBase::AddFlags( int flags )
255 //-----------------------------------------------------------------------------
257 // Output : const ConCommandBase
258 //-----------------------------------------------------------------------------
259 const ConCommandBase *ConCommandBase::GetNext( void ) const
264 //-----------------------------------------------------------------------------
267 //-----------------------------------------------------------------------------
268 void ConCommandBase::SetNext( ConCommandBase *next )
273 //-----------------------------------------------------------------------------
274 // Purpose: Copies string using local new/delete operators
277 //-----------------------------------------------------------------------------
278 char *ConCommandBase::CopyString( char const *from )
283 len = strlen( from );
291 to = new char[len+1];
292 Q_strncpy( to, from, len+1 );
297 //-----------------------------------------------------------------------------
299 // Output : char const
300 //-----------------------------------------------------------------------------
301 char const *ConCommandBase::GetHelpText( void ) const
303 return m_pszHelpString;
306 //-----------------------------------------------------------------------------
307 // Purpose: Has this cvar been registered
308 // Output : Returns true on success, false on failure.
309 //-----------------------------------------------------------------------------
310 bool ConCommandBase::IsRegistered( void ) const
312 return m_bRegistered;
315 //-----------------------------------------------------------------------------
316 // Purpose: Constructs a console command
317 // Input : *pName - name of command
318 // callback - function to call upon execution
319 // *pHelpString - help text for command
320 // flags - command flags, if any
321 //-----------------------------------------------------------------------------
322 ConCommand::ConCommand( char const *pName, FnCommandCallback callback, char const *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*= 0*/ )
324 Create( pName, callback, pHelpString, flags, completionFunc );
327 //-----------------------------------------------------------------------------
329 //-----------------------------------------------------------------------------
330 ConCommand::~ConCommand( void )
335 //-----------------------------------------------------------------------------
337 // Output : Returns true on success, false on failure.
338 //-----------------------------------------------------------------------------
339 bool ConCommand::IsCommand( void ) const
344 //-----------------------------------------------------------------------------
345 // Purpose: Invoke the function if there is one
346 //-----------------------------------------------------------------------------
347 void ConCommand::Dispatch( void )
349 if ( m_fnCommandCallback )
351 ( *m_fnCommandCallback )();
355 // Command without callback!!!
360 //-----------------------------------------------------------------------------
362 // Input : *partial -
368 //-----------------------------------------------------------------------------
369 int DefaultCompletionFunc( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
374 //-----------------------------------------------------------------------------
375 // Purpose: Create the named command
380 //-----------------------------------------------------------------------------
381 void ConCommand::Create( char const *pName, FnCommandCallback callback, char const *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*=0*/ )
384 m_fnCommandCallback = callback;
386 m_fnCompletionCallback = completionFunc ? completionFunc : DefaultCompletionFunc;
387 m_bHasCompletionCallback = completionFunc != 0 ? true : false;
390 BaseClass::Create( pName, pHelpString, flags );
393 //-----------------------------------------------------------------------------
395 // Input : *partial -
400 //-----------------------------------------------------------------------------
401 int ConCommand::AutoCompleteSuggest( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
403 Assert( m_fnCompletionCallback );
404 if ( !m_fnCompletionCallback )
407 return ( m_fnCompletionCallback )( partial, commands );
410 //-----------------------------------------------------------------------------
412 // Output : Returns true on success, false on failure.
413 //-----------------------------------------------------------------------------
414 bool ConCommand::CanAutoComplete( void )
416 return m_bHasCompletionCallback;
419 // ----------------------------------------------------------------------------- //
421 // ----------------------------------------------------------------------------- //
422 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags /* = 0 */ )
424 Create( pName, pDefaultValue, flags );
427 // ----------------------------------------------------------------------------- //
429 // ----------------------------------------------------------------------------- //
430 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString )
432 Create( pName, pDefaultValue, flags, pHelpString );
435 // ----------------------------------------------------------------------------- //
437 // ----------------------------------------------------------------------------- //
438 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, bool bMin, float fMin, bool bMax, float fMax )
440 Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax );
443 // ----------------------------------------------------------------------------- //
445 // ----------------------------------------------------------------------------- //
446 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, FnChangeCallback callback )
448 Create( pName, pDefaultValue, flags, pHelpString, false, 0.0, false, 0.0, callback );
451 // ----------------------------------------------------------------------------- //
453 // ----------------------------------------------------------------------------- //
454 ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, bool bMin, float fMin, bool bMax, float fMax, FnChangeCallback callback )
456 Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax, callback );
459 //-----------------------------------------------------------------------------
460 // Purpose: Free dynamic memory
461 //-----------------------------------------------------------------------------
462 ConVar::~ConVar( void )
466 delete[] m_pszString;
472 //-----------------------------------------------------------------------------
473 // Install a change callback (there shouldn't already be one....)
474 //-----------------------------------------------------------------------------
476 void ConVar::InstallChangeCallback( FnChangeCallback callback )
478 Assert( !m_fnChangeCallback || !callback );
479 m_fnChangeCallback = callback;
481 if (m_fnChangeCallback)
483 // Call it immediately to set the initial value...
484 m_fnChangeCallback( this, m_pszString );
488 bool ConVar::IsBitSet( int flag ) const
490 return ( flag & m_pParent->m_nFlags ) ? true : false;
493 char const *ConVar::GetHelpText( void ) const
495 return m_pParent->m_pszHelpString;
498 void ConVar::AddFlags( int flags )
500 m_pParent->m_nFlags |= flags;
503 bool ConVar::IsRegistered( void ) const
505 return m_pParent->m_bRegistered;
508 char const *ConVar::GetName( void ) const
510 return m_pParent->m_pszName;
513 //-----------------------------------------------------------------------------
515 // Output : Returns true on success, false on failure.
516 //-----------------------------------------------------------------------------
517 bool ConVar::IsCommand( void ) const
522 //-----------------------------------------------------------------------------
525 //-----------------------------------------------------------------------------
531 //-----------------------------------------------------------------------------
534 //-----------------------------------------------------------------------------
535 void ConVar::InternalSetValue( char const *value )
541 Assert(m_pParent == this); // Only valid for root convars.
544 fNewValue = ( float )atof( value );
546 if ( ClampValue( fNewValue ) )
548 Q_snprintf( tempVal,sizeof(tempVal), "%f", fNewValue );
553 m_fValue = fNewValue;
554 m_nValue = ( int )( m_fValue );
556 if ( !(m_nFlags & FCVAR_NEVER_AS_STRING) )
557 ChangeStringValue( val );
560 //-----------------------------------------------------------------------------
562 // Input : *tempVal -
563 //-----------------------------------------------------------------------------
564 void ConVar::ChangeStringValue( char const *tempVal )
566 Assert( !( m_nFlags & FCVAR_NEVER_AS_STRING ) );
568 char* pszOldValue = (char*)stackalloc( m_StringLength );
570 if ( m_fnChangeCallback )
572 memcpy( pszOldValue, m_pszString, m_StringLength );
575 int len = Q_strlen(tempVal) + 1;
577 if ( len > m_StringLength)
580 delete[] m_pszString;
582 m_pszString = new char[len];
583 m_StringLength = len;
586 memcpy( m_pszString, tempVal, len );
588 // Invoke any necessary callback function
589 if ( m_fnChangeCallback )
591 m_fnChangeCallback( this, pszOldValue );
594 stackfree( pszOldValue );
597 //-----------------------------------------------------------------------------
598 // Purpose: Check whether to clamp and then perform clamp
600 // Output : Returns true if value changed
601 //-----------------------------------------------------------------------------
602 bool ConVar::ClampValue( float& value )
604 if ( m_bHasMin && ( value < m_fMinVal ) )
610 if ( m_bHasMax && ( value > m_fMaxVal ) )
619 //-----------------------------------------------------------------------------
622 //-----------------------------------------------------------------------------
623 void ConVar::InternalSetFloatValue( float fNewValue )
625 if ( fNewValue == m_fValue )
628 Assert( m_pParent == this ); // Only valid for root convars.
631 ClampValue( fNewValue );
634 m_fValue = fNewValue;
635 m_nValue = ( int )m_fValue;
637 if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
640 Q_snprintf( tempVal, sizeof( tempVal), "%f", m_fValue );
641 ChangeStringValue( tempVal );
645 Assert( !m_fnChangeCallback );
649 //-----------------------------------------------------------------------------
652 //-----------------------------------------------------------------------------
653 void ConVar::InternalSetIntValue( int nValue )
655 if ( nValue == m_nValue )
658 Assert( m_pParent == this ); // Only valid for root convars.
660 float fValue = (float)nValue;
661 if ( ClampValue( fValue ) )
663 nValue = ( int )( fValue );
670 if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
673 Q_snprintf( tempVal, sizeof( tempVal ), "%d", m_nValue );
674 ChangeStringValue( tempVal );
678 Assert( !m_fnChangeCallback );
682 //-----------------------------------------------------------------------------
683 // Purpose: Private creation
684 //-----------------------------------------------------------------------------
685 void ConVar::Create( char const *pName, char const *pDefaultValue, int flags /*= 0*/,
686 char const *pHelpString /*= NULL*/, bool bMin /*= false*/, float fMin /*= 0.0*/,
687 bool bMax /*= false*/, float fMax /*= false*/, FnChangeCallback callback /*= NULL*/ )
689 static char *empty_string = "";
693 // Name should be static data
694 m_pszDefaultValue = pDefaultValue ? pDefaultValue : empty_string;
695 Assert( pDefaultValue );
697 m_StringLength = strlen( m_pszDefaultValue ) + 1;
698 m_pszString = new char[m_StringLength];
699 memcpy( m_pszString, m_pszDefaultValue, m_StringLength );
706 m_fnChangeCallback = callback;
708 m_fValue = ( float )atof( m_pszString );
710 // Bounds Check, should never happen, if it does, no big deal
711 if ( m_bHasMin && ( m_fValue < m_fMinVal ) )
716 if ( m_bHasMax && ( m_fValue > m_fMaxVal ) )
721 m_nValue = ( int )m_fValue;
723 BaseClass::Create( pName, pHelpString, flags );
726 //-----------------------------------------------------------------------------
729 //-----------------------------------------------------------------------------
730 void ConVar::SetValue(char const *value)
732 ConVar *var = ( ConVar * )m_pParent;
733 var->InternalSetValue( value );
736 //-----------------------------------------------------------------------------
739 //-----------------------------------------------------------------------------
740 void ConVar::SetValue( float value )
742 ConVar *var = ( ConVar * )m_pParent;
743 var->InternalSetFloatValue( value );
746 //-----------------------------------------------------------------------------
749 //-----------------------------------------------------------------------------
750 void ConVar::SetValue( int value )
752 ConVar *var = ( ConVar * )m_pParent;
753 var->InternalSetIntValue( value );
756 //-----------------------------------------------------------------------------
757 // Purpose: Reset to default value
758 //-----------------------------------------------------------------------------
759 void ConVar::Revert( void )
761 // Force default value again
762 ConVar *var = ( ConVar * )m_pParent;
763 var->SetValue( var->m_pszDefaultValue );
766 //-----------------------------------------------------------------------------
768 //-----------------------------------------------------------------------------
769 void ConVar::RevertAll( void )
771 ConCommandBase *p = s_pConCommandBases;
774 if ( !p->IsCommand() )
776 ConVar *var = ( ConVar * )p;
783 //-----------------------------------------------------------------------------
786 // Output : true if there is a min set
787 //-----------------------------------------------------------------------------
788 bool ConVar::GetMin( float& minVal ) const
790 minVal = m_pParent->m_fMinVal;
791 return m_pParent->m_bHasMin;
794 //-----------------------------------------------------------------------------
797 //-----------------------------------------------------------------------------
798 bool ConVar::GetMax( float& maxVal ) const
800 maxVal = m_pParent->m_fMaxVal;
801 return m_pParent->m_bHasMax;
804 //-----------------------------------------------------------------------------
806 // Output : char const
807 //-----------------------------------------------------------------------------
808 char const *ConVar::GetDefault( void ) const
810 return m_pParent->m_pszDefaultValue;