CUtlSymbol CUtlSymbolTable::AddString( char const* pString )
{
if (!pString)
return CUtlSymbol( UTL_INVAL_SYMBOL );
CUtlSymbol id = Find( pString );
//g_SymbolCS.Lock( );
if (id.IsValid())
{
//g_SymbolCS.Unlock( );
return id;
}
// Store a special context used to help with insertion
g_LessCtx.m_pUserString = pString;
g_LessCtx.m_pTable = this;
// didn't find, insert the string into the vector.
int len = strlen(pString) + 1;
int stridx = m_Strings.AddMultipleToTail( len );
memcpy( &m_Strings[stridx], pString, len * sizeof(char) );
UtlSymId_t idx = m_Lookup.Insert( stridx );
CUtlSymbol syRet( idx );
//g_SymbolCS.Unlock( );
return syRet;
}
//-----------------------------------------------------------------------------
// Purpose: extracts the list of configuration names from the vcproj
//-----------------------------------------------------------------------------
bool CVCProjConvert::ExtractConfigurations( IXMLDOMDocument *pDoc )
{
m_Configurations.RemoveAll();
if (!pDoc)
{
return false;
}
#ifdef _WIN32
CComPtr<IXMLDOMNodeList> pConfigs;
pDoc->getElementsByTagName( _bstr_t("Configuration"), &pConfigs);
if (pConfigs)
{
long len = 0;
pConfigs->get_length(&len);
for ( int i=0; i<len; i++ )
{
CComPtr<IXMLDOMNode> pNode;
pConfigs->get_item( i, &pNode );
if (pNode)
{
CComQIPtr<IXMLDOMElement> pElem( pNode );
CUtlSymbol configName = GetXMLAttribValue( pElem, "Name" );
if ( configName.IsValid() )
{
int newIndex = m_Configurations.AddToTail();
CConfiguration & config = m_Configurations[newIndex];
config.SetName( configName );
ExtractIncludes( pElem, config );
}
}
}
}
#elif _LINUX
DOMNodeList *nodes = pDoc->getElementsByTagName( _bstr_t("Configuration"));
if ( nodes )
{
int len = nodes->getLength();
for ( int i=0; i<len; i++ )
{
DOMNode *node = nodes->item(i);
if (node)
{
CUtlSymbol configName = GetXMLAttribValue( node, "Name" );
if ( configName.IsValid() )
{
int newIndex = m_Configurations.AddToTail();
CConfiguration & config = m_Configurations[newIndex];
config.SetName( configName );
ExtractIncludes( node, config );
}
}
}
}
#endif
return true;
}
//-----------------------------------------------------------------------------
// Purpose: mark or add
// Input : *pEntity -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CPrecacheOtherList::AddOrMarkPrecached( const char *pClassname )
{
CUtlSymbol sym = m_list.Find( pClassname );
if ( sym.IsValid() )
return false;
m_list.AddString( pClassname );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: gets the icon for a binding, if it exists
//-----------------------------------------------------------------------------
const char *CControllerMap::GetBindingIcon( int idx )
{
CUtlSymbol s = m_buttonMap[idx].icon;
if ( s.IsValid() )
{
return s.String();
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Updates the value shown in the mapcycle field
//-----------------------------------------------------------------------------
void CServerInfoPanel::UpdateMapCycleValue()
{
// look at current map
CUtlSymbol currentMap = GetVarString("map");
if (!currentMap.IsValid())
return;
// find it in the map cycle list
int listPoint = -1;
for (int i = 0; i < m_MapCycle.Count(); i++)
{
if (!stricmp(m_MapCycle[i].String(), currentMap.String()))
{
listPoint = i;
}
}
// take out the next 2 maps and make them the value
char nextMaps[512];
nextMaps[0] = 0;
bool needComma = false;
for (int i = 0; i < 2; i++)
{
int point = listPoint + i + 1;
if (point >= m_MapCycle.Count())
{
point -= m_MapCycle.Count();
}
if (m_MapCycle.IsValidIndex(point))
{
if (needComma)
{
strcat(nextMaps, ", ");
}
strcat(nextMaps, m_MapCycle[point].String());
needComma = true;
}
}
// add some elipses to show there is more maps
if (needComma)
{
strcat(nextMaps, ", ");
}
strcat(nextMaps, "...");
// show in varlist
SetVarString("mapcycle", nextMaps);
}
int CPhysicsSurfaceProps::GetSurfaceIndex(const char* pSurfacePropName) const {
if (pSurfacePropName[0] == '$') {
int index = GetReservedSurfaceIndex(pSurfacePropName);
if (index >= 0) return index;
}
CUtlSymbol id = m_strings->Find(pSurfacePropName);
if (id.IsValid()) {
for (int i = 0; i < m_props.Size(); i++) {
if (m_props[i].m_name == id) return i;
}
}
return -1;
}
int GetIndex( const char *pGlobalname )
{
CUtlSymbol symName = m_nameList.Find( pGlobalname );
if ( symName.IsValid() )
{
for ( int i = m_list.Count() - 1; i >= 0; --i )
{
if ( m_list[i].name == symName )
return i;
}
}
return -1;
}
//-----------------------------------------------------------------------------
// Purpose: walks a particular files config entry and removes an files not valid for this config
//-----------------------------------------------------------------------------
bool CVCProjConvert::IterateFileConfigurations( IXMLDOMElement *pFile, CUtlSymbol fileName )
{
#ifdef _WIN32
CComPtr<IXMLDOMNodeList> pConfigs;
pFile->getElementsByTagName( _bstr_t("FileConfiguration"), &pConfigs);
if (pConfigs)
{
long len = 0;
pConfigs->get_length(&len);
for ( int i=0; i<len; i++ )
{
CComPtr<IXMLDOMNode> pNode;
pConfigs->get_item( i, &pNode);
if (pNode)
{
CComQIPtr<IXMLDOMElement> pElem( pNode );
CUtlSymbol configName = GetXMLAttribValue( pElem, "Name");
CUtlSymbol excluded = GetXMLAttribValue( pElem ,"ExcludedFromBuild");
if ( configName.IsValid() && excluded.IsValid() )
{
int index = FindConfiguration( configName );
if ( index > 0 && excluded == "TRUE" )
{
m_Configurations[index].RemoveFile( fileName );
}
}
}
}//for
}//if
#elif _LINUX
DOMNodeList *nodes = pFile->getElementsByTagName( _bstr_t("FileConfiguration"));
if (nodes)
{
int len = nodes->getLength();
for ( int i=0; i<len; i++ )
{
DOMNode *node = nodes->item(i);
if (node)
{
CUtlSymbol configName = GetXMLAttribValue( node, "Name");
CUtlSymbol excluded = GetXMLAttribValue( node ,"ExcludedFromBuild");
if ( configName.IsValid() && excluded.IsValid() )
{
int index = FindConfiguration( configName );
if ( index >= 0 && excluded == "TRUE" )
{
m_Configurations[index].RemoveFile( fileName );
}
}
}
}//for
}//if
#endif
return true;
}
//-----------------------------------------------------------------------------
// Begin editing a particular material
//-----------------------------------------------------------------------------
void CMaterialEditorPanel::BeginEditingMaterial( const char *pMaterialName, IMaterial *pMaterial )
{
m_bMaterialDirty = false;
m_EditedMaterial = pMaterialName;
m_pTitleLabel->SetText( m_EditedMaterial.String() );
m_pMaterialViewer->SetMaterial(pMaterial);
m_pMaterial = pMaterial;
}
CUtlSymbol CUtlSymbolTable::AddString( const char* pString )
{
if (!pString)
return CUtlSymbol( UTL_INVAL_SYMBOL );
CUtlSymbol id = Find( pString );
if (id.IsValid())
return id;
int len = strlen(pString) + 1;
// Find a pool with space for this string, or allocate a new one.
int iPool = FindPoolWithSpace( len );
if ( iPool == -1 )
{
// Add a new pool.
int newPoolSize = max( len, MIN_STRING_POOL_SIZE );
StringPool_t *pPool = (StringPool_t*)malloc( sizeof( StringPool_t ) + newPoolSize - 1 );
pPool->m_TotalLen = newPoolSize;
pPool->m_SpaceUsed = 0;
iPool = m_StringPools.AddToTail( pPool );
}
// Copy the string in.
StringPool_t *pPool = m_StringPools[iPool];
Assert( pPool->m_SpaceUsed < 0xFFFF ); // This should never happen, because if we had a string > 64k, it
// would have been given its entire own pool.
unsigned short iStringOffset = pPool->m_SpaceUsed;
memcpy( &pPool->m_Data[pPool->m_SpaceUsed], pString, len );
pPool->m_SpaceUsed += len;
// didn't find, insert the string into the vector.
CStringPoolIndex index;
index.m_iPool = iPool;
index.m_iOffset = iStringOffset;
UtlSymId_t idx = m_Lookup.Insert( index );
return CUtlSymbol( idx );
}
//-----------------------------------------------------------------------------
// Purpose: returns the index of a config with this name, -1 on err
//-----------------------------------------------------------------------------
int CVCProjConvert::FindConfiguration( CUtlSymbol name )
{
if ( !name.IsValid() )
{
return -1;
}
for ( int i = 0; i < m_Configurations.Count(); i++ )
{
if ( m_Configurations[i].GetName() == name )
{
return i;
}
}
return -1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CMaterialSubRect::GetTextureGroupName() const
{
return m_symTextureGroupName.String();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CMaterialSubRect::GetName() const
{
return m_symName.String();
}
//-----------------------------------------------------------------------------
// Purpose: walks the file elements in the vcproj and inserts them into configs
//-----------------------------------------------------------------------------
bool CVCProjConvert::ExtractFiles( IXMLDOMDocument *pDoc )
{
if (!pDoc)
{
return false;
}
Assert( m_Configurations.Count() ); // some configs must be loaded first
#ifdef _WIN32
CComPtr<IXMLDOMNodeList> pFiles;
pDoc->getElementsByTagName( _bstr_t("File"), &pFiles);
if (pFiles)
{
long len = 0;
pFiles->get_length(&len);
for ( int i=0; i<len; i++ )
{
CComPtr<IXMLDOMNode> pNode;
pFiles->get_item( i, &pNode);
if (pNode)
{
CComQIPtr<IXMLDOMElement> pElem( pNode );
CUtlSymbol fileName = GetXMLAttribValue(pElem,"RelativePath");
if ( fileName.IsValid() )
{
CConfiguration::FileType_e type = GetFileType( fileName.String() );
CConfiguration::CFileEntry fileEntry( fileName.String(), type );
for ( int i = 0; i < m_Configurations.Count(); i++ ) // add the file to all configs
{
CConfiguration & config = m_Configurations[i];
config.InsertFile( fileEntry );
}
IterateFileConfigurations( pElem, fileName ); // now remove the excluded ones
}
}
}//for
}
#elif _LINUX
DOMNodeList *nodes = pDoc->getElementsByTagName( _bstr_t("File") );
if (nodes)
{
int len = nodes->getLength();
for ( int i=0; i<len; i++ )
{
DOMNode *node = nodes->item(i);
if (node)
{
CUtlSymbol fileName = GetXMLAttribValue(node,"RelativePath");
if ( fileName.IsValid() )
{
char fixedFileName[ MAX_PATH ];
Q_strncpy( fixedFileName, fileName.String(), sizeof(fixedFileName) );
if ( fixedFileName[0] == '.' && fixedFileName[1] == '\\' )
{
Q_memmove( fixedFileName, fixedFileName+2, sizeof(fixedFileName)-2 );
}
Q_FixSlashes( fixedFileName );
FindFileCaseInsensitive( fixedFileName, sizeof(fixedFileName) );
CConfiguration::FileType_e type = GetFileType( fileName.String() );
CConfiguration::CFileEntry fileEntry( fixedFileName, type );
for ( int i = 0; i < m_Configurations.Count(); i++ ) // add the file to all configs
{
CConfiguration & config = m_Configurations[i];
config.InsertFile( fileEntry );
}
IterateFileConfigurations( node, fixedFileName ); // now remove the excluded ones
}
}
}//for
}
#endif
return true;
}
//-----------------------------------------------------------------------------
// Purpose: extracts the list of defines and includes used for this config
//-----------------------------------------------------------------------------
bool CVCProjConvert::ExtractIncludes( IXMLDOMElement *pDoc, CConfiguration & config )
{
config.ResetDefines();
config.ResetIncludes();
if (!pDoc)
{
return false;
}
#ifdef _WIN32
CComPtr<IXMLDOMNodeList> pTools;
pDoc->getElementsByTagName( _bstr_t("Tool"), &pTools);
if (pTools)
{
long len = 0;
pTools->get_length(&len);
for ( int i=0; i<len; i++ )
{
CComPtr<IXMLDOMNode> pNode;
pTools->get_item( i, &pNode );
if (pNode)
{
CComQIPtr<IXMLDOMElement> pElem( pNode );
CUtlSymbol toolName = GetXMLAttribValue( pElem, "Name" );
if ( toolName == "VCCLCompilerTool" )
{
CUtlSymbol defines = GetXMLAttribValue( pElem, "PreprocessorDefinitions" );
char *str = (char *)_alloca( Q_strlen( defines.String() ) + 1 );
Assert( str );
Q_strcpy( str, defines.String() );
// now tokenize the string on the ";" char
char *delim = strchr( str, ';' );
char *curpos = str;
while ( delim )
{
*delim = 0;
delim++;
if ( Q_stricmp( curpos, "WIN32" ) && Q_stricmp( curpos, "_WIN32" ) &&
Q_stricmp( curpos, "_WINDOWS") && Q_stricmp( curpos, "WINDOWS")) // don't add WIN32 defines
{
config.AddDefine( curpos );
}
curpos = delim;
delim = strchr( delim, ';' );
}
if ( Q_stricmp( curpos, "WIN32" ) && Q_stricmp( curpos, "_WIN32" ) &&
Q_stricmp( curpos, "_WINDOWS") && Q_stricmp( curpos, "WINDOWS")) // don't add WIN32 defines
{
config.AddDefine( curpos );
}
CUtlSymbol includes = GetXMLAttribValue( pElem, "AdditionalIncludeDirectories" );
char *str2 = (char *)_alloca( Q_strlen( includes.String() ) + 1 );
Assert( str2 );
Q_strcpy( str2, includes.String() );
// now tokenize the string on the ";" char
delim = strchr( str2, ',' );
curpos = str2;
while ( delim )
{
*delim = 0;
delim++;
config.AddInclude( curpos );
curpos = delim;
delim = strchr( delim, ',' );
}
config.AddInclude( curpos );
}
}
}
}
#elif _LINUX
DOMNodeList *nodes= pDoc->getElementsByTagName( _bstr_t("Tool"));
if (nodes)
{
int len = nodes->getLength();
for ( int i=0; i<len; i++ )
{
DOMNode *node = nodes->item(i);
if (node)
{
CUtlSymbol toolName = GetXMLAttribValue( node, "Name" );
if ( toolName == "VCCLCompilerTool" )
{
CUtlSymbol defines = GetXMLAttribValue( node, "PreprocessorDefinitions" );
char *str = (char *)_alloca( Q_strlen( defines.String() ) + 1 );
Assert( str );
Q_strcpy( str, defines.String() );
// now tokenize the string on the ";" char
char *delim = strchr( str, ';' );
char *curpos = str;
while ( delim )
{
*delim = 0;
delim++;
if ( Q_stricmp( curpos, "WIN32" ) && Q_stricmp( curpos, "_WIN32" ) &&
Q_stricmp( curpos, "_WINDOWS") && Q_stricmp( curpos, "WINDOWS")) // don't add WIN32 defines
{
config.AddDefine( curpos );
}
curpos = delim;
delim = strchr( delim, ';' );
}
if ( Q_stricmp( curpos, "WIN32" ) && Q_stricmp( curpos, "_WIN32" ) &&
Q_stricmp( curpos, "_WINDOWS") && Q_stricmp( curpos, "WINDOWS")) // don't add WIN32 defines
{
config.AddDefine( curpos );
}
CUtlSymbol includes = GetXMLAttribValue( node, "AdditionalIncludeDirectories" );
char *str2 = (char *)_alloca( Q_strlen( includes.String() ) + 1 );
Assert( str2 );
Q_strcpy( str2, includes.String() );
// now tokenize the string on the ";" char
char token = ',';
delim = strchr( str2, token );
if ( !delim )
{
token = ';';
delim = strchr( str2, token );
}
curpos = str2;
while ( delim )
{
*delim = 0;
delim++;
Q_FixSlashes( curpos );
Q_strlower( curpos );
char fullPath[ MAX_PATH ];
Q_snprintf( fullPath, sizeof(fullPath), "%s/%s", m_BaseDir.String(), curpos );
Q_StripTrailingSlash( fullPath );
config.AddInclude( fullPath );
curpos = delim;
delim = strchr( delim, token );
}
Q_FixSlashes( curpos );
Q_strlower( curpos );
char fullPath[ MAX_PATH ];
Q_snprintf( fullPath, sizeof(fullPath), "%s/%s", m_BaseDir.String(), curpos );
Q_StripTrailingSlash( fullPath );
config.AddInclude( fullPath );
}
}
}
}
#endif
return true;
}
char const *CBugReporter::GetUserName()
{
return m_UserName.String();
}
