From 3bf9df6b2785fa6d951086978a3e66f49427166a Mon Sep 17 00:00:00 2001 From: FluorescentCIAAfricanAmerican <0934gj3049fk@protonmail.com> Date: Wed, 22 Apr 2020 12:56:21 -0400 Subject: 1 --- datamodel/dmserializerkeyvalues2.cpp | 1377 ++++++++++++++++++++++++++++++++++ 1 file changed, 1377 insertions(+) create mode 100644 datamodel/dmserializerkeyvalues2.cpp (limited to 'datamodel/dmserializerkeyvalues2.cpp') diff --git a/datamodel/dmserializerkeyvalues2.cpp b/datamodel/dmserializerkeyvalues2.cpp new file mode 100644 index 0000000..dbc8cb5 --- /dev/null +++ b/datamodel/dmserializerkeyvalues2.cpp @@ -0,0 +1,1377 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#include "dmserializerkeyvalues2.h" +#include +#include "datamodel/idatamodel.h" +#include "datamodel.h" +#include "datamodel/dmelement.h" +#include "datamodel/dmattributevar.h" +#include "dmattributeinternal.h" +#include "dmelementdictionary.h" +#include "DmElementFramework.h" +#include "tier1/utlbuffer.h" +#include + + +//----------------------------------------------------------------------------- +// Forward declarations +//----------------------------------------------------------------------------- +class CUtlBuffer; + + +//----------------------------------------------------------------------------- +// a simple class to keep track of a stack of valid parsed symbols +//----------------------------------------------------------------------------- +class CKeyValues2ErrorStack +{ +public: + CKeyValues2ErrorStack(); + + // 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, ... ); + +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; +}; + + +//----------------------------------------------------------------------------- +// Singleton instance +//----------------------------------------------------------------------------- +static CKeyValues2ErrorStack g_KeyValues2ErrorStack; + + +//----------------------------------------------------------------------------- +// Constructor +//----------------------------------------------------------------------------- +CKeyValues2ErrorStack::CKeyValues2ErrorStack() : + m_pFilename("NULL"), m_errorIndex(0), m_maxErrorIndex(0), m_nFileLine(1) +{ +} + + +//----------------------------------------------------------------------------- +// Sets the filename +//----------------------------------------------------------------------------- +void CKeyValues2ErrorStack::SetFilename( const char *pFilename ) +{ + m_pFilename = pFilename; + m_maxErrorIndex = 0; + m_nFileLine = 1; +} + + +//----------------------------------------------------------------------------- +// Current line control +//----------------------------------------------------------------------------- +void CKeyValues2ErrorStack::IncrementCurrentLine() +{ + ++m_nFileLine; +} + +void CKeyValues2ErrorStack::SetCurrentLine( int nLine ) +{ + m_nFileLine = nLine; +} + +int CKeyValues2ErrorStack::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 CKeyValues2ErrorStack::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 CKeyValues2ErrorStack::Pop() +{ + m_errorIndex--; + Assert(m_errorIndex>=0); +} + + +//----------------------------------------------------------------------------- +// Allows you to keep the same stack level, but change the name as you parse peers +//----------------------------------------------------------------------------- +void CKeyValues2ErrorStack::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 CKeyValues2ErrorStack::ReportError( const char *pFmt, ... ) +{ + char temp[2048]; + + va_list args; + va_start( args, pFmt ); + Q_vsnprintf( temp, sizeof( temp ), pFmt, args ); + va_end( args ); + + char temp2[2048]; + Q_snprintf( temp2, sizeof( temp2 ), "%s(%d) : %s\n", m_pFilename, m_nFileLine, temp ); + Warning( temp2 ); + + for ( int i = 0; i < m_maxErrorIndex; i++ ) + { + if ( !m_errorStack[i].IsValid() ) + continue; + + if ( i < m_errorIndex ) + { + Warning( "%s, ", g_pDataModel->GetString( m_errorStack[i] ) ); + } + else + { + Warning( "(*%s*), ", g_pDataModel->GetString( 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( g_pDataModel->GetSymbol( 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; +}; + + +//----------------------------------------------------------------------------- +// Serialization class for Key Values 2 +//----------------------------------------------------------------------------- +class CDmSerializerKeyValues2 : public IDmSerializer +{ +public: + CDmSerializerKeyValues2( bool bFlatMode ) : m_bFlatMode( bFlatMode ) {} + + // Inherited from IDMSerializer + virtual const char *GetName() const { return m_bFlatMode ? "keyvalues2_flat" : "keyvalues2"; } + virtual const char *GetDescription() const { return m_bFlatMode ? "KeyValues2 (flat)" : "KeyValues2"; } + virtual bool StoresVersionInFile() const { return true; } + virtual bool IsBinaryFormat() const { return false; } + virtual int GetCurrentVersion() const { return 1; } + virtual bool Serialize( CUtlBuffer &buf, CDmElement *pRoot ); + virtual bool Unserialize( CUtlBuffer &buf, const char *pEncodingName, int nEncodingVersion, + const char *pSourceFormatName, int nSourceFormatVersion, + DmFileId_t fileid, DmConflictResolution_t idConflictResolution, CDmElement **ppRoot ); + +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 serialization + void SerializeArrayAttribute( CUtlBuffer& buf, CDmAttribute *pAttribute ); + void SerializeElementAttribute( CUtlBuffer& buf, CDmElementSerializationDictionary &dict, CDmAttribute *pAttribute ); + void SerializeElementArrayAttribute( CUtlBuffer& buf, CDmElementSerializationDictionary &dict, CDmAttribute *pAttribute ); + bool SerializeAttributes( CUtlBuffer& buf, CDmElementSerializationDictionary &dict, CDmElement *pElement ); + bool SaveElement( CUtlBuffer& buf, CDmElementSerializationDictionary &dict, CDmElement *pElement, bool bWriteDelimiters = true ); + + // Methods related to unserialization + void EatWhitespacesAndComments( CUtlBuffer &buf ); + TokenType_t ReadToken( CUtlBuffer &buf, CUtlBuffer &token ); + DmElementDictHandle_t CreateDmElement( const char *pElementType ); + bool UnserializeAttributeValueFromToken( CDmAttribute *pAttribute, CUtlBuffer &tokenBuf ); + bool UnserializeElementAttribute( CUtlBuffer &buf, DmElementDictHandle_t hElement, const char *pAttributeName, const char *pElementType ); + bool UnserializeElementArrayAttribute( CUtlBuffer &buf, DmElementDictHandle_t hElement, const char *pAttributeName ); + bool UnserializeArrayAttribute( CUtlBuffer &buf, DmElementDictHandle_t hElement, const char *pAttributeName, DmAttributeType_t nAttrType ); + bool UnserializeAttribute( CUtlBuffer &buf, DmElementDictHandle_t hElement, const char *pAttributeName, DmAttributeType_t nAttrType ); + bool UnserializeElement( CUtlBuffer &buf, const char *pElementType, DmElementDictHandle_t *pHandle ); + bool UnserializeElement( CUtlBuffer &buf, DmElementDictHandle_t *pHandle ); + bool UnserializeElements( CUtlBuffer &buf, DmFileId_t fileid, DmConflictResolution_t idConflictResolution, CDmElement **ppRoot ); + + // For unserialization + CDmElementDictionary m_ElementDict; + DmElementDictHandle_t m_hRoot; + bool m_bFlatMode; + DmConflictResolution_t m_idConflictResolution; + DmFileId_t m_fileid; +}; + + +//----------------------------------------------------------------------------- +// Singleton instance +//----------------------------------------------------------------------------- +static CDmSerializerKeyValues2 s_DMSerializerKeyValues2( false ); +static CDmSerializerKeyValues2 s_DMSerializerKeyValues2Flat( true ); + +void InstallKeyValues2Serializer( IDataModel *pFactory ) +{ + pFactory->AddSerializer( &s_DMSerializerKeyValues2 ); + pFactory->AddSerializer( &s_DMSerializerKeyValues2Flat ); +} + + +//----------------------------------------------------------------------------- +// Serializes a single element attribute +//----------------------------------------------------------------------------- +void CDmSerializerKeyValues2::SerializeElementAttribute( CUtlBuffer& buf, CDmElementSerializationDictionary &dict, CDmAttribute *pAttribute ) +{ + CDmElement *pElement = pAttribute->GetValueElement(); + 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_pDataModel->GetAttributeNameForType( AT_ELEMENT ) ); + if ( pElement ) + { + ::Serialize( buf, pElement->GetId() ); + } + buf.PutChar( '\"' ); + } +} + + +//----------------------------------------------------------------------------- +// Serializes an array element attribute +//----------------------------------------------------------------------------- +void CDmSerializerKeyValues2::SerializeElementArrayAttribute( CUtlBuffer& buf, CDmElementSerializationDictionary &dict, CDmAttribute *pAttribute ) +{ + CDmrElementArray<> array( pAttribute ); + + buf.Printf( "\n[\n" ); + buf.PushTab(); + + int nCount = array.Count(); + for ( int i = 0; i < nCount; ++i ) + { + CDmElement *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 = AttributeTypeName( 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 CDmSerializerKeyValues2::SerializeArrayAttribute( CUtlBuffer& buf, CDmAttribute *pAttribute ) +{ + CDmrGenericArray array( pAttribute ); + int nCount = array.Count(); + + buf.PutString( "\n[\n" ); + buf.PushTab(); + + for ( int i = 0; i < nCount; ++i ) + { + if ( pAttribute->GetType() != AT_STRING_ARRAY ) + { + buf.PutChar( '\"' ); + buf.PushTab(); + } + + array.GetAttribute()->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 +//----------------------------------------------------------------------------- +bool CDmSerializerKeyValues2::SerializeAttributes( CUtlBuffer& buf, CDmElementSerializationDictionary &dict, CDmElement *pElement ) +{ + // Collect the attributes to be written + CDmAttribute **ppAttributes = ( CDmAttribute** )_alloca( pElement->AttributeCount() * sizeof( CDmAttribute* ) ); + int nAttributes = 0; + for ( CDmAttribute *pAttribute = pElement->FirstAttribute(); pAttribute; pAttribute = pAttribute->NextAttribute() ) + { + if ( pAttribute->IsFlagSet( FATTRIB_DONTSAVE ) ) + continue; + + ppAttributes[ nAttributes++ ] = pAttribute; + } + + // Now write them all out in reverse order, since FirstAttribute is actually the *last* attribute for perf reasons + for ( int i = nAttributes - 1; i >= 0; --i ) + { + CDmAttribute *pAttribute = ppAttributes[ i ]; + Assert( pAttribute ); + + const char *pName = pAttribute->GetName( ); + DmAttributeType_t nAttrType = pAttribute->GetType(); + if ( nAttrType != AT_ELEMENT ) + { + buf.Printf( "\"%s\" \"%s\" ", pName, g_pDataModel->GetAttributeNameForType( 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 CDmSerializerKeyValues2::SaveElement( CUtlBuffer& buf, CDmElementSerializationDictionary &dict, CDmElement *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_pDataModel->GetAttributeNameForType( 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 CDmSerializerKeyValues2::Serialize( CUtlBuffer &outBuf, CDmElement *pRoot ) +{ + SetSerializationDelimiter( GetCStringCharConversion() ); + SetSerializationArrayDelimiter( "," ); + + // Save elements, attribute links + CDmElementSerializationDictionary dict; + dict.BuildElementList( pRoot, m_bFlatMode ); + + // Save elements to buffer + DmElementDictHandle_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 CDmSerializerKeyValues2::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 ( !V_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 +//----------------------------------------------------------------------------- +CDmSerializerKeyValues2::TokenType_t CDmSerializerKeyValues2::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; + } + + token.EnsureCapacity( nLength ); + buf.Get( token.Base(), nLength ); + token.SeekGet( CUtlBuffer::SEEK_HEAD, 0 ); + token.SeekPut( CUtlBuffer::SEEK_HEAD, 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 +//----------------------------------------------------------------------------- +DmElementDictHandle_t CDmSerializerKeyValues2::CreateDmElement( const char *pElementType ) +{ + // See if we can create an element of that type + DmElementHandle_t hElement = g_pDataModel->CreateElement( pElementType, "", m_fileid ); + if ( hElement == DMELEMENT_HANDLE_INVALID ) + { + g_KeyValues2ErrorStack.ReportError("Element uses unknown element type %s\n", pElementType ); + return ELEMENT_DICT_HANDLE_INVALID; + } + + CDmElement *pElement = g_pDataModel->GetElement( hElement ); + CDmeElementAccessor::MarkBeingUnserialized( pElement, true ); + return m_ElementDict.InsertElement( pElement ); +} + + +//----------------------------------------------------------------------------- +// Reads an attribute for an element +//----------------------------------------------------------------------------- +bool CDmSerializerKeyValues2::UnserializeElementAttribute( CUtlBuffer &buf, DmElementDictHandle_t hElement, const char *pAttributeName, const char *pElementType ) +{ + CDmElement *pElement = m_ElementDict.GetElement( hElement ); + CDmAttribute *pAttribute = pElement->AddAttribute( pAttributeName, AT_ELEMENT ); + if ( !pAttribute ) + { + g_KeyValues2ErrorStack.ReportError("Attempted to read an attribute (\"%s\") of unknown type %s!\n", pAttributeName, pElementType ); + return false; + } + + DmElementDictHandle_t h; + bool bOk = UnserializeElement( buf, pElementType, &h ); + if ( bOk ) + { + CDmElement *pNewElement = m_ElementDict.GetElement( h ); + pAttribute->SetValue( pNewElement ? pNewElement->GetHandle() : DMELEMENT_HANDLE_INVALID ); + } + return bOk; +} + + +//----------------------------------------------------------------------------- +// Reads an attribute for an element array +//----------------------------------------------------------------------------- +bool CDmSerializerKeyValues2::UnserializeElementArrayAttribute( CUtlBuffer &buf, DmElementDictHandle_t hElement, const char *pAttributeName ) +{ + CDmElement *pElement = m_ElementDict.GetElement( hElement ); + CDmAttribute *pAttribute = pElement->AddAttribute( pAttributeName, AT_ELEMENT_ARRAY ); + if ( !pAttribute ) + { + g_KeyValues2ErrorStack.ReportError("Attempted to read an attribute (\"%s\") of an inappropriate type!\n", pAttributeName ); + return false; + } + + // Arrays first must have a '[' specified + TokenType_t token; + CUtlBuffer tokenBuf( 0, 0, CUtlBuffer::TEXT_BUFFER ); + 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_pDataModel->GetAttributeNameForType( 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 + { + DmElementDictHandle_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 CDmSerializerKeyValues2::UnserializeAttributeValueFromToken( CDmAttribute *pAttribute, 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 = ( pAttribute->GetType() == AT_STRING ) || ( pAttribute->GetType() == 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 ( pAttribute->GetType() < AT_FIRST_ARRAY_TYPE ) + { + bOk = pAttribute->Unserialize( buf ); + } + else + { + bOk = pAttribute->UnserializeElement( buf ); + } + + if ( bIsString ) + { + SetSerializationDelimiter( NULL ); + } + + return bOk; +} + + +//----------------------------------------------------------------------------- +// Reads an attribute for an element array +//----------------------------------------------------------------------------- +bool CDmSerializerKeyValues2::UnserializeArrayAttribute( CUtlBuffer &buf, DmElementDictHandle_t hElement, const char *pAttributeName, DmAttributeType_t nAttrType ) +{ + CDmElement *pElement = m_ElementDict.GetElement( hElement ); + CDmAttribute *pAttribute = pElement->AddAttribute( pAttributeName, nAttrType ); + if ( !pAttribute ) + { + g_KeyValues2ErrorStack.ReportError("Attempted to read an attribute (\"%s\") of an inappropriate type %s!\n", + pAttributeName, g_pDataModel->GetAttributeNameForType( nAttrType ) ); + return false; + } + + // Arrays first must have a '[' specified + TokenType_t token; + CUtlBuffer tokenBuf( 0, 0, CUtlBuffer::TEXT_BUFFER ); + 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, 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 CDmSerializerKeyValues2::UnserializeAttribute( CUtlBuffer &buf, + DmElementDictHandle_t hElement, const char *pAttributeName, DmAttributeType_t nAttrType ) +{ + // Read the attribute value + CUtlBuffer tokenBuf( 0, 0, CUtlBuffer::TEXT_BUFFER ); + 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; + } + + if ( ( nAttrType == AT_OBJECTID ) && !V_stricmp( pAttributeName, "id" ) ) + { + 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, m_idConflictResolution ); + + return true; + } + + CDmElement *pElement = m_ElementDict.GetElement( hElement ); + CDmAttribute *pAttribute = pElement->AddAttribute( pAttributeName, nAttrType ); + if ( !pAttribute ) + { + g_KeyValues2ErrorStack.ReportError("Attempted to read an attribute (\"%s\") of an inappropriate type %s!\n", + pAttributeName, g_pDataModel->GetAttributeNameForType( nAttrType ) ); + return false; + } + + 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, tokenBuf ) ) + return true; + + g_KeyValues2ErrorStack.ReportError("Error reading attribute \"%s\"", pAttributeName ); + return false; + } +} + + +/* +//----------------------------------------------------------------------------- +// Purpose: +// Input : includedKeys - +//----------------------------------------------------------------------------- +void KeyValues::AppendIncludedKeys( CUtlVector< KeyValues * >& includedKeys ) +{ + // Append any included keys, too... + int includeCount = includedKeys.Count(); + int i; + for ( i = 0; i < includeCount; i++ ) + { + KeyValues *kv = includedKeys[ i ]; + Assert( kv ); + + KeyValues *insertSpot = this; + while ( insertSpot->GetNextKey() ) + { + insertSpot = insertSpot->GetNextKey(); + } + + insertSpot->SetNextKey( kv ); + } +} + +void KeyValues::ParseIncludedKeys( char const *resourceName, const char *filetoinclude, + IBaseFileSystem* pFileSystem, const char *pPathID, CUtlVector< KeyValues * >& includedKeys ) +{ + Assert( resourceName ); + Assert( filetoinclude ); + Assert( pFileSystem ); + + // Load it... + if ( !pFileSystem ) + { + return; + } + + // Get relative subdirectory + char fullpath[ 512 ]; + Q_strncpy( fullpath, resourceName, sizeof( fullpath ) ); + + // Strip off characters back to start or first / + bool done = false; + int len = Q_strlen( fullpath ); + while ( !done ) + { + if ( len <= 0 ) + { + break; + } + + if ( fullpath[ len - 1 ] == '\\' || + fullpath[ len - 1 ] == '/' ) + { + break; + } + + // zero it + fullpath[ len - 1 ] = 0; + --len; + } + + // Append included file + Q_strncat( fullpath, filetoinclude, sizeof( fullpath ), COPY_ALL_CHARACTERS ); + + KeyValues *newKV = new KeyValues( fullpath ); + + // CUtlSymbol save = s_CurrentFileSymbol; // did that had any use ??? + + newKV->UsesEscapeSequences( m_bHasEscapeSequences ); // use same format as parent + + if ( newKV->LoadFromFile( pFileSystem, fullpath, pPathID ) ) + { + includedKeys.AddToTail( newKV ); + } + else + { + DevMsg( "KeyValues::ParseIncludedKeys: Couldn't load included keyvalue file %s\n", fullpath ); + newKV->deleteThis(); + } + + // s_CurrentFileSymbol = save; +} + +//----------------------------------------------------------------------------- +// Read from a buffer... +//----------------------------------------------------------------------------- +bool KeyValues::LoadFromBuffer( char const *resourceName, const char *pBuffer, IBaseFileSystem* pFileSystem , const char *pPathID ) +{ + char *pfile = const_cast(pBuffer); + + KeyValues *pPreviousKey = NULL; + KeyValues *pCurrentKey = this; + CUtlVector< KeyValues * > includedKeys; + bool wasQuoted; + g_KeyValues2ErrorStack.SetFilename( resourceName ); + do + { + // the first thing must be a key + const char *s = ReadToken( &pfile, wasQuoted ); + + if ( !pfile || !s || *s == 0 ) + break; + + if ( !Q_stricmp( s, "#include" ) ) // special include macro (not a key name) + { + s = ReadToken( &pfile, wasQuoted ); + // Name of subfile to load is now in s + + if ( !s || *s == 0 ) + { + g_KeyValues2ErrorStack.ReportError("#include is NULL " ); + } + else + { + ParseIncludedKeys( resourceName, s, pFileSystem, pPathID, includedKeys ); + } + + continue; + } + + if ( !pCurrentKey ) + { + pCurrentKey = new KeyValues( s ); + Assert( pCurrentKey ); + + pCurrentKey->UsesEscapeSequences( m_bHasEscapeSequences ); // same format has parent use + + if ( pPreviousKey ) + { + pPreviousKey->SetNextKey( pCurrentKey ); + } + } + else + { + pCurrentKey->SetName( s ); + } + + // get the '{' + s = ReadToken( &pfile, wasQuoted ); + + if ( s && *s == '{' && !wasQuoted ) + { + // header is valid so load the file + pCurrentKey->RecursiveLoadFromBuffer( resourceName, &pfile ); + } + else + { + g_KeyValues2ErrorStack.ReportError("LoadFromBuffer: missing {" ); + } + + pPreviousKey = pCurrentKey; + pCurrentKey = NULL; + } while ( pfile != NULL ); + + AppendIncludedKeys( includedKeys ); + + g_KeyValues2ErrorStack.SetFilename( "" ); + + return true; +} +*/ + + +//----------------------------------------------------------------------------- +// Unserializes a single element given the type name +//----------------------------------------------------------------------------- +bool CDmSerializerKeyValues2::UnserializeElement( CUtlBuffer &buf, const char *pElementType, DmElementDictHandle_t *pHandle ) +{ + *pHandle = ELEMENT_DICT_HANDLE_INVALID; + + // Create the element + DmElementDictHandle_t hElement = CreateDmElement( pElementType ); + if ( hElement == ELEMENT_DICT_HANDLE_INVALID ) + return false; + + // Report errors relative to this type name + CKeyValues2ErrorContext errorReport( pElementType ); + + TokenType_t token; + CUtlBuffer tokenBuf( 0, 0, CUtlBuffer::TEXT_BUFFER ); + 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 = g_pDataModel->GetAttributeTypeForName( pAttributeType ); + + // 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 CDmSerializerKeyValues2::UnserializeElement( CUtlBuffer &buf, DmElementDictHandle_t *pHandle ) +{ + *pHandle = ELEMENT_DICT_HANDLE_INVALID; + + // First, read the type name + CUtlBuffer tokenBuf( 0, 0, CUtlBuffer::TEXT_BUFFER ); + 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 CDmSerializerKeyValues2::Unserialize( CUtlBuffer &buf, const char *pEncodingName, int nEncodingVersion, + const char *pSourceFormatName, int nSourceFormatVersion, + DmFileId_t fileid, DmConflictResolution_t idConflictResolution, CDmElement **ppRoot ) +{ + bool bSuccess = UnserializeElements( buf, fileid, idConflictResolution, ppRoot ); + if ( !bSuccess ) + return false; + + return g_pDataModel->UpdateUnserializedElements( pSourceFormatName, nSourceFormatVersion, fileid, idConflictResolution, ppRoot ); +} + +bool CDmSerializerKeyValues2::UnserializeElements( CUtlBuffer &buf, DmFileId_t fileid, DmConflictResolution_t idConflictResolution, CDmElement **ppRoot ) +{ + *ppRoot = NULL; + + m_idConflictResolution = idConflictResolution; + + m_fileid = fileid; + + g_KeyValues2ErrorStack.SetFilename( g_pDataModel->GetFileName( fileid ) ); + m_hRoot = ELEMENT_DICT_HANDLE_INVALID; + m_ElementDict.Clear(); + + bool bOk = true; + while ( buf.IsValid() ) + { + DmElementDictHandle_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 ); + + // mark all unserialized elements as done unserializing, and call Resolve() + for ( DmElementDictHandle_t h = m_ElementDict.FirstElement(); + h != ELEMENT_DICT_HANDLE_INVALID; + h = m_ElementDict.NextElement( h ) ) + { + CDmElement *pElement = m_ElementDict.GetElement( h ); + if ( !pElement ) + continue; + + CDmeElementAccessor::MarkBeingUnserialized( pElement, false ); + } + + m_fileid = DMFILEID_INVALID; + + g_pDmElementFrameworkImp->RemoveCleanElementsFromDirtyList( ); + m_ElementDict.Clear(); + return bOk; +} -- cgit v1.2.3