General:

* Fixed a variety of server browser issues with mods based on this SDK
* Fixed many warnings on various platforms
* Added source code for fgdlib and raytrace
* Updated many source files with the latest shared source from TF2.

OSX:
* Added support for Xcode 4.6
* Switched OSX builds to use Xcode instead of makefiles
* Moved libs from src/lib/osx32 to src/lib/public/osx32 or src/lib/common/osx32 to match windows better.

Linux:
* Moved libs from src/lib/linux32 to src/lib/public/linux32 or src/lib/common/linux32 to match windows better.

1 files changed, 729 insertions, 0 deletions

diff --git a/sp/src/fgdlib/gdvar.cpp b/sp/src/fgdlib/gdvar.cpp
new file mode 100644
index 00000000..5b9a21be
--- /dev/null
+++ b/sp/src/fgdlib/gdvar.cpp
@@ -0,0 +1,729 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+//=============================================================================

+

+#include "fgdlib/fgdlib.h"

+#include "fgdlib/GameData.h"

+#include "fgdlib/WCKeyValues.h"

+#include "fgdlib/gdvar.h"

+

+// memdbgon must be the last include file in a .cpp file!!!

+#include <tier0/memdbgon.h>

+

+

+typedef struct

+{

+	GDIV_TYPE eType;		// The enumeration of this type.

+	char *pszName;			// The name of this type.

+	trtoken_t eStoreAs;		// How this type is stored (STRING, INTEGER, etc).

+} TypeMap_t;

+

+

+//-----------------------------------------------------------------------------

+// Maps type names to type enums and parsing logic for values.

+//-----------------------------------------------------------------------------

+static TypeMap_t TypeMap[] =

+{

+	{ ivAngle,				"angle",				STRING },

+	{ ivChoices,			"choices",				STRING },

+	{ ivColor1,				"color1",				STRING },

+	{ ivColor255,			"color255",				STRING },

+	{ ivDecal,				"decal",				STRING },

+	{ ivFlags,				"flags",				INTEGER },

+	{ ivInteger,			"integer",				INTEGER },

+	{ ivSound,				"sound",				STRING },

+	{ ivSprite,				"sprite",				STRING },

+	{ ivString,				"string",				STRING },

+	{ ivStudioModel,		"studio",				STRING },

+	{ ivTargetDest,			"target_destination",	STRING },

+	{ ivTargetSrc,			"target_source",		STRING },

+	{ ivTargetNameOrClass,	"target_name_or_class",	STRING },	// Another version of target_destination that accepts class names

+	{ ivVector,				"vector",				STRING },

+	{ ivNPCClass,			"npcclass",				STRING },

+	{ ivFilterClass,		"filterclass",			STRING },

+	{ ivFloat,				"float",				STRING },

+	{ ivMaterial,			"material",				STRING },

+	{ ivScene,				"scene",				STRING },

+	{ ivSide,				"side",					STRING },

+	{ ivSideList,			"sidelist",				STRING },

+	{ ivOrigin,				"origin",				STRING },

+	{ ivAxis,				"axis",					STRING },

+	{ ivVecLine,			"vecline",				STRING },

+	{ ivPointEntityClass,	"pointentityclass",		STRING },

+	{ ivNodeDest,			"node_dest",			INTEGER },

+	{ ivInstanceFile,		"instance_file",		STRING },

+	{ ivAngleNegativePitch,	"angle_negative_pitch",	STRING },

+	{ ivInstanceVariable,	"instance_variable",	STRING },

+	{ ivInstanceParm,		"instance_parm",		STRING },

+};

+

+

+char *GDinputvariable::m_pszEmpty = "";

+

+

+//-----------------------------------------------------------------------------

+//-----------------------------------------------------------------------------

+GDinputvariable::GDinputvariable(void)

