void asCRestore::WriteGlobalVarPointers()
{
int c = module->globalVarPointers.GetLength();
WRITE_NUM(c);
for( int n = 0; n < c; n++ )
{
asDWORD *p = (asDWORD*)module->globalVarPointers[n];
int idx = 0;
// Is it a module global or engine global?
if( p >= module->globalMem.AddressOf() && p <= module->globalMem.AddressOf() + module->globalMem.GetLength() )
idx = (asDWORD(p) - asDWORD(module->globalMem.AddressOf()))/4;
else
{
for( int i = 0; i < (signed)engine->globalPropAddresses.GetLength(); i++ )
{
if( engine->globalPropAddresses[i] == p )
{
idx = -i - 1;
break;
}
}
assert( idx != 0 );
}
WRITE_NUM(idx);
}
}
void asCRestore::WriteObjectTypeDeclaration(asCObjectType *ot, bool writeProperties)
{
if( !writeProperties )
{
// name
WriteString(&ot->name);
// size
int size = ot->size;
WRITE_NUM(size);
// flags
asDWORD flags = ot->flags;
WRITE_NUM(flags);
}
else
{
if( ot->flags & asOBJ_ENUM )
{
// enumValues[]
int size = (int)ot->enumValues.GetLength();
WRITE_NUM(size);
for( int n = 0; n < size; n++ )
{
WriteString(&ot->enumValues[n]->name);
WRITE_NUM(ot->enumValues[n]->value);
}
}
else if( ot->flags & asOBJ_TYPEDEF )
{
eToke
int writeTask(FILE *outputFile, void *task){
int endedTasks, metaSize, taskState;
Task *auxTask = (Task *)task;
pthread_mutex_lock(&dependsOnMeMutex);
writeTaskIdList(outputFile, (void *)auxTask->dependsOnMe);
pthread_mutex_unlock(&dependsOnMeMutex);
writeTaskIdList(outputFile, auxTask->myDeps);
HashIntVoid *children = auxTask->children;
hashIntVoidSerialize(outputFile, children);
int id = getTaskId(auxTask);
WRITE_NUM(outputFile, "id", id);
endedTasks = getTaskEndedTasks(auxTask);
WRITE_NUM(outputFile, "endedTasks", endedTasks);
metaSize = getTaskMetasize(auxTask);
WRITE_NUM(outputFile, "metaSize", metaSize);
WRITE_BYTES(outputFile, getTaskMetadata(auxTask), metaSize);
taskState = getTaskState(auxTask);
WRITE_NUM(outputFile, "taskState", taskState);
writeDataSpace(outputFile, getTaskDataSpace(task));
return 1;
}
////////////// Funcs to write the IntVector to File/////////////////
int WRITE_IV(FILE *outputFile, void *vet){
int i, element, vetSize = intVectorGetSize((IntVector *)vet);
WRITE_NUM(outputFile, "vetSize", vetSize);
for(i = 0; i < vetSize; i++){
element = intVectorGet((IntVector *)vet, i);
WRITE_NUM(outputFile, "element", element);
}
return 1;
}
void asCRestore::WriteGlobalVarPointers()
{
int c = (int)module->globalVarPointers.GetLength();
WRITE_NUM(c);
for( int n = 0; n < c; n++ )
{
void *p = (void*)module->globalVarPointers[n];
int i = FindGlobalPropPtrIndex(p);
WRITE_NUM(i);
}
}
void asCRestore::WriteObjectType(asCObjectType* ot)
{
char ch;
// Only write the object type name
if( ot )
{
// Check for template instances/specializations
if( ot->templateSubType.GetTokenType() != ttUnrecognizedToken &&
ot != engine->defaultArrayObjectType )
{
ch = 'a';
WRITE_NUM(ch);
if( ot->templateSubType.IsObject() )
{
ch = 's';
WRITE_NUM(ch);
WriteObjectType(ot->templateSubType.GetObjectType());
if( ot->templateSubType.IsObjectHandle() )
ch = 'h';
else
ch = 'o';
WRITE_NUM(ch);
}
else
{
ch = 't';
WRITE_NUM(ch);
eTokenType t = ot->templateSubType.GetTokenType();
WRITE_NUM(t);
}
}
else if( ot->flags & asOBJ_TEMPLATE_SUBTYPE )
{
ch = 's';
WRITE_NUM(ch);
WriteString(&ot->name);
}
else
{
ch = 'o';
WRITE_NUM(ch);
WriteString(&ot->name);
}
}
else
{
ch = '\0';
WRITE_NUM(ch);
// Write a null string
asDWORD null = 0;
WRITE_NUM(null);
}
}
void asCRestore::WriteDataType(const asCDataType *dt)
{
bool b;
int t = dt->GetTokenType();
WRITE_NUM(t);
WriteObjectType(dt->GetObjectType());
b = dt->IsObjectHandle();
WRITE_NUM(b);
b = dt->IsReadOnly();
WRITE_NUM(b);
b = dt->IsHandleToConst();
WRITE_NUM(b);
b = dt->IsReference();
WRITE_NUM(b);
}
void asCRestore::WriteUsedTypeIds()
{
int count = usedTypeIds.GetLength();
WRITE_NUM(count);
for( int n = 0; n < count; n++ )
WriteDataType(engine->GetDataTypeFromTypeId(usedTypeIds[n]));
}
void asCRestore::WriteUsedStringConstants()
{
asUINT count = (asUINT)usedStringConstants.GetLength();
WRITE_NUM(count);
for( asUINT i = 0; i < count; ++i )
WriteString(engine->stringConstants[i]);
}
void asCRestore::WriteUsedGlobalProps()
{
int c = (int)usedGlobalProperties.GetLength();
WRITE_NUM(c);
for( int n = 0; n < c; n++ )
{
size_t *p = (size_t*)usedGlobalProperties[n];
// First search for the global in the module
char moduleProp = 0;
asCGlobalProperty *prop = 0;
for( int i = 0; i < (signed)module->scriptGlobals.GetLength(); i++ )
{
if( p == module->scriptGlobals[i]->GetAddressOfValue() )
{
prop = module->scriptGlobals[i];
moduleProp = 1;
break;
}
}
// If it is not in the module, it must be an application registered property
if( !prop )
{
for( int i = 0; i < (signed)engine->registeredGlobalProps.GetLength(); i++ )
{
if( engine->registeredGlobalProps[i]->GetAddressOfValue() == p )
{
prop = engine->registeredGlobalProps[i];
break;
}
}
}
asASSERT(prop);
// Store the name and type of the property so we can find it again on loading
WriteString(&prop->name);
WriteDataType(&prop->type);
// Also store whether the property is a module property or a registered property
WRITE_NUM(moduleProp);
}
}
void asCRestore::WriteUsedFunctions()
{
asUINT count = (asUINT)usedFunctions.GetLength();
WRITE_NUM(count);
for( asUINT n = 0; n < usedFunctions.GetLength(); n++ )
{
char c;
// Write enough data to be able to uniquely identify the function upon load
// Is the function from the module or the application?
c = usedFunctions[n]->module ? 'm' : 'a';
WRITE_NUM(c);
WriteFunctionSignature(usedFunctions[n]);
}
}
void asCRestore::WriteByteCode(asDWORD *bc, int length)
{
while( length )
{
asDWORD c = (*bc)&0xFF;
WRITE_NUM(*bc);
bc += 1;
if( c == BC_ALLOC || c == BC_FREE ||
c == BC_REFCPY || c == BC_OBJTYPE )
{
// Translate object type pointers into indices
asDWORD tmp[MAX_DATA_SIZE];
int n;
for( n = 0; n < asCByteCode::SizeOfType(bcTypes[c])-1; n++ )
tmp[n] = *bc++;
*(int*)tmp = FindObjectTypeIdx(*(asCObjectType**)tmp);
for( n = 0; n < asCByteCode::SizeOfType(bcTypes[c])-1; n++ )
WRITE_NUM(tmp[n]);
}
else if( c == BC_TYPEID )
{
// Translate type ids into indices
asDWORD tmp[MAX_DATA_SIZE];
int n;
for( n = 0; n < asCByteCode::SizeOfType(bcTypes[c])-1; n++ )
tmp[n] = *bc++;
*(int*)tmp = FindTypeIdIdx(*(int*)tmp);
for( n = 0; n < asCByteCode::SizeOfType(bcTypes[c])-1; n++ )
WRITE_NUM(tmp[n]);
}
else
{
// Store the bc as is
for( int n = 1; n < asCByteCode::SizeOfType(bcTypes[c]); n++ )
WRITE_NUM(*bc++);
}
length -= asCByteCode::SizeOfType(bcTypes[c]);
}
}
void asCRestore::WriteObjectTypeDeclaration(asCObjectType *ot)
{
// name
WriteString(&ot->name);
// size
int size = ot->size;
WRITE_NUM(size);
// properties[]
size = ot->properties.GetLength();
WRITE_NUM(size);
for( asUINT n = 0; n < ot->properties.GetLength(); n++ )
{
WriteProperty(ot->properties[n]);
}
// TODO:
// methods[]
// behaviours
}
/// writeChildTask() writes only the necessary to
int writeChildTask(FILE *outputFile, void *task){
int metaSize = 0;
Task *auxTask = (Task *)task;
pthread_mutex_lock(&dependsOnMeMutex);
writeTaskIdList(outputFile, (void *)auxTask->dependsOnMe);
pthread_mutex_unlock(&dependsOnMeMutex);
writeTaskIdList(outputFile, auxTask->myDeps);
int id = getTaskId(auxTask);
WRITE_NUM(outputFile, "id", id);
metaSize = getTaskMetasize(auxTask);
WRITE_NUM(outputFile, "metaSize", metaSize);
WRITE_BYTES(outputFile, getTaskMetadata(auxTask), metaSize);
return 1;
}
void asCRestore::WriteFunctionSignature(asCScriptFunction *func)
{
asUINT i, count;
WriteString(&func->name);
WriteDataType(&func->returnType);
count = (asUINT)func->parameterTypes.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
WriteDataType(&func->parameterTypes[i]);
count = (asUINT)func->inOutFlags.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
WRITE_NUM(func->inOutFlags[i]);
WRITE_NUM(func->funcType);
WriteObjectType(func->objectType);
WRITE_NUM(func->isReadOnly);
}
void asCRestore::WriteObjectType(asCObjectType* ot)
{
char ch;
// Only write the object type name
if( ot )
{
if( ot->flags & asOBJ_SCRIPT_ARRAY && ot->name != asDEFAULT_ARRAY )
{
ch = 'a';
WRITE_NUM(ch);
if( ot->subType )
{
ch = 's';
WRITE_NUM(ch);
WriteObjectType(ot->subType);
ch = ot->arrayType & 1 ? 'h' : 'o';
WRITE_NUM(ch);
}
else
{
ch = 't';
WRITE_NUM(ch);
WRITE_NUM(ot->tokenType);
}
}
else
{
ch = 'o';
WRITE_NUM(ch);
WriteString(&ot->name);
}
}
else
{
ch = '\0';
WRITE_NUM(ch);
// Write a null string
asDWORD null = 0;
WRITE_NUM(null);
}
}
void asCRestore::WriteFunction(asCScriptFunction* func)
{
int i, count;
WriteString(&func->name);
WriteDataType(&func->returnType);
count = func->parameterTypes.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
WriteDataType(&func->parameterTypes[i]);
WRITE_NUM(func->id);
count = func->byteCode.GetLength();
WRITE_NUM(count);
WriteByteCode(func->byteCode.AddressOf(), count);
count = func->objVariablePos.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
{
WriteObjectType(func->objVariableTypes[i]);
WRITE_NUM(func->objVariablePos[i]);
}
WRITE_NUM(func->stackNeeded);
WriteObjectType(func->objectType);
int length = func->lineNumbers.GetLength();
WRITE_NUM(length);
for( i = 0; i < length; ++i )
WRITE_NUM(func->lineNumbers[i]);
}
void asCRestore::WriteFunction(asCScriptFunction* func)
{
char c;
// If there is no function, then store a null char
if( func == 0 )
{
c = '\0';
WRITE_NUM(c);
return;
}
// First check if the function has been saved already
for( asUINT f = 0; f < savedFunctions.GetLength(); f++ )
{
if( savedFunctions[f] == func )
{
c = 'r';
WRITE_NUM(c);
WRITE_NUM(f);
return;
}
}
// Keep a reference to the function in the list
savedFunctions.PushLast(func);
c = 'f';
WRITE_NUM(c);
asUINT i, count;
WriteFunctionSignature(func);
count = (asUINT)func->byteCode.GetLength();
WRITE_NUM(count);
WriteByteCode(func->byteCode.AddressOf(), count);
count = (asUINT)func->objVariablePos.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
{
WriteObjectType(func->objVariableTypes[i]);
WRITE_NUM(func->objVariablePos[i]);
}
WRITE_NUM(func->stackNeeded);
asUINT length = (asUINT)func->lineNumbers.GetLength();
WRITE_NUM(length);
for( i = 0; i < length; ++i )
WRITE_NUM(func->lineNumbers[i]);
WRITE_NUM(func->vfTableIdx);
WriteGlobalVarPointers(func);
// TODO: Write variables
// TODO: Store script section index
}
void asCRestore::WriteString(asCString* str)
{
asUINT len = (asUINT)str->GetLength();
WRITE_NUM(len);
stream->Write(str->AddressOf(), (asUINT)len);
}
void asCRestore::WriteObjectTypeDeclaration(asCObjectType *ot, bool writeProperties)
{
if( !writeProperties )
{
// name
WriteString(&ot->name);
// size
int size = ot->size;
WRITE_NUM(size);
// flags
asDWORD flags = ot->flags;
WRITE_NUM(flags);
}
else
{
if( ot->flags & asOBJ_ENUM )
{
// enumValues[]
int size = (int)ot->enumValues.GetLength();
WRITE_NUM(size);
for( int n = 0; n < size; n++ )
{
WriteString(&ot->enumValues[n]->name);
WRITE_NUM(ot->enumValues[n]->value);
}
}
else if( ot->flags & asOBJ_TYPEDEF )
{
eTokenType t = ot->templateSubType.GetTokenType();
WRITE_NUM(t);
}
else
{
WriteObjectType(ot->derivedFrom);
// interfaces[]
int size = (asUINT)ot->interfaces.GetLength();
WRITE_NUM(size);
asUINT n;
for( n = 0; n < ot->interfaces.GetLength(); n++ )
{
WriteObjectType(ot->interfaces[n]);
}
// properties[]
size = (asUINT)ot->properties.GetLength();
WRITE_NUM(size);
for( n = 0; n < ot->properties.GetLength(); n++ )
{
WriteObjectProperty(ot->properties[n]);
}
// behaviours
if( !ot->IsInterface() && ot->flags != asOBJ_TYPEDEF && ot->flags != asOBJ_ENUM )
{
WriteFunction(engine->scriptFunctions[ot->beh.construct]);
WriteFunction(engine->scriptFunctions[ot->beh.destruct]);
WriteFunction(engine->scriptFunctions[ot->beh.factory]);
size = (int)ot->beh.constructors.GetLength() - 1;
WRITE_NUM(size);
for( n = 1; n < ot->beh.constructors.GetLength(); n++ )
{
WriteFunction(engine->scriptFunctions[ot->beh.constructors[n]]);
WriteFunction(engine->scriptFunctions[ot->beh.factories[n]]);
}
}
// methods[]
size = (int)ot->methods.GetLength();
WRITE_NUM(size);
for( n = 0; n < ot->methods.GetLength(); n++ )
{
WriteFunction(engine->scriptFunctions[ot->methods[n]]);
}
// virtualFunctionTable[]
size = (int)ot->virtualFunctionTable.GetLength();
WRITE_NUM(size);
for( n = 0; n < (asUINT)size; n++ )
{
WriteFunction(ot->virtualFunctionTable[n]);
}
}
}
}
void asCRestore::WriteObjectProperty(asCObjectProperty* prop)
{
WriteString(&prop->name);
WriteDataType(&prop->type);
WRITE_NUM(prop->byteOffset);
}
void asCRestore::WriteString(asCString* str)
{
unsigned long len = str->GetLength();
WRITE_NUM(len);
stream->Write(str->AddressOf(), len);
}
int asCRestore::Save()
{
unsigned long i, count;
// Store everything in the same order that the builder parses scripts
// Store enums
count = (asUINT)module->enumTypes.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; i++ )
{
WriteObjectTypeDeclaration(module->enumTypes[i], false);
WriteObjectTypeDeclaration(module->enumTypes[i], true);
}
// Store type declarations first
count = (asUINT)module->classTypes.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; i++ )
{
// Store only the name of the class/interface types
WriteObjectTypeDeclaration(module->classTypes[i], false);
}
// Now store all interface methods
for( i = 0; i < count; i++ )
{
if( module->classTypes[i]->IsInterface() )
WriteObjectTypeDeclaration(module->classTypes[i], true);
}
// Then store the class methods, properties, and behaviours
for( i = 0; i < count; ++i )
{
if( !module->classTypes[i]->IsInterface() )
WriteObjectTypeDeclaration(module->classTypes[i], true);
}
// Store typedefs
count = (asUINT)module->typeDefs.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; i++ )
{
WriteObjectTypeDeclaration(module->typeDefs[i], false);
WriteObjectTypeDeclaration(module->typeDefs[i], true);
}
// scriptGlobals[]
count = (asUINT)module->scriptGlobals.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
WriteGlobalProperty(module->scriptGlobals[i]);
// scriptFunctions[]
count = 0;
for( i = 0; i < module->scriptFunctions.GetLength(); i++ )
if( module->scriptFunctions[i]->objectType == 0 )
count++;
WRITE_NUM(count);
for( i = 0; i < module->scriptFunctions.GetLength(); ++i )
if( module->scriptFunctions[i]->objectType == 0 )
WriteFunction(module->scriptFunctions[i]);
// globalFunctions[]
count = (int)module->globalFunctions.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; i++ )
{
WriteFunction(module->globalFunctions[i]);
}
// bindInformations[]
count = (asUINT)module->bindInformations.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
{
WriteFunction(module->bindInformations[i]->importedFunctionSignature);
WriteString(&module->bindInformations[i]->importFromModule);
}
// usedTypes[]
count = (asUINT)usedTypes.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
{
WriteObjectType(usedTypes[i]);
}
// usedTypeIds[]
WriteUsedTypeIds();
// usedFunctions[]
WriteUsedFunctions();
// usedGlobalProperties[]
WriteUsedGlobalProps();
// usedStringConstants[]
WriteUsedStringConstants();
// TODO: Store script section names
return asSUCCESS;
}
void asCRestore::WriteDataType(const asCDataType *dt)
{
if( dt->IsScriptArray() )
{
bool b = true;
WRITE_NUM(b);
b = dt->IsObjectHandle();
WRITE_NUM(b);
b = dt->IsReadOnly();
WRITE_NUM(b);
b = dt->IsHandleToConst();
WRITE_NUM(b);
b = dt->IsReference();
WRITE_NUM(b);
asCDataType sub = dt->GetSubType();
WriteDataType(&sub);
}
else
{
bool b = false;
WRITE_NUM(b);
int t = dt->GetTokenType();
WRITE_NUM(t);
WriteObjectType(dt->GetObjectType());
b = dt->IsObjectHandle();
WRITE_NUM(b);
b = dt->IsReadOnly();
WRITE_NUM(b);
b = dt->IsHandleToConst();
WRITE_NUM(b);
b = dt->IsReference();
WRITE_NUM(b);
}
}
int asCRestore::Save()
{
unsigned long i, count;
// structTypes[]
count = module->structTypes.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
{
WriteObjectTypeDeclaration(module->structTypes[i]);
}
// usedTypeIndices[]
count = module->usedTypes.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
{
WriteObjectType(module->usedTypes[i]);
}
// scriptGlobals[]
count = module->scriptGlobals.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
WriteProperty(module->scriptGlobals[i]);
// globalMem size (can restore data using @init())
count = module->globalMem.GetLength();
WRITE_NUM(count);
// globalVarPointers[]
WriteGlobalVarPointers();
// initFunction
WriteFunction(&module->initFunction);
// scriptFunctions[]
count = module->scriptFunctions.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
WriteFunction(module->scriptFunctions[i]);
// stringConstants[]
count = module->stringConstants.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
WriteString(module->stringConstants[i]);
// importedFunctions[] and bindInformations[]
count = module->importedFunctions.GetLength();
WRITE_NUM(count);
for( i = 0; i < count; ++i )
{
WriteFunction(module->importedFunctions[i]);
WRITE_NUM(module->bindInformations[i].importFrom);
}
// usedTypeIds[]
WriteUsedTypeIds();
return asSUCCESS;
}
void asCRestore::WriteProperty(asCProperty* prop)
{
WriteString(&prop->name);
WriteDataType(&prop->type);
WRITE_NUM(prop->index);
}
void asCRestore::WriteByteCode(asDWORD *bc, int length)
{
while( length )
{
asDWORD c = *(asBYTE*)bc;
WRITE_NUM(*bc);
bc += 1;
if( c == asBC_ALLOC )
{
asDWORD tmp[MAX_DATA_SIZE];
int n;
for( n = 0; n < asBCTypeSize[asBCInfo[c].type]-1; n++ )
tmp[n] = *bc++;
// Translate the object type
asCObjectType *ot = *(asCObjectType**)tmp;
*(int*)tmp = FindObjectTypeIdx(ot);
// Translate the constructor func id, if it is a script class
if( ot->flags & asOBJ_SCRIPT_OBJECT )
*(int*)&tmp[AS_PTR_SIZE] = FindFunctionIndex(engine->scriptFunctions[*(int*)&tmp[AS_PTR_SIZE]]);
for( n = 0; n < asBCTypeSize[asBCInfo[c].type]-1; n++ )
WRITE_NUM(tmp[n]);
}
else if( c == asBC_FREE ||
c == asBC_REFCPY ||
c == asBC_OBJTYPE )
{
// Translate object type pointers into indices
asDWORD tmp[MAX_DATA_SIZE];
int n;
for( n = 0; n < asBCTypeSize[asBCInfo[c].type]-1; n++ )
tmp[n] = *bc++;
*(int*)tmp = FindObjectTypeIdx(*(asCObjectType**)tmp);
for( n = 0; n < asBCTypeSize[asBCInfo[c].type]-1; n++ )
WRITE_NUM(tmp[n]);
}
else if( c == asBC_TYPEID )
{
// Translate type ids into indices
asDWORD tmp[MAX_DATA_SIZE];
int n;
for( n = 0; n < asBCTypeSize[asBCInfo[c].type]-1; n++ )
tmp[n] = *bc++;
*(int*)tmp = FindTypeIdIdx(*(int*)tmp);
for( n = 0; n < asBCTypeSize[asBCInfo[c].type]-1; n++ )
WRITE_NUM(tmp[n]);
}
else if( c == asBC_CALL ||
c == asBC_CALLINTF ||
c == asBC_CALLSYS )
{
// Translate the function id
asDWORD tmp[MAX_DATA_SIZE];
int n;
for( n = 0; n < asBCTypeSize[asBCInfo[c].type]-1; n++ )
tmp[n] = *bc++;
*(int*)tmp = FindFunctionIndex(engine->scriptFunctions[*(int*)tmp]);
for( n = 0; n < asBCTypeSize[asBCInfo[c].type]-1; n++ )
WRITE_NUM(tmp[n]);
}
else
{
// Store the bc as is
for( int n = 1; n < asBCTypeSize[asBCInfo[c].type]; n++ )
WRITE_NUM(*bc++);
}
length -= asBCTypeSize[asBCInfo[c].type];
}
}
