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.
1442 lines
42 KiB
1442 lines
42 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
//============================================================================= |
|
|
|
#include "dmxloader/dmxelement.h" |
|
#include <ctype.h> |
|
#include "tier1/utlbuffer.h" |
|
#include "tier1/utlbufferutil.h" |
|
#include <limits.h> |
|
#include "dmxserializationdictionary.h" |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Forward declarations |
|
//----------------------------------------------------------------------------- |
|
class CUtlBuffer; |
|
extern const char *g_pAttributeTypeName[AT_TYPE_COUNT]; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// a simple class to keep track of a stack of valid parsed symbols |
|
//----------------------------------------------------------------------------- |
|
class CDmxKeyValues2ErrorStack |
|
{ |
|
public: |
|
CDmxKeyValues2ErrorStack(); |
|
|
|
// Sets the filename to report with errors; sets the line number to 0 |
|
void SetFilename( const char *pFilename ); |
|
|
|
// Current line control |
|
void IncrementCurrentLine(); |
|
void SetCurrentLine( int nLine ); |
|
int GetCurrentLine() const; |
|
|
|
// entering a new keyvalues block, save state for errors |
|
// Not save symbols instead of pointers because the pointers can move! |
|
int Push( CUtlSymbol symName ); |
|
|
|
// exiting block, error isn't in this block, remove. |
|
void Pop(); |
|
|
|
// Allows you to keep the same stack level, but change the name as you parse peers |
|
void Reset( int stackLevel, CUtlSymbol symName ); |
|
|
|
// Hit an error, report it and the parsing stack for context |
|
void ReportError( const char *pError, ... ); |
|
|
|
static CUtlSymbolTable& GetSymbolTable() { return m_ErrorSymbolTable; } |
|
|
|
private: |
|
enum |
|
{ |
|
MAX_ERROR_STACK = 64 |
|
}; |
|
|
|
CUtlSymbol m_errorStack[MAX_ERROR_STACK]; |
|
const char *m_pFilename; |
|
int m_nFileLine; |
|
int m_errorIndex; |
|
int m_maxErrorIndex; |
|
|
|
static CUtlSymbolTable m_ErrorSymbolTable; |
|
}; |
|
|
|
|
|
CUtlSymbolTable CDmxKeyValues2ErrorStack::m_ErrorSymbolTable; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Singleton instance |
|
//----------------------------------------------------------------------------- |
|
static CDmxKeyValues2ErrorStack g_KeyValues2ErrorStack; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Constructor |
|
//----------------------------------------------------------------------------- |
|
CDmxKeyValues2ErrorStack::CDmxKeyValues2ErrorStack() : |
|
m_pFilename("NULL"), m_errorIndex(0), m_maxErrorIndex(0), m_nFileLine(1) |
|
{ |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Sets the filename |
|
//----------------------------------------------------------------------------- |
|
void CDmxKeyValues2ErrorStack::SetFilename( const char *pFilename ) |
|
{ |
|
m_pFilename = pFilename; |
|
m_maxErrorIndex = 0; |
|
m_nFileLine = 1; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Current line control |
|
//----------------------------------------------------------------------------- |
|
void CDmxKeyValues2ErrorStack::IncrementCurrentLine() |
|
{ |
|
++m_nFileLine; |
|
} |
|
|
|
void CDmxKeyValues2ErrorStack::SetCurrentLine( int nLine ) |
|
{ |
|
m_nFileLine = nLine; |
|
} |
|
|
|
int CDmxKeyValues2ErrorStack::GetCurrentLine() const |
|
{ |
|
return m_nFileLine; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// entering a new keyvalues block, save state for errors |
|
// Not save symbols instead of pointers because the pointers can move! |
|
//----------------------------------------------------------------------------- |
|
int CDmxKeyValues2ErrorStack::Push( CUtlSymbol symName ) |
|
{ |
|
if ( m_errorIndex < MAX_ERROR_STACK ) |
|
{ |
|
m_errorStack[m_errorIndex] = symName; |
|
} |
|
m_errorIndex++; |
|
m_maxErrorIndex = max( m_maxErrorIndex, (m_errorIndex-1) ); |
|
return m_errorIndex-1; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// exiting block, error isn't in this block, remove. |
|
//----------------------------------------------------------------------------- |
|
void CDmxKeyValues2ErrorStack::Pop() |
|
{ |
|
m_errorIndex--; |
|
Assert(m_errorIndex>=0); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Allows you to keep the same stack level, but change the name as you parse peers |
|
//----------------------------------------------------------------------------- |
|
void CDmxKeyValues2ErrorStack::Reset( int stackLevel, CUtlSymbol symName ) |
|
{ |
|
Assert( stackLevel >= 0 && stackLevel < m_errorIndex ); |
|
m_errorStack[stackLevel] = symName; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Hit an error, report it and the parsing stack for context |
|
//----------------------------------------------------------------------------- |
|
void CDmxKeyValues2ErrorStack::ReportError( const char *pFmt, ... ) |
|
{ |
|
char temp[2048]; |
|
|
|
va_list args; |
|
va_start( args, pFmt ); |
|
Q_vsnprintf( temp, sizeof( temp ), pFmt, args ); |
|
va_end( args ); |
|
|
|
Warning( "%s(%d) : %s\n", m_pFilename, m_nFileLine, temp ); |
|
|
|
for ( int i = 0; i < m_maxErrorIndex; i++ ) |
|
{ |
|
if ( !m_errorStack[i].IsValid() ) |
|
continue; |
|
|
|
if ( i < m_errorIndex ) |
|
{ |
|
Warning( "%s, ", GetSymbolTable().String( m_errorStack[i] ) ); |
|
} |
|
else |
|
{ |
|
Warning( "(*%s*), ", GetSymbolTable().String( m_errorStack[i] ) ); |
|
} |
|
} |
|
Warning( "\n" ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// a simple helper that creates stack entries as it goes in & out of scope |
|
//----------------------------------------------------------------------------- |
|
class CKeyValues2ErrorContext |
|
{ |
|
public: |
|
CKeyValues2ErrorContext( const char *pSymName ) |
|
{ |
|
Init( CDmxKeyValues2ErrorStack::GetSymbolTable().AddString( pSymName ) ); |
|
} |
|
|
|
CKeyValues2ErrorContext( CUtlSymbol symName ) |
|
{ |
|
Init( symName ); |
|
} |
|
|
|
~CKeyValues2ErrorContext() |
|
{ |
|
g_KeyValues2ErrorStack.Pop(); |
|
} |
|
|
|
void Reset( CUtlSymbol symName ) |
|
{ |
|
g_KeyValues2ErrorStack.Reset( m_stackLevel, symName ); |
|
} |
|
|
|
private: |
|
void Init( CUtlSymbol symName ) |
|
{ |
|
m_stackLevel = g_KeyValues2ErrorStack.Push( symName ); |
|
} |
|
|
|
int m_stackLevel; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Element dictionary used in unserialization |
|
//----------------------------------------------------------------------------- |
|
typedef int DmxElementDictHandle_t; |
|
enum |
|
{ |
|
ELEMENT_DICT_HANDLE_INVALID = (DmxElementDictHandle_t)~0 |
|
}; |
|
|
|
|
|
class CDmxElementDictionary |
|
{ |
|
public: |
|
CDmxElementDictionary(); |
|
|
|
DmxElementDictHandle_t InsertElement( CDmxElement *pElement ); |
|
CDmxElement *GetElement( DmxElementDictHandle_t handle ); |
|
void AddAttribute( CDmxAttribute *pAttribute, const DmObjectId_t &pElementId ); |
|
void AddArrayAttribute( CDmxAttribute *pAttribute, DmxElementDictHandle_t hChild ); |
|
void AddArrayAttribute( CDmxAttribute *pAttribute, const DmObjectId_t &pElementId ); |
|
|
|
// Finds an element into the table |
|
DmxElementDictHandle_t FindElement( CDmxElement *pElement ); |
|
DmxElementDictHandle_t FindElement( const DmObjectId_t &objectId ); |
|
|
|
// Sets the element id for an element |
|
void SetElementId( DmxElementDictHandle_t hElement, const DmObjectId_t &objectId ); |
|
|
|
// Hook up all element references (which were unserialized as object ids) |
|
void HookUpElementReferences(); |
|
|
|
// Clears the dictionary |
|
void Clear(); |
|
|
|
// iteration through elements |
|
DmxElementDictHandle_t FirstElement() { return 0; } |
|
DmxElementDictHandle_t NextElement( DmxElementDictHandle_t h ) |
|
{ |
|
return m_Dict.IsValidIndex( h+1 ) ? h+1 : ELEMENT_DICT_HANDLE_INVALID; |
|
} |
|
|
|
private: |
|
struct DictInfo_t |
|
{ |
|
CDmxElement *m_pElement; |
|
DmObjectId_t m_Id; |
|
}; |
|
|
|
struct AttributeInfo_t |
|
{ |
|
CDmxAttribute *m_pAttribute; |
|
DmAttributeType_t m_nType; // AT_ELEMENT or AT_OBJECTID |
|
union |
|
{ |
|
DmxElementDictHandle_t m_hElement; |
|
DmObjectId_t m_ObjectId; |
|
}; |
|
}; |
|
typedef CUtlVector<AttributeInfo_t> AttributeList_t; |
|
|
|
// Hook up all element references (which were unserialized as object ids) |
|
void HookUpElementAttributes(); |
|
void HookUpElementArrayAttributes(); |
|
|
|
CUtlVector< DictInfo_t > m_Dict; |
|
AttributeList_t m_Attributes; |
|
AttributeList_t m_ArrayAttributes; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Constructor |
|
//----------------------------------------------------------------------------- |
|
CDmxElementDictionary::CDmxElementDictionary() |
|
{ |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Clears the dictionary |
|
//----------------------------------------------------------------------------- |
|
void CDmxElementDictionary::Clear() |
|
{ |
|
m_Dict.Purge(); |
|
m_Attributes.Purge(); |
|
m_ArrayAttributes.Purge(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Inserts an element into the table |
|
//----------------------------------------------------------------------------- |
|
DmxElementDictHandle_t CDmxElementDictionary::InsertElement( CDmxElement *pElement ) |
|
{ |
|
// Insert it into the reconnection table |
|
DmxElementDictHandle_t h = m_Dict.AddToTail( ); |
|
m_Dict[h].m_pElement = pElement; |
|
InvalidateUniqueId( &m_Dict[h].m_Id ); |
|
return h; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Sets the element id for an element |
|
//----------------------------------------------------------------------------- |
|
void CDmxElementDictionary::SetElementId( DmxElementDictHandle_t hElement, const DmObjectId_t &objectId ) |
|
{ |
|
Assert( hElement != ELEMENT_DICT_HANDLE_INVALID ); |
|
CopyUniqueId( objectId, &m_Dict[hElement].m_Id ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns a particular element |
|
//----------------------------------------------------------------------------- |
|
CDmxElement *CDmxElementDictionary::GetElement( DmxElementDictHandle_t handle ) |
|
{ |
|
if ( handle == ELEMENT_DICT_HANDLE_INVALID ) |
|
return NULL; |
|
|
|
return m_Dict[ handle ].m_pElement; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Adds an attribute to the fixup list |
|
//----------------------------------------------------------------------------- |
|
void CDmxElementDictionary::AddAttribute( CDmxAttribute *pAttribute, const DmObjectId_t &objectId ) |
|
{ |
|
int i = m_Attributes.AddToTail(); |
|
m_Attributes[i].m_nType = AT_OBJECTID; |
|
m_Attributes[i].m_pAttribute = pAttribute; |
|
CopyUniqueId( objectId, &m_Attributes[i].m_ObjectId ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Adds an element of an attribute array to the fixup list |
|
//----------------------------------------------------------------------------- |
|
void CDmxElementDictionary::AddArrayAttribute( CDmxAttribute *pAttribute, DmxElementDictHandle_t hElement ) |
|
{ |
|
int i = m_ArrayAttributes.AddToTail(); |
|
m_ArrayAttributes[i].m_nType = AT_ELEMENT; |
|
m_ArrayAttributes[i].m_pAttribute = pAttribute; |
|
m_ArrayAttributes[i].m_hElement = hElement; |
|
} |
|
|
|
void CDmxElementDictionary::AddArrayAttribute( CDmxAttribute *pAttribute, const DmObjectId_t &objectId ) |
|
{ |
|
int i = m_ArrayAttributes.AddToTail(); |
|
m_ArrayAttributes[i].m_nType = AT_OBJECTID; |
|
m_ArrayAttributes[i].m_pAttribute = pAttribute; |
|
CopyUniqueId( objectId, &m_ArrayAttributes[i].m_ObjectId ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Finds an element into the table |
|
//----------------------------------------------------------------------------- |
|
DmxElementDictHandle_t CDmxElementDictionary::FindElement( CDmxElement *pElement ) |
|
{ |
|
int nCount = m_Dict.Count(); |
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
if ( pElement == m_Dict[i].m_pElement ) |
|
return i; |
|
} |
|
return ELEMENT_DICT_HANDLE_INVALID; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Finds an element into the table |
|
//----------------------------------------------------------------------------- |
|
DmxElementDictHandle_t CDmxElementDictionary::FindElement( const DmObjectId_t &objectId ) |
|
{ |
|
int nCount = m_Dict.Count(); |
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
if ( IsUniqueIdEqual( objectId, m_Dict[i].m_Id ) ) |
|
return i; |
|
} |
|
return ELEMENT_DICT_HANDLE_INVALID; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Hook up all element references (which were unserialized as object ids) |
|
//----------------------------------------------------------------------------- |
|
void CDmxElementDictionary::HookUpElementAttributes() |
|
{ |
|
int n = m_Attributes.Count(); |
|
for ( int i = 0; i < n; ++i ) |
|
{ |
|
Assert( m_Attributes[i].m_nType == AT_OBJECTID ); |
|
|
|
DmxElementDictHandle_t hElement = FindElement( m_Attributes[i].m_ObjectId ); |
|
CDmxElement *pElement = GetElement( hElement ); |
|
m_Attributes[i].m_pAttribute->SetValue( pElement ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Hook up all element array references |
|
//----------------------------------------------------------------------------- |
|
void CDmxElementDictionary::HookUpElementArrayAttributes() |
|
{ |
|
int n = m_ArrayAttributes.Count(); |
|
for ( int i = 0; i < n; ++i ) |
|
{ |
|
CUtlVector< CDmxElement* > &array = m_ArrayAttributes[i].m_pAttribute->GetArrayForEdit<CDmxElement*>(); |
|
|
|
if ( m_ArrayAttributes[i].m_nType == AT_ELEMENT ) |
|
{ |
|
CDmxElement *pElement = GetElement( m_ArrayAttributes[i].m_hElement ); |
|
array.AddToTail( pElement ); |
|
} |
|
else |
|
{ |
|
// search id->handle table (both loaded and unloaded) for id, and if not found, create a new handle, map it to the id and return it |
|
DmxElementDictHandle_t hElement = FindElement( m_ArrayAttributes[i].m_ObjectId ); |
|
CDmxElement *pElement = GetElement( hElement ); |
|
array.AddToTail( pElement ); |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Hook up all element references (which were unserialized as object ids) |
|
//----------------------------------------------------------------------------- |
|
void CDmxElementDictionary::HookUpElementReferences() |
|
{ |
|
HookUpElementArrayAttributes(); |
|
HookUpElementAttributes(); |
|
} |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Unserialization class for Key Values 2 |
|
//----------------------------------------------------------------------------- |
|
class CDmxSerializerKeyValues2 |
|
{ |
|
public: |
|
bool Unserialize( const char *pFileName, CUtlBuffer &buf, CDmxElement **ppRoot ); |
|
bool Serialize( CUtlBuffer &buf, CDmxElement *pRoot, const char *pFileName ); |
|
|
|
private: |
|
enum TokenType_t |
|
{ |
|
TOKEN_INVALID = -1, // A bogus token |
|
TOKEN_OPEN_BRACE, // { |
|
TOKEN_CLOSE_BRACE, // } |
|
TOKEN_OPEN_BRACKET, // [ |
|
TOKEN_CLOSE_BRACKET, // ] |
|
TOKEN_COMMA, // , |
|
// TOKEN_STRING, // Any non-quoted string |
|
TOKEN_DELIMITED_STRING, // Any quoted string |
|
TOKEN_INCLUDE, // #include |
|
TOKEN_EOF, // End of buffer |
|
}; |
|
|
|
// Methods related to unserialization |
|
void EatWhitespacesAndComments( CUtlBuffer &buf ); |
|
TokenType_t ReadToken( CUtlBuffer &buf, CUtlBuffer &token ); |
|
DmxElementDictHandle_t CreateDmxElement( const char *pElementType ); |
|
bool UnserializeAttributeValueFromToken( CDmxAttribute *pAttribute, DmAttributeType_t type, CUtlBuffer &tokenBuf ); |
|
bool UnserializeElementAttribute( CUtlBuffer &buf, DmxElementDictHandle_t hElement, const char *pAttributeName, const char *pElementType ); |
|
bool UnserializeElementArrayAttribute( CUtlBuffer &buf, DmxElementDictHandle_t hElement, const char *pAttributeName ); |
|
bool UnserializeArrayAttribute( CUtlBuffer &buf, DmxElementDictHandle_t hElement, const char *pAttributeName, DmAttributeType_t nAttrType ); |
|
bool UnserializeAttribute( CUtlBuffer &buf, DmxElementDictHandle_t hElement, const char *pAttributeName, DmAttributeType_t nAttrType ); |
|
bool UnserializeElement( CUtlBuffer &buf, const char *pElementType, DmxElementDictHandle_t *pHandle ); |
|
bool UnserializeElement( CUtlBuffer &buf, DmxElementDictHandle_t *pHandle ); |
|
|
|
// Methods related to serialization |
|
void SerializeArrayAttribute( CUtlBuffer& buf, CDmxAttribute *pAttribute ); |
|
void SerializeElementAttribute( CUtlBuffer& buf, CDmxSerializationDictionary &dict, CDmxAttribute *pAttribute ); |
|
void SerializeElementArrayAttribute( CUtlBuffer& buf, CDmxSerializationDictionary &dict, CDmxAttribute *pAttribute ); |
|
bool SerializeAttributes( CUtlBuffer& buf, CDmxSerializationDictionary &dict, CDmxElement *pElement ); |
|
bool SaveElement( CUtlBuffer& buf, CDmxSerializationDictionary &dict, CDmxElement *pElement, bool bWriteDelimiters = true ); |
|
|
|
// For unserialization |
|
CDmxElementDictionary m_ElementDict; |
|
DmxElementDictHandle_t m_hRoot; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Serializes a single element attribute |
|
//----------------------------------------------------------------------------- |
|
void CDmxSerializerKeyValues2::SerializeElementAttribute( CUtlBuffer& buf, CDmxSerializationDictionary &dict, CDmxAttribute *pAttribute ) |
|
{ |
|
CDmxElement *pElement = pAttribute->GetValue< CDmxElement* >(); |
|
if ( dict.ShouldInlineElement( pElement ) ) |
|
{ |
|
buf.Printf( "\"%s\"\n{\n", pElement->GetTypeString() ); |
|
if ( pElement ) |
|
{ |
|
SaveElement( buf, dict, pElement, false ); |
|
} |
|
buf.Printf( "}\n" ); |
|
} |
|
else |
|
{ |
|
buf.Printf( "\"%s\" \"", g_pAttributeTypeName[ AT_ELEMENT ] ); |
|
if ( pElement ) |
|
{ |
|
::Serialize( buf, pElement->GetId() ); |
|
} |
|
buf.PutChar( '\"' ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Serializes an array element attribute |
|
//----------------------------------------------------------------------------- |
|
void CDmxSerializerKeyValues2::SerializeElementArrayAttribute( CUtlBuffer& buf, CDmxSerializationDictionary &dict, CDmxAttribute *pAttribute ) |
|
{ |
|
const CUtlVector<CDmxElement*> &array = pAttribute->GetArray< CDmxElement* >(); |
|
|
|
buf.Printf( "\n[\n" ); |
|
buf.PushTab(); |
|
|
|
int nCount = array.Count(); |
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
CDmxElement *pElement = array[i]; |
|
if ( dict.ShouldInlineElement( pElement ) ) |
|
{ |
|
buf.Printf( "\"%s\"\n{\n", pElement->GetTypeString() ); |
|
if ( pElement ) |
|
{ |
|
SaveElement( buf, dict, pElement, false ); |
|
} |
|
buf.PutChar( '}' ); |
|
} |
|
else |
|
{ |
|
const char *pAttributeType = g_pAttributeTypeName[ AT_ELEMENT ]; |
|
buf.Printf( "\"%s\" \"", pAttributeType ); |
|
if ( pElement ) |
|
{ |
|
::Serialize( buf, pElement->GetId() ); |
|
} |
|
buf.PutChar( '\"' ); |
|
} |
|
|
|
if ( i != nCount - 1 ) |
|
{ |
|
buf.PutChar( ',' ); |
|
} |
|
buf.PutChar( '\n' ); |
|
} |
|
|
|
buf.PopTab(); |
|
buf.Printf( "]" ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Serializes array attributes |
|
//----------------------------------------------------------------------------- |
|
void CDmxSerializerKeyValues2::SerializeArrayAttribute( CUtlBuffer& buf, CDmxAttribute *pAttribute ) |
|
{ |
|
int nCount = pAttribute->GetArrayCount(); |
|
|
|
buf.PutString( "\n[\n" ); |
|
buf.PushTab(); |
|
|
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
if ( pAttribute->GetType() != AT_STRING_ARRAY ) |
|
{ |
|
buf.PutChar( '\"' ); |
|
buf.PushTab(); |
|
} |
|
|
|
pAttribute->SerializeElement( i, buf ); |
|
|
|
if ( pAttribute->GetType() != AT_STRING_ARRAY ) |
|
{ |
|
buf.PopTab(); |
|
buf.PutChar( '\"' ); |
|
} |
|
|
|
if ( i != nCount - 1 ) |
|
{ |
|
buf.PutChar( ',' ); |
|
} |
|
buf.PutChar( '\n' ); |
|
} |
|
buf.PopTab(); |
|
buf.PutChar( ']' ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Serializes all attributes in an element |
|
//----------------------------------------------------------------------------- |
|
static int SortAttributeByName(const void *p1, const void *p2 ) |
|
{ |
|
const CDmxAttribute **ppAtt1 = (const CDmxAttribute**)p1; |
|
const CDmxAttribute **ppAtt2 = (const CDmxAttribute**)p2; |
|
const char *pAttName1 = (*ppAtt1)->GetName(); |
|
const char *pAttName2 = (*ppAtt2)->GetName(); |
|
return Q_stricmp( pAttName1, pAttName2 ); |
|
} |
|
|
|
bool CDmxSerializerKeyValues2::SerializeAttributes( CUtlBuffer& buf, CDmxSerializationDictionary &dict, CDmxElement *pElement ) |
|
{ |
|
int nCount = pElement->AttributeCount(); |
|
CDmxAttribute **ppAttributes = (CDmxAttribute**)stackalloc( nCount * sizeof(CDmxAttribute*) ); |
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
ppAttributes[i] = pElement->GetAttribute( i ); |
|
} |
|
|
|
// Sort by name |
|
qsort( ppAttributes, nCount, sizeof(CDmxAttribute*), SortAttributeByName ); |
|
|
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
CDmxAttribute *pAttribute = ppAttributes[ i ]; |
|
|
|
const char *pName = pAttribute->GetName( ); |
|
DmAttributeType_t nAttrType = pAttribute->GetType(); |
|
if ( nAttrType != AT_ELEMENT ) |
|
{ |
|
buf.Printf( "\"%s\" \"%s\" ", pName, g_pAttributeTypeName[ nAttrType ] ); |
|
} |
|
else |
|
{ |
|
// Elements either serialize their type name or "element" depending on whether they are inlined |
|
buf.Printf( "\"%s\" ", pName ); |
|
} |
|
|
|
switch( nAttrType ) |
|
{ |
|
default: |
|
if ( nAttrType >= AT_FIRST_ARRAY_TYPE ) |
|
{ |
|
SerializeArrayAttribute( buf, pAttribute ); |
|
} |
|
else |
|
{ |
|
if ( pAttribute->SerializesOnMultipleLines() ) |
|
{ |
|
buf.PutChar( '\n' ); |
|
} |
|
|
|
buf.PutChar( '\"' ); |
|
buf.PushTab(); |
|
pAttribute->Serialize( buf ); |
|
buf.PopTab(); |
|
buf.PutChar( '\"' ); |
|
} |
|
break; |
|
|
|
case AT_STRING: |
|
// Don't explicitly add string delimiters; serialization does that. |
|
pAttribute->Serialize( buf ); |
|
break; |
|
|
|
case AT_ELEMENT: |
|
SerializeElementAttribute( buf, dict, pAttribute ); |
|
break; |
|
|
|
case AT_ELEMENT_ARRAY: |
|
SerializeElementArrayAttribute( buf, dict, pAttribute ); |
|
break; |
|
} |
|
|
|
buf.PutChar( '\n' ); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
bool CDmxSerializerKeyValues2::SaveElement( CUtlBuffer& buf, CDmxSerializationDictionary &dict, CDmxElement *pElement, bool bWriteDelimiters ) |
|
{ |
|
if ( bWriteDelimiters ) |
|
{ |
|
buf.Printf( "\"%s\"\n{\n", pElement->GetTypeString() ); |
|
} |
|
buf.PushTab(); |
|
|
|
// explicitly serialize id, now that it's no longer an attribute |
|
buf.Printf( "\"id\" \"%s\" ", g_pAttributeTypeName[ AT_OBJECTID ] ); |
|
buf.PutChar( '\"' ); |
|
::Serialize( buf, pElement->GetId() ); |
|
buf.PutString( "\"\n" ); |
|
|
|
SerializeAttributes( buf, dict, pElement ); |
|
|
|
buf.PopTab(); |
|
if ( bWriteDelimiters ) |
|
{ |
|
buf.Printf( "}\n" ); |
|
} |
|
return true; |
|
} |
|
|
|
bool CDmxSerializerKeyValues2::Serialize( CUtlBuffer &outBuf, CDmxElement *pRoot, const char *pFormatName ) |
|
{ |
|
SetSerializationDelimiter( GetCStringCharConversion() ); |
|
SetSerializationArrayDelimiter( "," ); |
|
|
|
bool bFlatMode = !Q_stricmp( pFormatName, "keyvalues2_flat" ); |
|
|
|
// Save elements, attribute links |
|
CDmxSerializationDictionary dict; |
|
dict.BuildElementList( pRoot, bFlatMode ); |
|
|
|
// Save elements to buffer |
|
DmxSerializationHandle_t i; |
|
for ( i = dict.FirstRootElement(); i != ELEMENT_DICT_HANDLE_INVALID; i = dict.NextRootElement(i) ) |
|
{ |
|
SaveElement( outBuf, dict, dict.GetRootElement( i ) ); |
|
outBuf.PutChar( '\n' ); |
|
} |
|
|
|
SetSerializationDelimiter( NULL ); |
|
SetSerializationArrayDelimiter( NULL ); |
|
|
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Eats whitespaces and c++ style comments |
|
//----------------------------------------------------------------------------- |
|
#pragma warning (disable:4706) |
|
|
|
void CDmxSerializerKeyValues2::EatWhitespacesAndComments( CUtlBuffer &buf ) |
|
{ |
|
// eating white spaces and remarks loop |
|
int nMaxPut = buf.TellMaxPut() - buf.TellGet(); |
|
int nOffset = 0; |
|
while ( nOffset < nMaxPut ) |
|
{ |
|
// Eat whitespaces, keep track of line count |
|
const char *pPeek = NULL; |
|
while ( (pPeek = (const char *)buf.PeekGet( sizeof(char), nOffset ) ) ) |
|
{ |
|
if ( !isspace( *pPeek ) ) |
|
break; |
|
|
|
if ( *pPeek == '\n' ) |
|
{ |
|
g_KeyValues2ErrorStack.IncrementCurrentLine(); |
|
} |
|
if ( ++nOffset >= nMaxPut ) |
|
break; |
|
} |
|
|
|
// If we don't have a a c++ style comment next, we're done |
|
pPeek = (const char *)buf.PeekGet( 2 * sizeof(char), nOffset ); |
|
if ( ( nOffset >= nMaxPut ) || !pPeek || ( pPeek[0] != '/' ) || ( pPeek[1] != '/' ) ) |
|
break; |
|
|
|
// Deal with c++ style comments |
|
nOffset += 2; |
|
|
|
// read complete line |
|
while ( ( pPeek = (const char *)buf.PeekGet( sizeof(char), nOffset ) ) ) |
|
{ |
|
if ( *pPeek == '\n' ) |
|
break; |
|
if ( ++nOffset >= nMaxPut ) |
|
break; |
|
} |
|
|
|
g_KeyValues2ErrorStack.IncrementCurrentLine(); |
|
} |
|
|
|
buf.SeekGet( CUtlBuffer::SEEK_CURRENT, nOffset ); |
|
} |
|
|
|
#pragma warning (default:4706) |
|
|
|
//----------------------------------------------------------------------------- |
|
// Reads a single token, points the token utlbuffer at it |
|
//----------------------------------------------------------------------------- |
|
CDmxSerializerKeyValues2::TokenType_t CDmxSerializerKeyValues2::ReadToken( CUtlBuffer &buf, CUtlBuffer &token ) |
|
{ |
|
EatWhitespacesAndComments( buf ); |
|
|
|
// if message text buffers go over this size |
|
// change this value to make sure they will fit |
|
// affects loading of last active chat window |
|
if ( !buf.IsValid() || ( buf.TellGet() == buf.TellMaxPut() ) ) |
|
return TOKEN_EOF; |
|
|
|
// Compute token length and type |
|
int nLength = 0; |
|
TokenType_t t = TOKEN_INVALID; |
|
char c = *((const char *)buf.PeekGet()); |
|
switch( c ) |
|
{ |
|
case '{': |
|
nLength = 1; |
|
t = TOKEN_OPEN_BRACE; |
|
break; |
|
|
|
case '}': |
|
nLength = 1; |
|
t = TOKEN_CLOSE_BRACE; |
|
break; |
|
|
|
case '[': |
|
nLength = 1; |
|
t = TOKEN_OPEN_BRACKET; |
|
break; |
|
|
|
case ']': |
|
nLength = 1; |
|
t = TOKEN_CLOSE_BRACKET; |
|
break; |
|
|
|
case ',': |
|
nLength = 1; |
|
t = TOKEN_COMMA; |
|
break; |
|
|
|
case '\"': |
|
// NOTE: The -1 is because peek includes room for the /0 |
|
nLength = buf.PeekDelimitedStringLength( GetCStringCharConversion(), false ) - 1; |
|
if ( (nLength <= 1) || ( *(const char *)buf.PeekGet( nLength - 1 ) != '\"' )) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Unexpected EOF in quoted string" ); |
|
t = TOKEN_INVALID; |
|
} |
|
else |
|
{ |
|
t = TOKEN_DELIMITED_STRING; |
|
} |
|
break; |
|
|
|
default: |
|
t = TOKEN_INVALID; |
|
break; |
|
} |
|
|
|
// Point the token buffer to the token + update the original buffer get index |
|
token.SetExternalBuffer( (void*)buf.PeekGet(), nLength, nLength, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY ); |
|
buf.SeekGet( CUtlBuffer::SEEK_CURRENT, nLength ); |
|
|
|
// Count the number of crs in the token + update the current line |
|
const char *pMem = (const char *)token.Base(); |
|
for ( int i = 0; i < nLength; ++i ) |
|
{ |
|
if ( pMem[i] == '\n' ) |
|
{ |
|
g_KeyValues2ErrorStack.IncrementCurrentLine(); |
|
} |
|
} |
|
|
|
return t; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Creates a scene object, adds it to the element dictionary |
|
//----------------------------------------------------------------------------- |
|
DmxElementDictHandle_t CDmxSerializerKeyValues2::CreateDmxElement( const char *pElementType ) |
|
{ |
|
// See if we can create an element of that type |
|
CDmxElement *pElement = new CDmxElement( pElementType ); |
|
return m_ElementDict.InsertElement( pElement ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Reads an attribute for an element |
|
//----------------------------------------------------------------------------- |
|
bool CDmxSerializerKeyValues2::UnserializeElementAttribute( CUtlBuffer &buf, DmxElementDictHandle_t hElement, const char *pAttributeName, const char *pElementType ) |
|
{ |
|
CDmxElement *pElement = m_ElementDict.GetElement( hElement ); |
|
if ( pElement->HasAttribute( pAttributeName ) ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Attribute \"%s\" was defined more than once.\n", pAttributeName ); |
|
return false; |
|
} |
|
|
|
CDmxAttribute *pAttribute; |
|
{ |
|
CDmxElementModifyScope modify( pElement ); |
|
pAttribute = pElement->AddAttribute( pAttributeName ); |
|
} |
|
|
|
DmxElementDictHandle_t h; |
|
bool bOk = UnserializeElement( buf, pElementType, &h ); |
|
if ( bOk ) |
|
{ |
|
CDmxElement *pNewElement = m_ElementDict.GetElement( h ); |
|
pAttribute->SetValue( pNewElement ); |
|
} |
|
return bOk; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Reads an attribute for an element array |
|
//----------------------------------------------------------------------------- |
|
bool CDmxSerializerKeyValues2::UnserializeElementArrayAttribute( CUtlBuffer &buf, DmxElementDictHandle_t hElement, const char *pAttributeName ) |
|
{ |
|
CDmxElement *pElement = m_ElementDict.GetElement( hElement ); |
|
if ( pElement->HasAttribute( pAttributeName ) ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Attribute \"%s\" was defined more than once.\n", pAttributeName ); |
|
return false; |
|
} |
|
|
|
CDmxAttribute *pAttribute; |
|
{ |
|
CDmxElementModifyScope modify( pElement ); |
|
pAttribute = pElement->AddAttribute( pAttributeName ); |
|
} |
|
|
|
// Arrays first must have a '[' specified |
|
TokenType_t token; |
|
CUtlBuffer tokenBuf; |
|
CUtlCharConversion *pConv; |
|
token = ReadToken( buf, tokenBuf ); |
|
if ( token != TOKEN_OPEN_BRACKET ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting '[', didn't find it!" ); |
|
return false; |
|
} |
|
|
|
int nElementIndex = 0; |
|
|
|
// Now read a list of array values, separated by commas |
|
while ( buf.IsValid() ) |
|
{ |
|
token = ReadToken( buf, tokenBuf ); |
|
if ( token == TOKEN_INVALID || token == TOKEN_EOF ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting ']', didn't find it!" ); |
|
return false; |
|
} |
|
|
|
// Then, keep reading until we hit a ']' |
|
if ( token == TOKEN_CLOSE_BRACKET ) |
|
break; |
|
|
|
// If we've already read in an array value, we need to read a comma next |
|
if ( nElementIndex > 0 ) |
|
{ |
|
if ( token != TOKEN_COMMA ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting ',', didn't find it!" ); |
|
return false; |
|
} |
|
|
|
// Read in the next thing, which should be a value |
|
token = ReadToken( buf, tokenBuf ); |
|
} |
|
|
|
// Ok, we must be reading an array type value |
|
if ( token != TOKEN_DELIMITED_STRING ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting element type, didn't find it!" ); |
|
return false; |
|
} |
|
|
|
// Get the element type out |
|
pConv = GetCStringCharConversion(); |
|
int nLength = tokenBuf.PeekDelimitedStringLength( pConv ); |
|
char *pElementType = (char*)stackalloc( nLength * sizeof(char) ); |
|
tokenBuf.GetDelimitedString( pConv, pElementType, nLength ); |
|
|
|
// Use the element type to figure out if we're using a element reference or an inlined element |
|
if ( !Q_strncmp( pElementType, g_pAttributeTypeName[AT_ELEMENT], nLength ) ) |
|
{ |
|
token = ReadToken( buf, tokenBuf ); |
|
|
|
// Ok, we must be reading an array type value |
|
if ( token != TOKEN_DELIMITED_STRING ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting element reference, didn't find it!" ); |
|
return false; |
|
} |
|
|
|
// Get the element type out |
|
pConv = GetCStringCharConversion(); |
|
nLength = tokenBuf.PeekDelimitedStringLength( pConv ); |
|
char *pElementId = (char*)stackalloc( nLength * sizeof(char) ); |
|
tokenBuf.GetDelimitedString( pConv, pElementId, nLength ); |
|
|
|
DmObjectId_t id; |
|
if ( !UniqueIdFromString( &id, pElementId ) ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Encountered invalid element ID data!" ); |
|
return false; |
|
} |
|
|
|
Assert( IsUniqueIdValid( id ) ); |
|
m_ElementDict.AddArrayAttribute( pAttribute, id ); |
|
} |
|
else |
|
{ |
|
DmxElementDictHandle_t hArrayElement; |
|
bool bOk = UnserializeElement( buf, pElementType, &hArrayElement ); |
|
if ( !bOk ) |
|
return false; |
|
m_ElementDict.AddArrayAttribute( pAttribute, hArrayElement ); |
|
} |
|
|
|
// Ok, we've read in another value |
|
++nElementIndex; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Unserializes an attribute from a token buffer |
|
//----------------------------------------------------------------------------- |
|
bool CDmxSerializerKeyValues2::UnserializeAttributeValueFromToken( CDmxAttribute *pAttribute, DmAttributeType_t type, CUtlBuffer &tokenBuf ) |
|
{ |
|
// NOTE: This code is necessary because the attribute code is using Scanf |
|
// which is not really friendly toward delimiters, so we must pass in |
|
// non-delimited buffers. Sucky. There must be a better way of doing this |
|
const char *pBuf = (const char*)tokenBuf.Base(); |
|
int nLength = tokenBuf.TellMaxPut(); |
|
char *pTemp = (char*)stackalloc( nLength + 1 ); |
|
|
|
bool bIsString = ( type == AT_STRING ) || ( type == AT_STRING_ARRAY ); |
|
if ( !bIsString ) |
|
{ |
|
nLength = tokenBuf.PeekDelimitedStringLength( GetCStringCharConversion() ); |
|
tokenBuf.GetDelimitedString( GetCStringCharConversion(), pTemp, nLength + 1 ); |
|
pBuf = pTemp; |
|
} |
|
else |
|
{ |
|
SetSerializationDelimiter( GetCStringCharConversion() ); |
|
} |
|
|
|
bool bOk; |
|
CUtlBuffer buf( pBuf, nLength, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY ); |
|
if ( type < AT_FIRST_ARRAY_TYPE ) |
|
{ |
|
bOk = pAttribute->Unserialize( type, buf ); |
|
} |
|
else |
|
{ |
|
bOk = pAttribute->UnserializeElement( type, buf ); |
|
} |
|
|
|
if ( bIsString ) |
|
{ |
|
SetSerializationDelimiter( NULL ); |
|
} |
|
|
|
return bOk; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Reads an attribute for an element array |
|
//----------------------------------------------------------------------------- |
|
bool CDmxSerializerKeyValues2::UnserializeArrayAttribute( CUtlBuffer &buf, DmxElementDictHandle_t hElement, const char *pAttributeName, DmAttributeType_t nAttrType ) |
|
{ |
|
CDmxElement *pElement = m_ElementDict.GetElement( hElement ); |
|
if ( pElement->HasAttribute( pAttributeName ) ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Encountered duplicate attribute definition for attribute \"%s\"!", pAttributeName ); |
|
return false; |
|
} |
|
|
|
CDmxAttribute *pAttribute; |
|
{ |
|
CDmxElementModifyScope modify( pElement ); |
|
pAttribute = pElement->AddAttribute( pAttributeName ); |
|
} |
|
|
|
// Arrays first must have a '[' specified |
|
TokenType_t token; |
|
CUtlBuffer tokenBuf; |
|
token = ReadToken( buf, tokenBuf ); |
|
if ( token != TOKEN_OPEN_BRACKET ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting '[', didn't find it!" ); |
|
return false; |
|
} |
|
|
|
int nElementIndex = 0; |
|
|
|
// Now read a list of array values, separated by commas |
|
while ( buf.IsValid() ) |
|
{ |
|
token = ReadToken( buf, tokenBuf ); |
|
if ( token == TOKEN_INVALID || token == TOKEN_EOF ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting ']', didn't find it!" ); |
|
return false; |
|
} |
|
|
|
// Then, keep reading until we hit a ']' |
|
if ( token == TOKEN_CLOSE_BRACKET ) |
|
break; |
|
|
|
// If we've already read in an array value, we need to read a comma next |
|
if ( nElementIndex > 0 ) |
|
{ |
|
if ( token != TOKEN_COMMA ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting ',', didn't find it!" ); |
|
return false; |
|
} |
|
|
|
// Read in the next thing, which should be a value |
|
token = ReadToken( buf, tokenBuf ); |
|
} |
|
|
|
// Ok, we must be reading an attributearray value |
|
if ( token != TOKEN_DELIMITED_STRING ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting array attribute value, didn't find it!" ); |
|
return false; |
|
} |
|
|
|
if ( !UnserializeAttributeValueFromToken( pAttribute, nAttrType, tokenBuf ) ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError("Error reading in array attribute \"%s\" element %d", pAttributeName, nElementIndex ); |
|
return false; |
|
} |
|
|
|
// Ok, we've read in another value |
|
++nElementIndex; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Reads an attribute for an element |
|
//----------------------------------------------------------------------------- |
|
bool CDmxSerializerKeyValues2::UnserializeAttribute( CUtlBuffer &buf, |
|
DmxElementDictHandle_t hElement, const char *pAttributeName, DmAttributeType_t nAttrType ) |
|
{ |
|
// Read the attribute value |
|
CUtlBuffer tokenBuf; |
|
TokenType_t token = ReadToken( buf, tokenBuf ); |
|
if ( token != TOKEN_DELIMITED_STRING ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting quoted attribute value for attribute \"%s\", didn't find one!", pAttributeName ); |
|
return false; |
|
} |
|
|
|
CDmxElement *pElement = m_ElementDict.GetElement( hElement ); |
|
if ( ( nAttrType == AT_OBJECTID ) && !Q_strnicmp( pAttributeName, "id", 3 ) ) |
|
{ |
|
CUtlCharConversion *pConv = GetCStringCharConversion(); |
|
int nLength = tokenBuf.PeekDelimitedStringLength( pConv ); |
|
char *pElementId = (char*)stackalloc( nLength * sizeof(char) ); |
|
tokenBuf.GetDelimitedString( pConv, pElementId, nLength ); |
|
|
|
DmObjectId_t id; |
|
if ( !UniqueIdFromString( &id, pElementId ) ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Encountered invalid element ID data!" ); |
|
return false; |
|
} |
|
|
|
m_ElementDict.SetElementId( hElement, id ); |
|
pElement->SetId( id ); |
|
return true; |
|
} |
|
|
|
if ( pElement->HasAttribute( pAttributeName ) ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Encountered duplicate attribute definition for attribute \"%s\"!", pAttributeName ); |
|
return false; |
|
} |
|
|
|
CDmxAttribute *pAttribute; |
|
{ |
|
CDmxElementModifyScope modify( pElement ); |
|
pAttribute = pElement->AddAttribute( pAttributeName ); |
|
} |
|
|
|
switch( nAttrType ) |
|
{ |
|
case AT_ELEMENT: |
|
{ |
|
// Get the attribute value out |
|
CUtlCharConversion *pConv = GetCStringCharConversion(); |
|
int nLength = tokenBuf.PeekDelimitedStringLength( pConv ); |
|
char *pAttributeValue = (char*)stackalloc( nLength * sizeof(char) ); |
|
tokenBuf.GetDelimitedString( pConv, pAttributeValue, nLength ); |
|
|
|
// No string? that's ok, it means we have a NULL pointer |
|
if ( !pAttributeValue[0] ) |
|
return true; |
|
|
|
DmObjectId_t id; |
|
if ( !UniqueIdFromString( &id, pAttributeValue ) ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError("Invalid format for element ID encountered for attribute \"%s\"", pAttributeName ); |
|
return false; |
|
} |
|
|
|
m_ElementDict.AddAttribute( pAttribute, id ); |
|
} |
|
return true; |
|
|
|
default: |
|
if ( UnserializeAttributeValueFromToken( pAttribute, nAttrType, tokenBuf ) ) |
|
return true; |
|
|
|
g_KeyValues2ErrorStack.ReportError("Error reading attribute \"%s\"", pAttributeName ); |
|
return false; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Unserializes a single element given the type name |
|
//----------------------------------------------------------------------------- |
|
bool CDmxSerializerKeyValues2::UnserializeElement( CUtlBuffer &buf, const char *pElementType, DmxElementDictHandle_t *pHandle ) |
|
{ |
|
*pHandle = ELEMENT_DICT_HANDLE_INVALID; |
|
|
|
// Create the element |
|
DmxElementDictHandle_t hElement = CreateDmxElement( pElementType ); |
|
|
|
// Report errors relative to this type name |
|
CKeyValues2ErrorContext errorReport( pElementType ); |
|
|
|
TokenType_t token; |
|
CUtlBuffer tokenBuf; |
|
CUtlCharConversion *pConv; |
|
int nLength; |
|
|
|
// Then we expect a '{' |
|
token = ReadToken( buf, tokenBuf ); |
|
if ( token != TOKEN_OPEN_BRACE ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting '{', didn't find it!" ); |
|
return false; |
|
} |
|
|
|
while ( buf.IsValid() ) |
|
{ |
|
token = ReadToken( buf, tokenBuf ); |
|
if ( token == TOKEN_INVALID || token == TOKEN_EOF ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting '}', didn't find it!" ); |
|
return false; |
|
} |
|
|
|
// Then, keep reading until we hit a '}' |
|
if ( token == TOKEN_CLOSE_BRACE ) |
|
break; |
|
|
|
// Ok, we must be reading an attribute |
|
if ( token != TOKEN_DELIMITED_STRING ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting attribute name, didn't find it!" ); |
|
return false; |
|
} |
|
|
|
// First, read an attribute name |
|
pConv = GetCStringCharConversion(); |
|
nLength = tokenBuf.PeekDelimitedStringLength( pConv ); |
|
char *pAttributeName = (char*)stackalloc( nLength * sizeof(char) ); |
|
tokenBuf.GetDelimitedString( pConv, pAttributeName, nLength ); |
|
|
|
// Next, read an attribute type |
|
token = ReadToken( buf, tokenBuf ); |
|
if ( token != TOKEN_DELIMITED_STRING ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting attribute type for attribute %s, didn't find it!", pAttributeName ); |
|
return false; |
|
} |
|
|
|
pConv = GetCStringCharConversion(); |
|
nLength = tokenBuf.PeekDelimitedStringLength( pConv ); |
|
char *pAttributeType = (char*)stackalloc( nLength * sizeof(char) ); |
|
tokenBuf.GetDelimitedString( pConv, pAttributeType, nLength ); |
|
|
|
DmAttributeType_t nAttrType = AT_UNKNOWN; |
|
for ( int i = 0; i < AT_TYPE_COUNT; ++i ) |
|
{ |
|
if ( !Q_stricmp( g_pAttributeTypeName[i], pAttributeType ) ) |
|
{ |
|
nAttrType = (DmAttributeType_t)i; |
|
break; |
|
} |
|
} |
|
|
|
// Next, read an attribute value |
|
bool bOk = true; |
|
switch( nAttrType ) |
|
{ |
|
case AT_UNKNOWN: |
|
bOk = UnserializeElementAttribute( buf, hElement, pAttributeName, pAttributeType ); |
|
break; |
|
|
|
case AT_ELEMENT_ARRAY: |
|
bOk = UnserializeElementArrayAttribute( buf, hElement, pAttributeName ); |
|
break; |
|
|
|
default: |
|
if ( nAttrType >= AT_FIRST_ARRAY_TYPE ) |
|
{ |
|
bOk = UnserializeArrayAttribute( buf, hElement, pAttributeName, nAttrType ); |
|
} |
|
else |
|
{ |
|
bOk = UnserializeAttribute( buf, hElement, pAttributeName, nAttrType ); |
|
} |
|
break; |
|
} |
|
|
|
if ( !bOk ) |
|
return false; |
|
} |
|
|
|
*pHandle = hElement; |
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Unserializes a single element |
|
//----------------------------------------------------------------------------- |
|
bool CDmxSerializerKeyValues2::UnserializeElement( CUtlBuffer &buf, DmxElementDictHandle_t *pHandle ) |
|
{ |
|
*pHandle = ELEMENT_DICT_HANDLE_INVALID; |
|
|
|
// First, read the type name |
|
CUtlBuffer tokenBuf; |
|
CUtlCharConversion* pConv; |
|
|
|
TokenType_t token = ReadToken( buf, tokenBuf ); |
|
if ( token == TOKEN_INVALID ) |
|
return false; |
|
|
|
if ( token == TOKEN_EOF ) |
|
return true; |
|
|
|
// Get the type name out |
|
if ( token != TOKEN_DELIMITED_STRING ) |
|
{ |
|
g_KeyValues2ErrorStack.ReportError( "Expecting element type name, didn't find it!" ); |
|
return false; |
|
} |
|
|
|
pConv = GetCStringCharConversion(); |
|
int nLength = tokenBuf.PeekDelimitedStringLength( pConv ); |
|
char *pTypeName = (char*)stackalloc( nLength * sizeof(char) ); |
|
tokenBuf.GetDelimitedString( pConv, pTypeName, nLength ); |
|
|
|
return UnserializeElement( buf, pTypeName, pHandle ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Main entry point for the unserialization |
|
//----------------------------------------------------------------------------- |
|
bool CDmxSerializerKeyValues2::Unserialize( const char *pFileName, CUtlBuffer &buf, CDmxElement **ppRoot ) |
|
{ |
|
*ppRoot = NULL; |
|
|
|
g_KeyValues2ErrorStack.SetFilename( pFileName ); |
|
m_hRoot = ELEMENT_DICT_HANDLE_INVALID; |
|
m_ElementDict.Clear(); |
|
|
|
bool bOk = true; |
|
while ( buf.IsValid() ) |
|
{ |
|
DmxElementDictHandle_t h; |
|
bOk = UnserializeElement( buf, &h ); |
|
if ( !bOk || ( h == ELEMENT_DICT_HANDLE_INVALID ) ) |
|
break; |
|
|
|
if ( m_hRoot == ELEMENT_DICT_HANDLE_INVALID ) |
|
{ |
|
m_hRoot = h; |
|
} |
|
} |
|
|
|
// do this *before* getting the root, since the first element might be deleted due to id conflicts |
|
m_ElementDict.HookUpElementReferences(); |
|
|
|
*ppRoot = m_ElementDict.GetElement( m_hRoot ); |
|
m_ElementDict.Clear(); |
|
|
|
if ( !bOk ) |
|
{ |
|
CleanupDMX( *ppRoot ); |
|
*ppRoot = NULL; |
|
} |
|
|
|
return bOk; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Unserialization entry point for text files (assumes version has been stripped) |
|
//----------------------------------------------------------------------------- |
|
bool UnserializeTextDMX( const char *pFileName, CUtlBuffer &buf, CDmxElement **ppRoot ) |
|
{ |
|
CDmxSerializerKeyValues2 dmxUnserializer; |
|
return dmxUnserializer.Unserialize( pFileName, buf, ppRoot ); |
|
} |
|
|
|
|
|
bool SerializeTextDMX( const char *pFileName, CUtlBuffer &buf, CDmxElement *pRoot ) |
|
{ |
|
CDmxSerializerKeyValues2 dmxSerializer; |
|
return dmxSerializer.Serialize( buf, pRoot, pFileName ); |
|
}
|
|
|