+{

+	m_szDefault[0] = 0;

+	m_nDefault = 0;

+	m_szValue[0] = 0;

+	m_bReportable = FALSE;

+	m_bReadOnly = false;

+	m_pszDescription = NULL;

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: construct generally used for creating a temp instance parm type

+// Input  : szType - the textual type of this variable

+//			szName - the name description of this variable

+//-----------------------------------------------------------------------------

+GDinputvariable::GDinputvariable( const char *szType, const char *szName )

+{

+	m_szDefault[0] = 0;

+	m_nDefault = 0;

+	m_szValue[0] = 0;

+	m_bReportable = FALSE;

+	m_bReadOnly = false;

+	m_pszDescription = NULL;

+

+	m_eType = GetTypeFromToken( szType );

+	strcpy( m_szName, szName );

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Destructor.

+//-----------------------------------------------------------------------------

+GDinputvariable::~GDinputvariable(void)

+{

+	delete [] m_pszDescription;

+	m_Items.RemoveAll();

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Implements the copy operator.

+//-----------------------------------------------------------------------------

+GDinputvariable &GDinputvariable::operator =(GDinputvariable &Other)

+{

+	m_eType = Other.GetType();

+	strcpy(m_szName, Other.m_szName);

+	strcpy(m_szLongName, Other.m_szLongName);

+	strcpy(m_szDefault, Other.m_szDefault);

+

+	//

+	// Copy the description.

+	//

+	delete [] m_pszDescription;

+	if (Other.m_pszDescription != NULL)

+	{

+		m_pszDescription = new char[strlen(Other.m_pszDescription) + 1];

+		strcpy(m_pszDescription, Other.m_pszDescription);

+	}

+	else

+	{

+		m_pszDescription = NULL;

+	}

+

+	m_nDefault = Other.m_nDefault;

+	m_bReportable = Other.m_bReportable;

+	m_bReadOnly = Other.m_bReadOnly;

+

+	m_Items.RemoveAll();

+	

+	int nCount = Other.m_Items.Count();

+	for (int i = 0; i < nCount; i++)

+	{

+		m_Items.AddToTail(Other.m_Items.Element(i));

+	}

+

+	return(*this);

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Returns the storage format of a given variable type.

+// Input  : pszToken - Sting containing the token.

+// Output : GDIV_TYPE corresponding to the token in the string, ivBadType if the

+//			string does not correspond to a valid type.

+//-----------------------------------------------------------------------------

+trtoken_t GDinputvariable::GetStoreAsFromType(GDIV_TYPE eType)

+{

+	for (int i = 0; i < sizeof(TypeMap) / sizeof(TypeMap[0]); i++)

+	{

+		if (TypeMap[i].eType == eType)

+		{

+			return(TypeMap[i].eStoreAs);

+		}

+	}

+

+	Assert(FALSE);

+	return(STRING);

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Returns the enumerated type of a string token.

+// Input  : pszToken - Sting containing the token.

+// Output : GDIV_TYPE corresponding to the token in the string, ivBadType if the

+//			string does not correspond to a valid type.

+//-----------------------------------------------------------------------------

+GDIV_TYPE GDinputvariable::GetTypeFromToken(const char *pszToken)

+{

+	for (int i = 0; i < sizeof(TypeMap) / sizeof(TypeMap[0]); i++)

+	{

+		if (IsToken(pszToken, TypeMap[i].pszName))

+		{

+			return(TypeMap[i].eType);

+		}

+	}

+

+	return(ivBadType);

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Returns a string representing the type of this variable, eg. "integer".

+//-----------------------------------------------------------------------------

+const char *GDinputvariable::GetTypeText(void)

+{

+	for (int i = 0; i < sizeof(TypeMap) / sizeof(TypeMap[0]); i++)

+	{

+		if (TypeMap[i].eType == m_eType)

+		{

+			return(TypeMap[i].pszName);

+		}

+	}

+

+	return("unknown");

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+// Input  : tr - 

+// Output : Returns TRUE on success, FALSE on failure.

+//-----------------------------------------------------------------------------

+BOOL GDinputvariable::InitFromTokens(TokenReader& tr)

+{

+	char szToken[128];

+

+	if (!GDGetToken(tr, m_szName, sizeof(m_szName), IDENT))

+	{

+		return FALSE;

+	}

+

+	if (!GDSkipToken(tr, OPERATOR, "("))

+	{

+		return FALSE;

+	}

+

+	// check for "reportable" marker

+	trtoken_t ttype = tr.NextToken(szToken, sizeof(szToken));

+	if (ttype == OPERATOR)

+	{

+		if (!strcmp(szToken, "*"))

+		{

+			m_bReportable = true;

+		}

+	}

+	else

+	{

+		tr.Stuff(ttype, szToken);

+	}

+

+	// get type

+	if (!GDGetToken(tr, szToken, sizeof(szToken), IDENT))

+	{

+		return FALSE;

+	}

+

+	if (!GDSkipToken(tr, OPERATOR, ")"))

+	{

+		return FALSE;

+	}

+

+	//

+	// Check for known variable types.

+	//

+	m_eType = GetTypeFromToken(szToken);

+	if (m_eType == ivBadType)

+	{

+		GDError(tr, "'%s' is not a valid variable type", szToken);

+		return FALSE;

+	}

+

+	//

+	// Look ahead at the next token.

+	//

+	ttype = tr.PeekTokenType(szToken,sizeof(szToken));

+

+	//

+	// Check for the "readonly" specifier.

+	//

+	if ((ttype == IDENT) && IsToken(szToken, "readonly"))

+	{

+		tr.NextToken(szToken, sizeof(szToken));

+		m_bReadOnly = true;

+

+		//

+		// Look ahead at the next token.

+		//

+		ttype = tr.PeekTokenType(szToken,sizeof(szToken));

+	}

+

+	//

+	// Check for the ':' indicating a long name.

+	//

+	if (ttype == OPERATOR && IsToken(szToken, ":"))

+	{

+		//

+		// Eat the ':'.

+		//

+		tr.NextToken(szToken, sizeof(szToken));

+

+		if (m_eType == ivFlags)

+		{

+			GDError(tr, "flag sets do not have long names");

+			return FALSE;

+		}

+

+		//

+		// Get the long name.

+		//

+		if (!GDGetToken(tr, m_szLongName, sizeof(m_szLongName), STRING))

+		{

+			return(FALSE);

+		}

+

+		//

+		// Look ahead at the next token.

+		//

+		ttype = tr.PeekTokenType(szToken,sizeof(szToken));

+

+		//

+		// Check for the ':' indicating a default value.

+		//

+		if (ttype == OPERATOR && IsToken(szToken, ":"))

+		{

+			//

+			// Eat the ':'.

+			//

+			tr.NextToken(szToken, sizeof(szToken));

+

+			//

+			// Look ahead at the next token.

+			//

+			ttype = tr.PeekTokenType(szToken,sizeof(szToken));

+			if (ttype == OPERATOR && IsToken(szToken, ":"))

+			{

+				//

+				// No default value provided, skip to the description.

+				//

+			}

+			else

+			{

+				//

+				// Determine how to parse the default value. If this is a choices field, the

+				// default could either be a string or an integer, so we must look ahead and

+				// use whichever is there.

+				//

+				trtoken_t eStoreAs = GetStoreAsFromType(m_eType);

+

+				if (eStoreAs == STRING)

+				{

+					if (!GDGetToken(tr, m_szDefault, sizeof(m_szDefault), STRING))

+					{

+						return(FALSE);

+					}

+				}

+				else if (eStoreAs == INTEGER)

+				{

+					if (!GDGetToken(tr, szToken, sizeof(szToken), INTEGER))

+					{

+						return(FALSE);

+					}

+

+					m_nDefault = atoi(szToken);

+				}

+

+				//

+				// Look ahead at the next token.

+				//

+				ttype = tr.PeekTokenType(szToken,sizeof(szToken));

+			}

+		}

+

+		//

+		// Check for the ':' indicating a description.

+		//

+		if (ttype == OPERATOR && IsToken(szToken, ":"))

+		{

+			//

+			// Eat the ':'.

+			//

+			tr.NextToken(szToken, sizeof(szToken));

+

+			//

+			// Read the description.

+			//

+

+			// If we've already read a description then free it to avoid memory leaks.

+			if ( m_pszDescription )

+			{

+				delete [] m_pszDescription;

+				m_pszDescription = NULL;

+			}

+			if (!GDGetTokenDynamic(tr, &m_pszDescription, STRING))

+			{

+				return(FALSE);

+			}

+

+			//

+			// Look ahead at the next token.

+			//

+			ttype = tr.PeekTokenType(szToken,sizeof(szToken));

+		}

+	}

+	else

+	{

+		//

+		// Default long name is short name.

+		//

+		strcpy(m_szLongName, m_szName);

+	}

+

+	//

+	// Check for the ']' indicating the end of the class definition.

+	//

+	if ((ttype == OPERATOR && IsToken(szToken, "]")) ||	ttype != OPERATOR)

+	{

+		if (m_eType == ivFlags || m_eType == ivChoices)

+		{

+			//

+			// Can't define a flags or choices variable without providing any flags or choices.

+			//

+			GDError(tr, "no %s specified", m_eType == ivFlags ? "flags" : "choices");

+			return(FALSE);

+		}

+		return(TRUE);

+	}

+

+	if (!GDSkipToken(tr, OPERATOR, "="))

+	{

+		return(FALSE);

+	}

+

+	if (m_eType != ivFlags && m_eType != ivChoices)

+	{

+		GDError(tr, "didn't expect '=' here");

+		return(FALSE);

+	}

+

+	// should be '[' to start flags/choices

+	if (!GDSkipToken(tr, OPERATOR, "["))

+	{

+		return(FALSE);

+	}

+

+	// get flags?

+	if (m_eType == ivFlags)

+	{

+		GDIVITEM ivi;

+

+		while (1)

+		{

+			ttype = tr.PeekTokenType();

+			if (ttype != INTEGER)

+			{

+				break;

+			}

+

+			// store bitflag value

+			GDGetToken(tr, szToken, sizeof(szToken), INTEGER);

+			sscanf( szToken, "%lu", &ivi.iValue );

+

+			// colon..

+			if (!GDSkipToken(tr, OPERATOR, ":"))

+			{

+				return FALSE;

+			}

+

+			// get description

+			if (!GDGetToken(tr, szToken, sizeof(szToken), STRING))

+			{

+				return FALSE;

+			}

+			strcpy(ivi.szCaption, szToken);

+

+			// colon..

+			if (!GDSkipToken(tr, OPERATOR, ":"))

+			{

+				return FALSE;

+			}

+

+			// get default setting

+			if (!GDGetToken(tr, szToken, sizeof(szToken), INTEGER))

+			{

+				return FALSE;

+			}

+			ivi.bDefault = atoi(szToken) ? TRUE : FALSE;

+

+			// add item to array of items

+			m_Items.AddToTail(ivi);

+		}

+		

+		// Set the default value.

+		unsigned long nDefault = 0;

+		for (int i = 0; i < m_Items.Count(); i++)

+		{

+			if (m_Items[i].bDefault)

+				nDefault |= m_Items[i].iValue;

+		}

+		m_nDefault = (int)nDefault;

+		Q_snprintf( m_szDefault, sizeof( m_szDefault ), "%d", m_nDefault );

+	}

+	else if (m_eType == ivChoices)

+	{

+		GDIVITEM ivi;

+

+		while (1)

+		{

+			ttype = tr.PeekTokenType();

+			if ((ttype != INTEGER) && (ttype != STRING))

+			{

+				break;

+			}

+

+			// store choice value

+			GDGetToken(tr, szToken, sizeof(szToken), ttype);

+			ivi.iValue = 0;

+			strcpy(ivi.szValue, szToken);

+

+			// colon

+			if (!GDSkipToken(tr, OPERATOR, ":"))

+			{

+				return FALSE;

+			}

+

+			// get description

+			if (!GDGetToken(tr, szToken, sizeof(szToken), STRING))

+			{

+				return FALSE;

+			}

+

+			strcpy(ivi.szCaption, szToken);

+

+			m_Items.AddToTail(ivi);

+		}

+	}

+

+	if (!GDSkipToken(tr, OPERATOR, "]"))

+	{

+		return FALSE;

+	}

+

+	return TRUE;

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Decodes a key value from a string.

+// Input  : pkv - Pointer to the key value object containing string encoded value.

+//-----------------------------------------------------------------------------

+void GDinputvariable::FromKeyValue(MDkeyvalue *pkv)

+{

+	trtoken_t eStoreAs = GetStoreAsFromType(m_eType);

+

+	if (eStoreAs == STRING)

+	{

+		strcpy(m_szValue, pkv->szValue);

+	}

+	else if (eStoreAs == INTEGER)

+	{

+		m_nValue = atoi(pkv->szValue);

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Determines whether the given flag is set (assuming this is an ivFlags).

+// Input  : uCheck - Flag to check.

+// Output : Returns TRUE if flag is set, FALSE if not.

+//-----------------------------------------------------------------------------

+BOOL GDinputvariable::IsFlagSet(unsigned int uCheck)

+{

+	Assert(m_eType == ivFlags);

+	return (((unsigned int)m_nValue & uCheck) == uCheck) ? TRUE : FALSE;

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Combines the flags or choices items from another variable into our

+//			list of flags or choices. Ours take priority if collisions occur.

+// Input  : Other - The variable whose items are being merged with ours.

+//-----------------------------------------------------------------------------

+void GDinputvariable::Merge(GDinputvariable &Other)

+{

+	//

+	// Only valid if we are of the same type.

+	//

+	if (Other.GetType() != GetType())

+	{

+		return;

+	}

+

+	//

+	// Add Other's items to this ONLY if there is no same-value entry

+	// for a specific item.

+	//

+	bool bFound = false;

+	int nOurItems = m_Items.Count();

+	for (int i = 0; i < Other.m_Items.Count(); i++)

+	{

+		GDIVITEM &TheirItem = Other.m_Items[i];

+		for (int j = 0; j < nOurItems; j++)

+		{

+			GDIVITEM &OurItem = m_Items[j];

+			if (TheirItem.iValue == OurItem.iValue)

+			{

+				bFound = true;

+				break;

+			}

+		}

+

+		if (!bFound)

+		{

+			//

+			// Not found in our list - add their item to our list.

+			//

+			m_Items.AddToTail(TheirItem);

+		}

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Determines whether the given flag is set (assuming this is an ivFlags).

+// Input  : uFlags - Flags to set.

+//			bSet - TRUE to set the flags, FALSE to clear them.

+//-----------------------------------------------------------------------------

+void GDinputvariable::SetFlag(unsigned int uFlags, BOOL bSet)

+{

+	Assert(m_eType == ivFlags);

+	if (bSet)

+	{

+		m_nValue |= uFlags;

+	}

+	else

+	{

+		m_nValue &= ~uFlags;

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Sets this keyvalue to its default value.

+//-----------------------------------------------------------------------------

+void GDinputvariable::ResetDefaults(void)

+{

+	if (m_eType == ivFlags)

+	{

+		m_nValue = 0;

+

+		//

+		// Run thru flags and set any default flags.

+		//

+		int nCount = m_Items.Count();

+		for (int i = 0; i < nCount; i++)

+		{

+			if (m_Items[i].bDefault)

+			{

+				m_nValue |= GetFlagMask(i);

+			}

+		}

+	}

+	else

+	{

+		m_nValue = m_nDefault;

+		strcpy(m_szValue, m_szDefault);

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Encodes a key value as a string.

+// Input  : pkv - Pointer to the key value object to receive the encoded string.

+//-----------------------------------------------------------------------------

+void GDinputvariable::ToKeyValue(MDkeyvalue *pkv)

+{

+	strcpy(pkv->szKey, m_szName);

+

+	trtoken_t eStoreAs = GetStoreAsFromType(m_eType);

+

+	if (eStoreAs == STRING)

+	{

+		strcpy(pkv->szValue, m_szValue);

+	}

+	else if (eStoreAs == INTEGER)

+	{

+		itoa(m_nValue, pkv->szValue, 10);

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Returns the description string that corresponds to a value string

+//			for a choices list.

+// Input  : pszString - The choices value string.

+// Output : Returns the description string.

+//-----------------------------------------------------------------------------

+const char *GDinputvariable::ItemStringForValue(const char *szValue)

+{

+	int nCount = m_Items.Count();

+	for (int i = 0; i < nCount; i++)

+	{

+		if (!stricmp(m_Items[i].szValue, szValue))

+		{

+			return(m_Items[i].szCaption);

+		}

+	}

+

+	return(NULL);

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Returns the value string that corresponds to a description string

+//			for a choices list.

+// Input  : pszString - The choices description string.

+// Output : Returns the value string.

+//-----------------------------------------------------------------------------

+const char *GDinputvariable::ItemValueForString(const char *szString)

+{

+	int nCount = m_Items.Count();

+	for (int i = 0; i < nCount; i++)

+	{

+		if (!strcmpi(m_Items[i].szCaption, szString))

+		{

+			return(m_Items[i].szValue);

+		}

+	}

+

+	return(NULL);

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: this function will let you iterate through the text names of the variable types

+// Input  : eType - the type to get the text of

+// Output : returns the textual name

+//-----------------------------------------------------------------------------

+const char *GDinputvariable::GetVarTypeName( GDIV_TYPE eType )

+{

+	return TypeMap[ eType ].pszName;

+}

+

+