Team Fortress 2 Source Code as on 22/4/2020
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

696 lines
17 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $Workfile: $
// $NoKeywords: $
//===========================================================================//
#include "pch_tier0.h"
#include "tier0/icommandline.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "tier0/dbg.h"
#include "tier0/memdbgon.h"
#ifdef POSIX
#include <limits.h>
#define _MAX_PATH PATH_MAX
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
static const int MAX_PARAMETER_LEN = 128;
//-----------------------------------------------------------------------------
// Purpose: Implements ICommandLine
//-----------------------------------------------------------------------------
class CCommandLine : public ICommandLine
{
public:
// Construction
CCommandLine( void );
virtual ~CCommandLine( void );
// Implements ICommandLine
virtual void CreateCmdLine( const char *commandline );
virtual void CreateCmdLine( int argc, char **argv );
virtual const char *GetCmdLine( void ) const;
virtual const char *CheckParm( const char *psz, const char **ppszValue = 0 ) const;
// A bool return of whether param exists, useful for just checking if param that is just a flag is set
virtual bool HasParm( const char *psz ) const;
virtual void RemoveParm( const char *parm );
virtual void AppendParm( const char *pszParm, const char *pszValues );
virtual int ParmCount() const;
virtual int FindParm( const char *psz ) const;
virtual const char* GetParm( int nIndex ) const;
virtual const char *ParmValue( const char *psz, const char *pDefaultVal = NULL ) const OVERRIDE;
virtual int ParmValue( const char *psz, int nDefaultVal ) const OVERRIDE;
virtual float ParmValue( const char *psz, float flDefaultVal ) const OVERRIDE;
virtual const char *ParmValueByIndex( int nIndex, const char *pDefaultVal = 0 ) const OVERRIDE;
virtual void SetParm( int nIndex, char const *pParm );
private:
enum
{
MAX_PARAMETER_LEN = 128,
MAX_PARAMETERS = 256,
};
// When the commandline contains @name, it reads the parameters from that file
void LoadParametersFromFile( const char *&pSrc, char *&pDst, int maxDestLen, bool bInQuotes );
// Parse command line...
void ParseCommandLine();
// Frees the command line arguments
void CleanUpParms();
// Adds an argument..
void AddArgument( const char *pFirst, const char *pLast );
// Copy of actual command line
char *m_pszCmdLine;
// Pointers to each argument...
int m_nParmCount;
char *m_ppParms[MAX_PARAMETERS];
};
//-----------------------------------------------------------------------------
// Instance singleton and expose interface to rest of code
//-----------------------------------------------------------------------------
static CCommandLine g_CmdLine;
ICommandLine *CommandLine()
{
return &g_CmdLine;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CCommandLine::CCommandLine( void )
{
m_pszCmdLine = NULL;
m_nParmCount = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CCommandLine::~CCommandLine( void )
{
CleanUpParms();
delete[] m_pszCmdLine;
}
//-----------------------------------------------------------------------------
// Read commandline from file instead...
//-----------------------------------------------------------------------------
void CCommandLine::LoadParametersFromFile( const char *&pSrc, char *&pDst, int maxDestLen, bool bInQuotes )
{
// Suck out the file name
char szFileName[ _MAX_PATH ];
char *pOut;
char *pDestStart = pDst;
if ( maxDestLen < 3 )
return;
// Skip the @ sign
pSrc++;
pOut = szFileName;
char terminatingChar = ' ';
if ( bInQuotes )
terminatingChar = '\"';
while ( *pSrc && *pSrc != terminatingChar )
{
*pOut++ = *pSrc++;
if ( (pOut - szFileName) >= (_MAX_PATH-1) )
break;
}
*pOut = '\0';
// Skip the space after the file name
if ( *pSrc )
pSrc++;
// Now read in parameters from file
FILE *fp = fopen( szFileName, "r" );
if ( fp )
{
char c;
c = (char)fgetc( fp );
while ( c != EOF )
{
// Turn return characters into spaces
if ( c == '\n' )
c = ' ';
*pDst++ = c;
// Don't go past the end, and allow for our terminating space character AND a terminating null character.
if ( (pDst - pDestStart) >= (maxDestLen-2) )
break;
// Get the next character, if there are more
c = (char)fgetc( fp );
}
// Add a terminating space character
*pDst++ = ' ';
fclose( fp );
}
else
{
printf( "Parameter file '%s' not found, skipping...", szFileName );
}
}
//-----------------------------------------------------------------------------
// Creates a command line from the arguments passed in
//-----------------------------------------------------------------------------
void CCommandLine::CreateCmdLine( int argc, char **argv )
{
char cmdline[ 2048 ];
cmdline[ 0 ] = 0;
char *dest = cmdline;
size_t size = sizeof( cmdline );
const char *space = "";
for ( int i = 0; i < argc; ++i )
{
// We need room for: space, arg, 2 quotes, and a nil.
Assert( strlen( space ) + strlen( argv[ i ] ) + 2 + 1 <= size );
if ( size )
{
_snprintf( dest, size, "%s\"%s\"", space, argv[ i ] );
dest[ size - 1 ] = 0;
}
size_t len = strlen( dest );
size -= len;
dest += len;
space = " ";
}
CreateCmdLine( cmdline );
}
//-----------------------------------------------------------------------------
// Purpose: Create a command line from the passed in string
// Note that if you pass in a @filename, then the routine will read settings
// from a file instead of the command line
//-----------------------------------------------------------------------------
void CCommandLine::CreateCmdLine( const char *commandline )
{
if ( m_pszCmdLine )
{
delete[] m_pszCmdLine;
}
char szFull[ 4096 ];
szFull[0] = '\0';
char *pDst = szFull;
const char *pSrc = commandline;
bool bInQuotes = false;
const char *pInQuotesStart = 0;
while ( *pSrc )
{
// Is this an unslashed quote?
if ( *pSrc == '"' )
{
if ( pSrc == commandline || ( pSrc[-1] != '/' && pSrc[-1] != '\\' ) )
{
bInQuotes = !bInQuotes;
pInQuotesStart = pSrc + 1;
}
}
if ( *pSrc == '@' )
{
if ( pSrc == commandline || (!bInQuotes && isspace( pSrc[-1] )) || (bInQuotes && pSrc == pInQuotesStart) )
{
LoadParametersFromFile( pSrc, pDst, sizeof( szFull ) - (pDst - szFull), bInQuotes );
continue;
}
}
// Don't go past the end.
if ( (pDst - szFull) >= (sizeof( szFull ) - 1) )
break;
*pDst++ = *pSrc++;
}
*pDst = '\0';
int len = strlen( szFull ) + 1;
m_pszCmdLine = new char[len];
memcpy( m_pszCmdLine, szFull, len );
ParseCommandLine();
}
//-----------------------------------------------------------------------------
// Finds a string in another string with a case insensitive test
//-----------------------------------------------------------------------------
static char * _stristr( char * pStr, const char * pSearch )
{
AssertValidStringPtr(pStr);
AssertValidStringPtr(pSearch);
if (!pStr || !pSearch)
return 0;
char* pLetter = pStr;
// Check the entire string
while (*pLetter != 0)
{
// Skip over non-matches
if (tolower((unsigned char)*pLetter) == tolower((unsigned char)*pSearch))
{
// Check for match
char const* pMatch = pLetter + 1;
char const* pTest = pSearch + 1;
while (*pTest != 0)
{
// We've run off the end; don't bother.
if (*pMatch == 0)
return 0;
if (tolower((unsigned char)*pMatch) != tolower((unsigned char)*pTest))
break;
++pMatch;
++pTest;
}
// Found a match!
if (*pTest == 0)
return pLetter;
}
++pLetter;
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Remove specified string ( and any args attached to it ) from command line
// Input : *pszParm -
//-----------------------------------------------------------------------------
void CCommandLine::RemoveParm( const char *pszParm )
{
if ( !m_pszCmdLine )
return;
// Search for first occurrence of pszParm
char *p, *found;
char *pnextparam;
int n;
int curlen;
p = m_pszCmdLine;
while ( *p )
{
curlen = strlen( p );
found = _stristr( p, pszParm );
if ( !found )
break;
pnextparam = found + 1;
bool bHadQuote = false;
if ( found > m_pszCmdLine && found[-1] == '\"' )
bHadQuote = true;
while ( pnextparam && *pnextparam && (*pnextparam != ' ') && (*pnextparam != '\"') )
pnextparam++;
if ( pnextparam && ( static_cast<size_t>( pnextparam - found ) > strlen( pszParm ) ) )
{
p = pnextparam;
continue;
}
while ( pnextparam && *pnextparam && (*pnextparam != '-') && (*pnextparam != '+') )
pnextparam++;
if ( bHadQuote )
{
found--;
}
if ( pnextparam && *pnextparam )
{
// We are either at the end of the string, or at the next param. Just chop out the current param.
n = curlen - ( pnextparam - p ); // # of characters after this param.
memmove( found, pnextparam, n );
found[n] = '\0';
}
else
{
// Clear out rest of string.
n = pnextparam - found;
memset( found, 0, n );
}
}
// Strip and trailing ' ' characters left over.
while ( 1 )
{
int len = strlen( m_pszCmdLine );
if ( len == 0 || m_pszCmdLine[ len - 1 ] != ' ' )
break;
m_pszCmdLine[len - 1] = '\0';
}
ParseCommandLine();
}
//-----------------------------------------------------------------------------
// Purpose: Append parameter and argument values to command line
// Input : *pszParm -
// *pszValues -
//-----------------------------------------------------------------------------
void CCommandLine::AppendParm( const char *pszParm, const char *pszValues )
{
int nNewLength = 0;
char *pCmdString;
nNewLength = strlen( pszParm ); // Parameter.
if ( pszValues )
nNewLength += strlen( pszValues ) + 1; // Values + leading space character.
nNewLength++; // Terminal 0;
if ( !m_pszCmdLine )
{
m_pszCmdLine = new char[ nNewLength ];
strcpy( m_pszCmdLine, pszParm );
if ( pszValues )
{
strcat( m_pszCmdLine, " " );
strcat( m_pszCmdLine, pszValues );
}
ParseCommandLine();
return;
}
// Remove any remnants from the current Cmd Line.
RemoveParm( pszParm );
nNewLength += strlen( m_pszCmdLine ) + 1 + 1;
pCmdString = new char[ nNewLength ];
memset( pCmdString, 0, nNewLength );
strcpy ( pCmdString, m_pszCmdLine ); // Copy old command line.
strcat ( pCmdString, " " ); // Put in a space
strcat ( pCmdString, pszParm );
if ( pszValues )
{
strcat( pCmdString, " " );
strcat( pCmdString, pszValues );
}
// Kill off the old one
delete[] m_pszCmdLine;
// Point at the new command line.
m_pszCmdLine = pCmdString;
ParseCommandLine();
}
//-----------------------------------------------------------------------------
// Purpose: Return current command line
// Output : const char
//-----------------------------------------------------------------------------
const char *CCommandLine::GetCmdLine( void ) const
{
return m_pszCmdLine;
}
//-----------------------------------------------------------------------------
// Purpose: Search for the parameter in the current commandline
// Input : *psz -
// **ppszValue -
// Output : char
//-----------------------------------------------------------------------------
const char *CCommandLine::CheckParm( const char *psz, const char **ppszValue ) const
{
if ( ppszValue )
*ppszValue = NULL;
int i = FindParm( psz );
if ( i == 0 )
return NULL;
if ( ppszValue )
{
if ( (i+1) >= m_nParmCount )
{
*ppszValue = NULL;
}
else
{
*ppszValue = m_ppParms[i+1];
}
}
return m_ppParms[i];
}
//-----------------------------------------------------------------------------
// Adds an argument..
//-----------------------------------------------------------------------------
void CCommandLine::AddArgument( const char *pFirst, const char *pLast )
{
if ( pLast <= pFirst )
return;
if ( m_nParmCount >= MAX_PARAMETERS )
Error( "CCommandLine::AddArgument: exceeded %d parameters", MAX_PARAMETERS );
size_t nLen = pLast - pFirst + 1;
m_ppParms[m_nParmCount] = new char[nLen];
memcpy( m_ppParms[m_nParmCount], pFirst, nLen - 1 );
m_ppParms[m_nParmCount][nLen - 1] = 0;
++m_nParmCount;
}
//-----------------------------------------------------------------------------
// Parse command line...
//-----------------------------------------------------------------------------
void CCommandLine::ParseCommandLine()
{
CleanUpParms();
if (!m_pszCmdLine)
return;
const char *pChar = m_pszCmdLine;
while ( *pChar && isspace(*pChar) )
{
++pChar;
}
bool bInQuotes = false;
const char *pFirstLetter = NULL;
for ( ; *pChar; ++pChar )
{
if ( bInQuotes )
{
if ( *pChar != '\"' )
continue;
AddArgument( pFirstLetter, pChar );
pFirstLetter = NULL;
bInQuotes = false;
continue;
}
// Haven't started a word yet...
if ( !pFirstLetter )
{
if ( *pChar == '\"' )
{
bInQuotes = true;
pFirstLetter = pChar + 1;
continue;
}
if ( isspace( *pChar ) )
continue;
pFirstLetter = pChar;
continue;
}
// Here, we're in the middle of a word. Look for the end of it.
if ( isspace( *pChar ) )
{
AddArgument( pFirstLetter, pChar );
pFirstLetter = NULL;
}
}
if ( pFirstLetter )
{
AddArgument( pFirstLetter, pChar );
}
}
//-----------------------------------------------------------------------------
// Individual command line arguments
//-----------------------------------------------------------------------------
void CCommandLine::CleanUpParms()
{
for ( int i = 0; i < m_nParmCount; ++i )
{
delete [] m_ppParms[i];
m_ppParms[i] = NULL;
}
m_nParmCount = 0;
}
//-----------------------------------------------------------------------------
// Returns individual command line arguments
//-----------------------------------------------------------------------------
int CCommandLine::ParmCount() const
{
return m_nParmCount;
}
int CCommandLine::FindParm( const char *psz ) const
{
// Start at 1 so as to not search the exe name
for ( int i = 1; i < m_nParmCount; ++i )
{
if ( !_stricmp( psz, m_ppParms[i] ) )
return i;
}
return 0;
}
bool CCommandLine::HasParm( const char *psz ) const
{
return ( FindParm( psz ) != 0 );
}
const char* CCommandLine::GetParm( int nIndex ) const
{
Assert( (nIndex >= 0) && (nIndex < m_nParmCount) );
if ( (nIndex < 0) || (nIndex >= m_nParmCount) )
return "";
return m_ppParms[nIndex];
}
void CCommandLine::SetParm( int nIndex, char const *pParm )
{
if ( pParm )
{
Assert( (nIndex >= 0) && (nIndex < m_nParmCount) );
if ( (nIndex >= 0) && (nIndex < m_nParmCount) )
{
if ( m_ppParms[nIndex] )
delete[] m_ppParms[nIndex];
m_ppParms[nIndex] = strdup( pParm );
}
}
}
//-----------------------------------------------------------------------------
// Returns the argument after the one specified, or the default if not found
//-----------------------------------------------------------------------------
const char *CCommandLine::ParmValue( const char *psz, const char *pDefaultVal ) const
{
int nIndex = FindParm( psz );
if (( nIndex == 0 ) || (nIndex == m_nParmCount - 1))
return pDefaultVal;
// Probably another cmdline parameter instead of a valid arg if it starts with '+' or '-'
if ( m_ppParms[nIndex + 1][0] == '-' || m_ppParms[nIndex + 1][0] == '+' )
return pDefaultVal;
return m_ppParms[nIndex + 1];
}
int CCommandLine::ParmValue( const char *psz, int nDefaultVal ) const
{
int nIndex = FindParm( psz );
if (( nIndex == 0 ) || (nIndex == m_nParmCount - 1))
return nDefaultVal;
// Probably another cmdline parameter instead of a valid arg if it starts with '+' or '-'
if ( m_ppParms[nIndex + 1][0] == '-' || m_ppParms[nIndex + 1][0] == '+' )
return nDefaultVal;
return atoi( m_ppParms[nIndex + 1] );
}
float CCommandLine::ParmValue( const char *psz, float flDefaultVal ) const
{
int nIndex = FindParm( psz );
if (( nIndex == 0 ) || (nIndex == m_nParmCount - 1))
return flDefaultVal;
// Probably another cmdline parameter instead of a valid arg if it starts with '+' or '-'
if ( m_ppParms[nIndex + 1][0] == '-' || m_ppParms[nIndex + 1][0] == '+' )
return flDefaultVal;
return atof( m_ppParms[nIndex + 1] );
}
const char *CCommandLine::ParmValueByIndex( int nIndex, const char *pDefaultVal ) const
{
if (( nIndex == 0 ) || (nIndex == m_nParmCount - 1))
return pDefaultVal;
// Probably another cmdline parameter instead of a valid arg if it starts with '+' or '-'
if ( m_ppParms[nIndex + 1][0] == '-' || m_ppParms[nIndex + 1][0] == '+' )
return pDefaultVal;
return m_ppParms[nIndex + 1];
}