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
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]; |
|
} |
|
|
|
|