void Stream::WriteBitmap(Stream* value)
{
WriteBoolean(value != NULL);
if (value != NULL)
Serialize(value);
}
/*----------------------------------------------------------------------
WriteStructureSchema
ecrit le schema de structure pointe' par pSS dans le fichier
de nom fileName.
Si code est nul, ecrit le schema avec un nouveau code
d'identification, sinon avec code comme code d'identification.
----------------------------------------------------------------------*/
ThotBool WriteStructureSchema (Name fileName, PtrSSchema pSS,
int code)
{
PtrTtAttribute pAttr;
int i, j;
/* ouvre le fichier */
outfile = TtaWriteOpen (fileName);
if (outfile == 0)
return False;
/* ecrit la partie fixe du schema de structure */
WriteName (pSS->SsName);
if (code == 0)
/* alloue un nouveau code d'identification au schema compile' */
WriteShort (UniqueIdent ());
else
/* le schema compile' a le code d'identification code */
WriteShort (code);
WriteName (pSS->SsDefaultPSchema);
WriteBoolean (pSS->SsExtension);
WriteShort (pSS->SsDocument);
WriteShort (pSS->SsRootElem);
WriteShort (pSS->SsNAttributes);
WriteShort (pSS->SsNRules);
WriteBoolean (pSS->SsExport);
WriteShort (pSS->SsNExceptions);
for (i = 0; i < pSS->SsNExceptions; i++)
WriteShort (pSS->SsException[i]);
/* ecrit le texte des constantes */
i = 0;
do
TtaWriteByte (outfile, pSS->SsConstBuffer[i++]);
while (pSS->SsConstBuffer[i - 1] != '\0' || pSS->SsConstBuffer[i] != '\0');
/* SsFirstDynNature */
TtaWriteByte (outfile, '\0');
/* ecrit les attributs */
for (i = 0; i < pSS->SsNAttributes; i++)
{
pAttr = pSS->SsAttribute->TtAttr[i];
WriteName (pAttr->AttrName);
WriteBoolean (pAttr->AttrGlobal);
WriteShort (pAttr->AttrFirstExcept);
WriteShort (pAttr->AttrLastExcept);
WriteAttributeType (pAttr->AttrType);
switch (pAttr->AttrType)
{
case AtNumAttr:
case AtTextAttr:
break;
case AtReferenceAttr:
WriteShort (pAttr->AttrTypeRef);
WriteName (pAttr->AttrTypeRefNature);
break;
case AtEnumAttr:
WriteShort (pAttr->AttrNEnumValues);
for (j = 0; j < pAttr->AttrNEnumValues; j++)
WriteName (pAttr->AttrEnumValue[j]);
break;
}
}
/* ecrit les regles de structure */
for (i = 0; i < pSS->SsNRules; i++)
WriteRule (pSS->SsRule->SrElem[i]);
/* ecrit les regles d'extension */
if (pSS->SsExtension)
{
WriteShort (pSS->SsNExtensRules);
for (i = 0; i < pSS->SsNExtensRules; i++)
WriteRule (&pSS->SsExtensBlock->EbExtensRule[i]);
}
TtaWriteClose (outfile);
return True;
}
bool CSave::WriteFields( const char *pname, void *pBaseData, const DataMap_t& dataMap, const TYPEDESCRIPTION *pFields, int fieldCount )
{
int i, j;
const TYPEDESCRIPTION *pTest;
int entityArray[ MAX_ENTITYARRAY ];
// Precalculate the number of empty fields
int actualCount = 0;
for( i = 0; i < fieldCount; i++ )
{
pTest = &pFields[ i ];
void *pOutputData;
pOutputData = ( ( char * ) pBaseData + pTest->fieldOffset );
if( ( pTest->flags & TypeDescFlag::SAVE ) && !DataEmpty( ( const char * ) pOutputData, pTest->fieldSize * g_SaveRestoreSizes[ pTest->fieldType ] ) )
++actualCount;
}
// Empty fields will not be written, write out the actual number of fields to be written
WriteInt( pname, &actualCount, 1 );
for( i = 0; i < fieldCount; i++ )
{
void *pOutputData;
pTest = &pFields[ i ];
pOutputData = ( ( char * ) pBaseData + pTest->fieldOffset );
// UNDONE: Must we do this twice?
//TODO: update CSaveRestoreBuffer to allow seeking to write to earlier locations. - Solokiller
if( !( pTest->flags & TypeDescFlag::SAVE ) || DataEmpty( ( const char * ) pOutputData, pTest->fieldSize * g_SaveRestoreSizes[ pTest->fieldType ] ) )
continue;
switch( pTest->fieldType )
{
case FIELD_FLOAT:
WriteFloat( pTest->fieldName, ( float * ) pOutputData, pTest->fieldSize );
break;
case FIELD_TIME:
WriteTime( pTest->fieldName, ( float * ) pOutputData, pTest->fieldSize );
break;
case FIELD_MODELNAME:
case FIELD_SOUNDNAME:
case FIELD_STRING:
WriteString( pTest->fieldName, ( int * ) pOutputData, pTest->fieldSize );
break;
case FIELD_CLASSPTR:
case FIELD_EVARS:
case FIELD_EDICT:
case FIELD_ENTITY:
case FIELD_EHANDLE:
if( pTest->fieldSize > MAX_ENTITYARRAY )
ALERT( at_error, "Can't save more than %d entities in an array!!!\n", MAX_ENTITYARRAY );
for( j = 0; j < pTest->fieldSize; j++ )
{
switch( pTest->fieldType )
{
case FIELD_EVARS:
entityArray[ j ] = EntityIndex( ( ( entvars_t ** ) pOutputData )[ j ] );
break;
case FIELD_CLASSPTR:
entityArray[ j ] = EntityIndex( ( ( CBaseEntity ** ) pOutputData )[ j ] );
break;
case FIELD_EDICT:
entityArray[ j ] = EntityIndex( ( ( edict_t ** ) pOutputData )[ j ] );
break;
case FIELD_ENTITY:
entityArray[ j ] = EntityIndex( ( ( EOFFSET * ) pOutputData )[ j ] );
break;
case FIELD_EHANDLE:
entityArray[ j ] = EntityIndex( ( CBaseEntity * ) ( ( ( EHANDLE * ) pOutputData )[ j ] ) );
break;
}
}
WriteInt( pTest->fieldName, entityArray, pTest->fieldSize );
break;
case FIELD_POSITION_VECTOR:
WritePositionVector( pTest->fieldName, ( float * ) pOutputData, pTest->fieldSize );
break;
case FIELD_VECTOR:
WriteVector( pTest->fieldName, ( float * ) pOutputData, pTest->fieldSize );
break;
case FIELD_BOOLEAN:
//TODO: should be written as a bit perhaps? - Solokiller
WriteBoolean( pTest->fieldName, ( bool* ) pOutputData, pTest->fieldSize );
break;
case FIELD_INTEGER:
WriteInt( pTest->fieldName, ( int * ) pOutputData, pTest->fieldSize );
break;
case FIELD_SHORT:
WriteData( pTest->fieldName, 2 * pTest->fieldSize, ( ( char * ) pOutputData ) );
break;
case FIELD_CHARACTER:
WriteData( pTest->fieldName, pTest->fieldSize, ( ( char * ) pOutputData ) );
break;
case FIELD_FUNCPTR:
WriteFunction( pTest->fieldName, ( void ** ) pOutputData, pTest->fieldSize, dataMap, *pTest );
break;
default:
ALERT( at_error, "Bad field type\n" );
}
}
return true;
}
/*----------------------------------------------------------------------
WriteRule ecrit une regle de structure
----------------------------------------------------------------------*/
static void WriteRule (SRule * pSRule)
{
int j;
WriteName (pSRule->SrName);
WriteShort (pSRule->SrNDefAttrs);
for (j = 0; j < pSRule->SrNDefAttrs; j++)
WriteShort (pSRule->SrDefAttr[j]);
for (j = 0; j < pSRule->SrNDefAttrs; j++)
WriteSignedShort (pSRule->SrDefAttrValue[j]);
for (j = 0; j < pSRule->SrNDefAttrs; j++)
WriteBoolean (pSRule->SrDefAttrModif[j]);
WriteShort (pSRule->SrNLocalAttrs);
for (j = 0; j < pSRule->SrNLocalAttrs; j++)
WriteShort (pSRule->SrLocalAttr->Num[j]);
for (j = 0; j < pSRule->SrNLocalAttrs; j++)
WriteBoolean (pSRule->SrRequiredAttr->Bln[j]);
WriteBoolean (pSRule->SrUnitElem);
WriteBoolean (pSRule->SrRecursive);
WriteBoolean (pSRule->SrExportedElem);
if (pSRule->SrExportedElem)
{
WriteShort (pSRule->SrExportContent);
WriteName (pSRule->SrNatExpContent);
}
WriteShort (pSRule->SrFirstExcept);
WriteShort (pSRule->SrLastExcept);
WriteShort (pSRule->SrNInclusions);
for (j = 0; j < pSRule->SrNInclusions; j++)
WriteShort (pSRule->SrInclusion[j]);
WriteShort (pSRule->SrNExclusions);
for (j = 0; j < pSRule->SrNExclusions; j++)
WriteShort (pSRule->SrExclusion[j]);
WriteBoolean (pSRule->SrRefImportedDoc);
WriteConstructor (pSRule->SrConstruct);
switch (pSRule->SrConstruct)
{
case CsNatureSchema:
/* don't write anything */
break;
case CsBasicElement:
WriteBasicType (pSRule->SrBasicType);
break;
case CsReference:
WriteShort (pSRule->SrReferredType);
WriteName (pSRule->SrRefTypeNat);
break;
case CsIdentity:
WriteShort (pSRule->SrIdentRule);
break;
case CsList:
WriteShort (pSRule->SrListItem);
WriteShort (pSRule->SrMinItems);
WriteShort (pSRule->SrMaxItems);
break;
case CsChoice:
WriteSignedShort (pSRule->SrNChoices);
if (pSRule->SrNChoices > 0)
for (j = 0; j < pSRule->SrNChoices; j++)
WriteShort (pSRule->SrChoice[j]);
break;
case CsAggregate:
case CsUnorderedAggregate:
WriteShort (pSRule->SrNComponents);
for (j = 0; j < pSRule->SrNComponents; j++)
WriteShort (pSRule->SrComponent[j]);
for (j = 0; j < pSRule->SrNComponents; j++)
WriteBoolean (pSRule->SrOptComponent[j]);
break;
case CsConstant:
WriteShort (pSRule->SrIndexConst);
break;
case CsPairedElement:
WriteBoolean (pSRule->SrFirstOfPair);
break;
case CsExtensionRule:
break;
case CsDocument:
case CsAny:
case CsEmpty:
break;
}
}
void PDF::WriteBoolean(const char * name, bool boolean)
{
WriteName(name);
WriteBoolean(boolean);
fputc('\n', file);
}
