示例#1
0
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;
}
示例#2
0
//-----------------------------------------------------------------------------
// 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;
}
示例#3
0
//-----------------------------------------------------------------------------
// 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;
}
示例#4
0
//-----------------------------------------------------------------------------
// 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;
}
示例#7
0
	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;
	}
示例#8
0
//-----------------------------------------------------------------------------
// 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;
}
示例#10
0
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 );
}
示例#11
0
//-----------------------------------------------------------------------------
// 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();
}
示例#14
0
//-----------------------------------------------------------------------------
// 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;
}
示例#15
0
//-----------------------------------------------------------------------------
// 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();
}