void syncScript(Common::Serializer &s, scriptInstanceStruct *entry) {
int numScripts = 0;
uint32 dummyLong = 0;
uint16 dummyWord = 0;
if (s.isSaving()) {
// Figure out the number of scripts to save
scriptInstanceStruct* pCurrent = entry->nextScriptPtr;
while (pCurrent) {
++numScripts;
pCurrent = pCurrent->nextScriptPtr;
}
}
s.syncAsSint16LE(numScripts);
scriptInstanceStruct *ptr = entry->nextScriptPtr;
for (int i = 0; i < numScripts; ++i) {
if (s.isLoading())
ptr = (scriptInstanceStruct *)mallocAndZero(sizeof(scriptInstanceStruct));
s.syncAsUint16LE(dummyWord);
s.syncAsSint16LE(ptr->ccr);
s.syncAsSint16LE(ptr->scriptOffset);
s.syncAsUint32LE(dummyLong);
s.syncAsSint16LE(ptr->dataSize);
s.syncAsSint16LE(ptr->scriptNumber);
s.syncAsSint16LE(ptr->overlayNumber);
s.syncAsSint16LE(ptr->sysKey);
s.syncAsSint16LE(ptr->freeze);
s.syncAsSint16LE(ptr->type);
s.syncAsSint16LE(ptr->var16);
s.syncAsSint16LE(ptr->var18);
s.syncAsSint16LE(ptr->var1A);
s.syncAsSint16LE(ptr->dataSize);
if (ptr->dataSize) {
if (s.isLoading())
ptr->data = (byte *)mallocAndZero(ptr->dataSize);
s.syncBytes(ptr->data, ptr->dataSize);
}
if (s.isLoading()) {
ptr->nextScriptPtr = NULL;
entry->nextScriptPtr = ptr;
entry = ptr;
} else {
ptr = ptr->nextScriptPtr;
}
}
}
static void syncCell(Common::Serializer &s) {
int chunkCount = 0;
cellStruct *t, *p;
uint16 dummyWord = 0;
if (s.isSaving()) {
// Figure out the number of chunks to save
t = cellHead.next;
while (t) {
++chunkCount;
t = t->next;
}
} else {
cellHead.next = NULL; // Not in ASM code, but I guess the variable is defaulted in the EXE
}
s.syncAsSint16LE(chunkCount);
t = s.isSaving() ? cellHead.next : &cellHead;
for (int i = 0; i < chunkCount; ++i) {
p = s.isSaving() ? t : (cellStruct *)mallocAndZero(sizeof(cellStruct));
s.syncAsUint16LE(dummyWord);
s.syncAsUint16LE(dummyWord);
s.syncAsSint16LE(p->idx);
s.syncAsSint16LE(p->type);
s.syncAsSint16LE(p->overlay);
s.syncAsSint16LE(p->x);
s.syncAsSint16LE(p->field_C);
s.syncAsSint16LE(p->spriteIdx);
s.syncAsSint16LE(p->color);
s.syncAsSint16LE(p->backgroundPlane);
s.syncAsSint16LE(p->freeze);
s.syncAsSint16LE(p->parent);
s.syncAsSint16LE(p->parentOverlay);
s.syncAsSint16LE(p->parentType);
s.syncAsSint16LE(p->followObjectOverlayIdx);
s.syncAsSint16LE(p->followObjectIdx);
s.syncAsSint16LE(p->animStart);
s.syncAsSint16LE(p->animEnd);
s.syncAsSint16LE(p->animWait);
s.syncAsSint16LE(p->animStep);
s.syncAsSint16LE(p->animChange);
s.syncAsSint16LE(p->animType);
s.syncAsSint16LE(p->animSignal);
s.syncAsSint16LE(p->animCounter);
s.syncAsSint16LE(p->animLoop);
s.syncAsUint16LE(dummyWord);
if (s.isSaving())
t = t->next;
else {
p->next = NULL;
t->next = p;
p->prev = cellHead.prev;
cellHead.prev = p;
t = p;
}
}
}
static void syncCT(Common::Serializer &s) {
int v = (_vm->_polyStruct) ? 1 : 0;
s.syncAsSint32LE(v);
if (s.isLoading())
_vm->_polyStruct = (v != 0) ? &_vm->_polyStructNorm : NULL;
if (v == 0)
// There is no further data to load or save
return;
s.syncAsSint16LE(numberOfWalkboxes);
if (numberOfWalkboxes) {
for (int i = 0; i < numberOfWalkboxes; ++i)
s.syncAsSint16LE(walkboxColor[i]);
for (int i = 0; i < numberOfWalkboxes; ++i)
s.syncAsSint16LE(walkboxState[i]);
}
for (int i = 0; i < 10; i++) {
v = 0;
if (s.isSaving()) v = (persoTable[i]) ? 1 : 0;
s.syncAsSint32LE(v);
if (s.isLoading())
// Set up the pointer for the next structure
persoTable[i] = (v == 0) ? NULL : (persoStruct *)mallocAndZero(sizeof(persoStruct));
if (v != 0)
syncPerso(s, *persoTable[i]);
}
}
int _delayExec( char *inActionCall, char *recoveryActionCall,
char *delayCondition, ruleExecInfo_t *rei ) {
char *args[MAX_NUM_OF_ARGS_IN_ACTION];
int i, argc;
ruleExecSubmitInp_t *ruleSubmitInfo;
/* char action[MAX_ACTION_SIZE]; */
char tmpStr[NAME_LEN];
bytesBuf_t *packedReiAndArgBBuf = NULL;
char *ruleExecId;
char *actionCall;
RE_TEST_MACRO( " Calling _delayExec" );
actionCall = inActionCall;
/* Get Arguments */
actionCall = ( char * ) malloc( strlen( inActionCall ) + strlen( recoveryActionCall ) + 3 );
sprintf( actionCall, "%s|%s", inActionCall, recoveryActionCall );
args[1] = NULL;
argc = 0;
/* Pack Rei and Args */
i = packReiAndArg( rei->rsComm, rei, args, argc, &packedReiAndArgBBuf );
if ( i < 0 ) {
if ( actionCall != inActionCall ) {
free( actionCall );
}
return( i );
}
/* fill Conditions into Submit Struct */
ruleSubmitInfo = ( ruleExecSubmitInp_t * ) mallocAndZero( sizeof( ruleExecSubmitInp_t ) );
i = fillSubmitConditions( actionCall, delayCondition, packedReiAndArgBBuf, ruleSubmitInfo, rei );
if ( actionCall != inActionCall ) {
free( actionCall );
}
if ( i < 0 ) {
free( ruleSubmitInfo );
return( i );
}
/* Store ReiArgs Struct in a File */
i = rsRuleExecSubmit( rei->rsComm, ruleSubmitInfo, &ruleExecId );
if ( packedReiAndArgBBuf != NULL ) {
clearBBuf( packedReiAndArgBBuf );
free( packedReiAndArgBBuf );
}
free( ruleSubmitInfo );
if ( i < 0 ) {
return( i );
}
free( ruleExecId );
snprintf( tmpStr, NAME_LEN, "%d", i );
i = pushStack( &delayStack, tmpStr );
return( i );
}
/**
* \fn msiPropertiesNew( msParam_t *listParam, ruleExecInfo_t *rei )
*
* \brief Create a new empty property list
*
* \module properties
*
* \since pre-2.1
*
* \author David R. Nadeau / University of California, San Diego
* \date 2007
*
* \usage See clients/icommands/test/rules3.0/
*
* \param[out] listParam - a KeyValPair_MS_T, the newly created property list
* \param[in,out] rei - The RuleExecInfo structure that is automatically
* handled by the rule engine. The user does not include rei as a
* parameter in the rule invocation.
*
* \DolVarDependence none
* \DolVarModified none
* \iCatAttrDependence none
* \iCatAttrModified none
* \sideeffect none
*
* \return integer
* \retval 0 on success
* \pre none
* \post none
* \sa none
**/
int
msiPropertiesNew( msParam_t *listParam, ruleExecInfo_t *rei )
{
RE_TEST_MACRO( " Calling msiPropertiesNew" );
/* Create empty list */
fillMsParam( listParam, NULL,
KeyValPair_MS_T, mallocAndZero( sizeof(keyValPair_t) ), NULL );
return 0;
}
int getVolumeDataEntry(volumeDataStruct *entry) {
char buffer[256];
int i;
volumeNumEntry = 0;
volumeNumberOfEntry = 0;
if (_vm->_currentVolumeFile.isOpen()) {
freeDisk();
}
askDisk(-1);
strcpy(buffer, entry->ident);
_vm->_currentVolumeFile.open(buffer);
if (!_vm->_currentVolumeFile.isOpen()) {
return (-14);
}
changeCursor(CURSOR_DISK);
volumeNumberOfEntry = _vm->_currentVolumeFile.readSint16BE();
volumeSizeOfEntry = _vm->_currentVolumeFile.readSint16BE();
volumeNumEntry = volumeNumberOfEntry;
assert(volumeSizeOfEntry == 14 + 4 + 4 + 4 + 4);
volumePtrToFileDescriptor = (fileEntry *) mallocAndZero(sizeof(fileEntry) * volumeNumEntry);
for (i = 0; i < volumeNumEntry; i++) {
volumePtrToFileDescriptor[i].name[0] = 0;
volumePtrToFileDescriptor[i].offset = 0;
volumePtrToFileDescriptor[i].size = 0;
volumePtrToFileDescriptor[i].extSize = 0;
volumePtrToFileDescriptor[i].unk3 = 0;
}
for (i = 0; i < volumeNumEntry; i++) {
_vm->_currentVolumeFile.read(&volumePtrToFileDescriptor[i].name, 14);
volumePtrToFileDescriptor[i].offset = _vm->_currentVolumeFile.readSint32BE();
volumePtrToFileDescriptor[i].size = _vm->_currentVolumeFile.readSint32BE();
volumePtrToFileDescriptor[i].extSize = _vm->_currentVolumeFile.readSint32BE();
volumePtrToFileDescriptor[i].unk3 = _vm->_currentVolumeFile.readSint32BE();
}
strcpy(currentBaseName, entry->ident);
loadPal(entry);
return 0;
}
int
copyRescGrpInfo(rescGrpInfo_t *from, rescGrpInfo_t *to)
{
*to = *from;
if (from->next != NULL) {
to->next = (rescGrpInfo_t*)mallocAndZero(sizeof(rescGrpInfo_t));
copyRescGrpInfo(from->next,to->next);
}
else
to->next = NULL;
return(0);
}
int
copyCollInfo(collInfo_t *from, collInfo_t *to)
{
*to = *from;
if (from->next != NULL) {
to->next = (collInfo_t*)mallocAndZero(sizeof(collInfo_t));
copyCollInfo(from->next,to->next);
}
else
to->next = NULL;
return(0);
}
int
copyDataObjInfo(dataObjInfo_t *from, dataObjInfo_t *to)
{
*to = *from;
if (from->next != NULL) {
to->next = (dataObjInfo_t*)mallocAndZero(sizeof(dataObjInfo_t));
copyDataObjInfo(from->next,to->next);
}
else
to->next = NULL;
return(0);
}
/**
* \fn msiPropertiesClone( msParam_t *listParam, msParam_t *cloneParam, ruleExecInfo_t *rei )
*
* \brief Clone a property list, returning a new property list
*
* \module properties
*
* \since pre-2.1
*
* \author David R. Nadeau / University of California, San Diego
* \date 2007
*
* \usage See clients/icommands/test/rules3.0/
*
* \param[in] listParam - a KeyValPair_MS_T, the property list to clone
* \param[out] cloneParam - a KeyValPair_MS_T, the returned clone (new property list)
* \param[in,out] rei - The RuleExecInfo structure that is automatically
* handled by the rule engine. The user does not include rei as a
* parameter in the rule invocation.
*
* \DolVarDependence none
* \DolVarModified none
* \iCatAttrDependence none
* \iCatAttrModified none
* \sideeffect a new peoperty list is created
*
* \return integer
* \retval 0 on success
* \pre none
* \post none
* \sa none
**/
int
msiPropertiesClone( msParam_t *listParam, msParam_t *cloneParam, ruleExecInfo_t *rei )
{
RE_TEST_MACRO( " Calling msiPropertiesClone" );
/* Check parameters */
if ( strcmp( listParam->type, KeyValPair_MS_T ) != 0 )
return USER_PARAM_TYPE_ERR;
fillMsParam( cloneParam, NULL,
KeyValPair_MS_T, mallocAndZero( sizeof(keyValPair_t) ), NULL );
replKeyVal( (keyValPair_t*)listParam->inOutStruct, (keyValPair_t*)cloneParam->inOutStruct );
return 0;
}
static void syncActors(Common::Serializer &s) {
int numEntries = 0;
actorStruct *ptr;
uint16 dummyLong = 0;
if (s.isSaving()) {
ptr = actorHead.next;
while (ptr) {
++numEntries;
ptr = ptr->next;
}
}
s.syncAsSint16LE(numEntries);
ptr = s.isSaving() ? actorHead.next : &actorHead;
for (int i = 0; i < numEntries; ++i) {
actorStruct *p = s.isSaving() ? ptr : (actorStruct *)mallocAndZero(sizeof(actorStruct));
s.syncAsUint32LE(dummyLong);
s.syncAsSint16LE(p->idx);
s.syncAsSint16LE(p->type);
s.syncAsSint16LE(p->overlayNumber);
s.syncAsSint16LE(p->x_dest);
s.syncAsSint16LE(p->y_dest);
s.syncAsSint16LE(p->x);
s.syncAsSint16LE(p->y);
s.syncAsSint16LE(p->startDirection);
s.syncAsSint16LE(p->nextDirection);
s.syncAsSint16LE(p->endDirection);
s.syncAsSint16LE(p->stepX);
s.syncAsSint16LE(p->stepY);
s.syncAsSint16LE(p->pathId);
s.syncAsSint16LE(p->phase);
s.syncAsSint16LE(p->counter);
s.syncAsSint16LE(p->poly);
s.syncAsSint16LE(p->flag);
s.syncAsSint16LE(p->start);
s.syncAsSint16LE(p->freeze);
if (s.isSaving())
ptr = ptr->next;
else {
p->next = NULL;
ptr->next = p;
p->prev = actorHead.prev;
actorHead.prev = p;
ptr = p->next;
}
}
}
int
applyRuleForPostProcForRead( rsComm_t *rsComm, bytesBuf_t *dataObjReadOutBBuf, char *objPath ) {
if ( ReadWriteRuleState != ON_STATE ) {
return 0;
}
ruleExecInfo_t rei2;
memset( ( char* )&rei2, 0, sizeof( ruleExecInfo_t ) );
msParamArray_t msParamArray;
memset( ( char* )&msParamArray, 0, sizeof( msParamArray_t ) );
if ( rsComm != NULL ) {
rei2.rsComm = rsComm;
rei2.uoic = &rsComm->clientUser;
rei2.uoip = &rsComm->proxyUser;
}
rei2.doi = ( dataObjInfo_t* )mallocAndZero( sizeof( dataObjInfo_t ) );
snprintf( rei2.doi->objPath, sizeof( rei2.doi->objPath ), "%s", objPath );
memset( &msParamArray, 0, sizeof( msParamArray ) );
int * myInOutStruct = ( int* )malloc( sizeof( int ) );
*myInOutStruct = dataObjReadOutBBuf->len;
addMsParamToArray( &msParamArray, "*ReadBuf", BUF_LEN_MS_T, myInOutStruct,
dataObjReadOutBBuf, 0 );
int status = applyRule( "acPostProcForDataObjRead(*ReadBuf)", &msParamArray, &rei2,
NO_SAVE_REI );
free( rei2.doi );
if ( status < 0 ) {
if ( rei2.status < 0 ) {
status = rei2.status;
}
rodsLog( LOG_ERROR,
"rsDataObjRead: acPostProcForDataObjRead error=%d", status );
clearMsParamArray( &msParamArray, 0 );
return status;
}
clearMsParamArray( &msParamArray, 0 );
return 0;
}
int loadOverlay(const char *scriptName) {
int newNumberOfScript;
bool scriptNotLoadedBefore;
int scriptIdx;
char fileName[50];
int fileIdx;
int unpackedSize;
byte *unpackedBuffer;
ovlDataStruct *ovlData;
debug(1, "Load overlay: %s", scriptName);
newNumberOfScript = numOfLoadedOverlay;
scriptNotLoadedBefore = false;
scriptIdx = findOverlayByName((const char *)scriptName);
if (scriptIdx == -4) {
scriptIdx = numOfLoadedOverlay;
newNumberOfScript++;
scriptNotLoadedBefore = true;
}
if (overlayTable[scriptIdx].alreadyLoaded) {
return (scriptIdx);
}
overlayTable[scriptIdx].ovlData =
(ovlDataStruct *) mallocAndZero(sizeof(ovlDataStruct));
if (!overlayTable[scriptIdx].ovlData)
return (-2);
if (scriptName != overlayTable[scriptIdx].overlayName)
strcpy(overlayTable[scriptIdx].overlayName, scriptName);
overlayTable[scriptIdx].alreadyLoaded = 1;
numOfLoadedOverlay = newNumberOfScript;
overlayTable[scriptIdx].ovlData->scriptNumber = scriptIdx;
strcpy(fileName, scriptName);
strcat(fileName, ".OVL");
debug(1, "Attempting to load overlay file %s...", fileName);
fileIdx = findFileInDisks(fileName);
if (fileIdx < 0) {
warning("Unable to load overlay %s", scriptName);
//releaseScript(scriptName);
return (-18);
}
unpackedSize = volumePtrToFileDescriptor[fileIdx].extSize + 2;
// This memory block will be later passed to a MemoryReadStream, which will dispose of it
unpackedBuffer = (byte *)malloc(unpackedSize);
memset(unpackedBuffer, 0, unpackedSize);
if (!unpackedBuffer) {
return (-2);
}
if (volumePtrToFileDescriptor[fileIdx].size + 2 != unpackedSize) {
char *pakedBuffer =
(char *)mallocAndZero(volumePtrToFileDescriptor[fileIdx].
size + 2);
loadPackedFileToMem(fileIdx, (uint8 *) pakedBuffer);
delphineUnpack((uint8 *)unpackedBuffer, (const uint8 *)pakedBuffer, volumePtrToFileDescriptor[fileIdx].size);
MemFree(pakedBuffer);
} else {
loadPackedFileToMem(fileIdx, (uint8 *) unpackedBuffer);
}
debug(1, "OVL loading done...");
Common::MemoryReadStream s(unpackedBuffer, unpackedSize, DisposeAfterUse::YES);
unpackedBuffer = NULL;
ovlData = overlayTable[scriptIdx].ovlData;
// Skip pointers
s.skip(60);
ovlData->arrayProc = NULL;
ovlData->ptr1 = NULL;
ovlData->arrayObject = NULL;
ovlData->arrayStates = NULL;
ovlData->arrayObjVar = NULL;
ovlData->stringTable = NULL;
ovlData->arraySymbGlob = NULL;
ovlData->arrayRelocGlob = NULL;
ovlData->arrayMsgRelHeader = NULL;
ovlData->nameVerbGlob = NULL;
ovlData->arrayNameObj = NULL;
ovlData->arrayNameRelocGlob = NULL;
ovlData->arrayNameSymbGlob = NULL;
ovlData->data4Ptr = NULL;
ovlData->ptr8 = NULL;
ovlData->numProc = s.readUint16BE();
ovlData->numRel = s.readUint16BE();
ovlData->numSymbGlob = s.readUint16BE();
ovlData->numRelocGlob = s.readUint16BE();
ovlData->numMsgRelHeader = s.readUint16BE();
ovlData->numObj = s.readUint16BE();
ovlData->numStrings = s.readUint16BE();
ovlData->size8 = s.readUint16BE();
ovlData->size9 = s.readUint16BE();
ovlData->nameExportSize = s.readUint16BE();
ovlData->exportNamesSize = s.readUint16BE();
ovlData->specialString2Length = s.readUint16BE();
ovlData->sizeOfData4 = s.readUint16BE();
ovlData->size12 = s.readUint16BE();
ovlData->specialString1Length = s.readUint16BE();
ovlData->scriptNumber = s.readUint16BE();
if (ovlData->numSymbGlob) { // export data
int i;
ovlData->arraySymbGlob =
(exportEntryStruct *) mallocAndZero(ovlData->numSymbGlob * sizeof(exportEntryStruct));
if (!ovlData->arraySymbGlob) {
return (-2);
}
for (i = 0; i < ovlData->numSymbGlob; i++) {
ovlData->arraySymbGlob[i].var0 = s.readUint16BE();
ovlData->arraySymbGlob[i].var2 = s.readUint16BE();
ovlData->arraySymbGlob[i].var4 = s.readUint16BE();
ovlData->arraySymbGlob[i].idx = s.readUint16BE();
ovlData->arraySymbGlob[i].offsetToName = s.readUint16BE();
}
}
if (ovlData->exportNamesSize) { // export names
ovlData->arrayNameSymbGlob = (char *) mallocAndZero(ovlData->exportNamesSize);
if (!ovlData->arrayNameSymbGlob) {
return (-2);
}
s.read(ovlData->arrayNameSymbGlob, ovlData->exportNamesSize);
}
if (ovlData->numRelocGlob) { // import data
int i;
ovlData->arrayRelocGlob =
(importDataStruct *) mallocAndZero(ovlData->numRelocGlob *
sizeof(importDataStruct));
if (!ovlData->arrayRelocGlob) {
return (-2);
}
for (i = 0; i < ovlData->numRelocGlob; i++) {
ovlData->arrayRelocGlob[i].var0 = s.readUint16BE();
ovlData->arrayRelocGlob[i].var1 = s.readUint16BE();
ovlData->arrayRelocGlob[i].linkType = s.readUint16BE();
ovlData->arrayRelocGlob[i].linkIdx = s.readUint16BE();
ovlData->arrayRelocGlob[i].nameOffset = s.readUint16BE();
}
}
if (ovlData->nameExportSize) { // import name
ovlData->arrayNameRelocGlob = (char *) mallocAndZero(ovlData->nameExportSize);
if (!ovlData->arrayNameRelocGlob) {
return (-2);
}
s.read(ovlData->arrayNameRelocGlob, ovlData->nameExportSize);
}
if (ovlData->numMsgRelHeader) { // link data
int i;
ASSERT(sizeof(linkDataStruct) == 0x22);
ovlData->arrayMsgRelHeader = (linkDataStruct *) mallocAndZero(ovlData->numMsgRelHeader * sizeof(linkDataStruct));
if (!ovlData->arrayMsgRelHeader) {
return (-2);
}
for (i = 0; i < ovlData->numMsgRelHeader; i++) {
ovlData->arrayMsgRelHeader[i].type = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].id = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].offsetVerbeName = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].verbOverlay = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].verbNumber = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].obj1Overlay = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].obj1Number = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].obj2Overlay = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].obj2Number = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].trackX = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].trackY = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].obj1NewState = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].obj2NewState = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].obj1OldState = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].obj2OldState = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].trackDirection = s.readUint16BE();
ovlData->arrayMsgRelHeader[i].dialog = s.readUint16BE();
}
}
if (ovlData->numProc) { // script
ovlData3Struct *tempPtr;
int i;
ovlData->arrayProc =
(ovlData3Struct *) mallocAndZero(ovlData->numProc * sizeof(ovlData3Struct));
if (!ovlData->arrayProc) {
return (-2);
}
for (i = 0; i < ovlData->numProc; i++) {
s.skip(4);
ovlData->arrayProc[i].dataPtr = NULL;
ovlData->arrayProc[i].sizeOfData = s.readUint16BE();
ovlData->arrayProc[i].offsetToSubData3 = s.readUint16BE();
ovlData->arrayProc[i].offsetToImportData = s.readUint16BE();
ovlData->arrayProc[i].offsetToSubData2 = s.readUint16BE();
ovlData->arrayProc[i].offsetToImportName = s.readUint16BE();
ovlData->arrayProc[i].offsetToSubData5 = s.readUint16BE();
ovlData->arrayProc[i].sysKey = s.readUint16BE();
ovlData->arrayProc[i].var12 = s.readUint16BE();
ovlData->arrayProc[i].numRelocGlob = s.readUint16BE();
ovlData->arrayProc[i].subData2Size = s.readUint16BE();
ovlData->arrayProc[i].var18 = s.readUint16BE();
ovlData->arrayProc[i].var1A = s.readUint16BE();
}
tempPtr = ovlData->arrayProc;
for (i = 0; i < ovlData->numProc; i++) {
tempPtr->dataPtr = (uint8 *) mallocAndZero(tempPtr->sizeOfData);
if (!tempPtr->dataPtr) {
return (-2);
}
s.read(tempPtr->dataPtr, tempPtr->sizeOfData);
if (tempPtr->offsetToImportData) {
flipGen(tempPtr->dataPtr + tempPtr->offsetToImportData,
tempPtr->numRelocGlob * 10);
}
if (tempPtr->offsetToSubData2) {
flipGen(tempPtr->dataPtr + tempPtr->offsetToSubData2,
tempPtr->subData2Size * 10);
}
tempPtr++;
}
}
if (ovlData->numRel) {
ovlData3Struct *tempPtr;
int i;
ovlData->ptr1 =
(ovlData3Struct *) mallocAndZero(ovlData->numRel * sizeof(ovlData3Struct));
if (!ovlData->ptr1) {
return (-2);
}
for (i = 0; i < ovlData->numRel; i++) {
s.skip(4);
ovlData->ptr1[i].dataPtr = NULL;
ovlData->ptr1[i].sizeOfData = s.readUint16BE();
ovlData->ptr1[i].offsetToSubData3 = s.readUint16BE();
ovlData->ptr1[i].offsetToImportData = s.readUint16BE();
ovlData->ptr1[i].offsetToSubData2 = s.readUint16BE();
ovlData->ptr1[i].offsetToImportName = s.readUint16BE();
ovlData->ptr1[i].offsetToSubData5 = s.readUint16BE();
ovlData->ptr1[i].sysKey = s.readUint16BE();
ovlData->ptr1[i].var12 = s.readUint16BE();
ovlData->ptr1[i].numRelocGlob = s.readUint16BE();
ovlData->ptr1[i].subData2Size = s.readUint16BE();
ovlData->ptr1[i].var18 = s.readUint16BE();
ovlData->ptr1[i].var1A = s.readUint16BE();
}
tempPtr = (ovlData3Struct *) ovlData->ptr1;
for (i = 0; i < ovlData->numRel; i++) {
tempPtr->dataPtr = (uint8 *) mallocAndZero(tempPtr->sizeOfData);
if (!tempPtr->dataPtr) {
return (-2);
}
s.read(tempPtr->dataPtr, tempPtr->sizeOfData);
if (tempPtr->offsetToImportData) {
flipGen(tempPtr->dataPtr + tempPtr->offsetToImportData,
tempPtr->numRelocGlob * 10);
}
if (tempPtr->offsetToSubData2) {
flipGen(tempPtr->dataPtr + tempPtr->offsetToSubData2,
tempPtr->subData2Size * 10);
}
tempPtr++;
}
}
if (ovlData->size12) {
ovlData->ptr8 = (uint8 *) mallocAndZero(ovlData->size12);
if (!ovlData->ptr8) {
/* releaseScript(scriptIdx,scriptName);
if (freeIsNeeded) {
freePtr(unpackedBuffer);
} */
return (-2);
}
s.read(ovlData->ptr8, ovlData->size12);
}
if (ovlData->numObj) {
int i;
ovlData->arrayObject =
(objDataStruct *) mallocAndZero(ovlData->numObj *
sizeof(objDataStruct));
if (!ovlData->arrayObject) {
return (-2);
}
for (i = 0; i < ovlData->numObj; i++) {
ovlData->arrayObject[i]._type = s.readUint16BE();
ovlData->arrayObject[i]._class = (eClass) s.readUint16BE();
ovlData->arrayObject[i]._nameOffset = s.readUint16BE();
ovlData->arrayObject[i]._numStates = s.readUint16BE();
ovlData->arrayObject[i]._varTableIdx = s.readUint16BE();
ovlData->arrayObject[i]._firstStateIdx = s.readUint16BE();
ovlData->arrayObject[i]._stateTableIdx = s.readUint16BE();
}
// allocate states for object with multiple states
if (scriptNotLoadedBefore) {
overlayTable[scriptIdx].state = stateID;
stateID += getNumObjectsByClass(scriptIdx, MULTIPLE) + getNumObjectsByClass(scriptIdx, THEME);
}
}
if (ovlData->size9) {
ovlData->arrayObjVar =
(objectParams *) mallocAndZero(ovlData->size9 *
sizeof(objectParams));
if (!ovlData->arrayObjVar) {
return (-2);
}
}
if (ovlData->size8) {
int i;
ovlData->arrayStates =
(objectParams *) mallocAndZero(ovlData->size8 *
sizeof(objectParams));
if (!ovlData->arrayStates) {
return (-2);
}
for (i = 0; i < ovlData->size8; i++) {
ovlData->arrayStates[i].X = s.readUint16BE();
ovlData->arrayStates[i].Y = s.readUint16BE();
ovlData->arrayStates[i].Z = s.readUint16BE();
ovlData->arrayStates[i].frame = s.readUint16BE();
ovlData->arrayStates[i].scale = s.readUint16BE();
ovlData->arrayStates[i].state = s.readUint16BE();
}
}
if (ovlData->numStrings) {
int i;
ovlData->stringTable =
(stringEntryStruct *) mallocAndZero(ovlData->numStrings *
sizeof(stringEntryStruct));
for (i = 0; i < ovlData->numStrings; i++) {
ovlData->stringTable[i].idx = s.readUint16BE();
}
}
if (ovlData->sizeOfData4) {
ovlData->data4Ptr =
(uint8 *) mallocAndZero(ovlData->sizeOfData4);
if (!ovlData->data4Ptr) {
return (-2);
}
}
if (ovlData->
specialString1Length /*|| ovlData->specialString2Length */
|| ovlData->stringTable) {
int i;
//int unpackedSize;
//int fileIdx;
//uint8 fileName[50];
//char* unpackedBuffer;
strcpy(fileName, scriptName);
strcat(fileName, ".FR");
fileIdx = findFileInDisks(fileName);
if (fileIdx < 0) {
//releaseScript(scriptName);
return (-18);
}
unpackedSize = volumePtrToFileDescriptor[fileIdx].extSize + 2;
// This memory block will be later passed to a MemoryReadStream, which will dispose of it
unpackedBuffer = (byte *)malloc(unpackedSize);
memset(unpackedBuffer, 0, unpackedSize);
if (!unpackedBuffer) {
return (-2);
}
if (volumePtrToFileDescriptor[fileIdx].size + 2 !=
unpackedSize) {
char *pakedBuffer =
(char *)
mallocAndZero(volumePtrToFileDescriptor[fileIdx].
size + 2);
loadPackedFileToMem(fileIdx, (uint8 *) pakedBuffer);
delphineUnpack((uint8 *) unpackedBuffer, (const uint8 *)pakedBuffer, volumePtrToFileDescriptor[fileIdx].size);
MemFree(pakedBuffer);
} else {
loadPackedFileToMem(fileIdx, (uint8 *) unpackedBuffer);
}
Common::MemoryReadStream s2(unpackedBuffer, unpackedSize, DisposeAfterUse::YES);
unpackedBuffer = NULL;
ovlData->specialString1Length = s2.readUint16BE();
if (ovlData->specialString1Length) {
ovlData->nameVerbGlob = (char *) mallocAndZero(ovlData->specialString1Length);
if (!ovlData->nameVerbGlob) {
/* releaseScript(scriptIdx,scriptName);
*
* if (freeIsNeeded)
* {
* freePtr(unpackedBuffer);
* } */
return (-2);
}
s2.read(ovlData->nameVerbGlob, ovlData->specialString1Length);
}
ovlData->specialString2Length = s2.readUint16BE();
if (ovlData->specialString2Length) {
ovlData->arrayNameObj = (char *) mallocAndZero(ovlData->specialString2Length);
if (!ovlData->arrayNameObj) {
/* releaseScript(scriptIdx,scriptName);
*
* if (freeIsNeeded)
* {
* freePtr(unpackedBuffer);
* } */
return (-2);
}
s2.read(ovlData->arrayNameObj, ovlData->specialString2Length);
}
for (i = 0; i < ovlData->numStrings; i++) {
ovlData->stringTable[i].length = s2.readUint16BE();
if (ovlData->stringTable[i].length) {
ovlData->stringTable[i].string =
(char *)mallocAndZero(ovlData->
stringTable[i].length);
if (!ovlData->stringTable[i].string) {
/* releaseScript(scriptIdx,scriptName);
*
* if (freeIsNeeded)
* {
* freePtr(unpackedBuffer);
* } */
return (-2);
}
s2.read(ovlData->stringTable[i].string, ovlData->stringTable[i].length);
}
}
}
#ifdef DUMP_SCRIPT
{
int i;
for (i = 0; i < ovlData->numProc; i++) {
dumpScript(scriptName, ovlData, i);
}
}
#endif
#ifdef DUMP_OBJECT
{
// TODO: Rewrite this to use Common::DumpFile
int i;
FILE *fHandle;
char nameBundle[100];
sprintf(nameBundle, "%s-objs.txt", scriptName);
fHandle = fopen(nameBundle, "w+");
ASSERT(fHandle);
for (i = 0; i < ovlData->numMsgRelHeader; i++) {
linkDataStruct *var_34;
var_34 = &ovlData->arrayMsgRelHeader[i];
if (ovlData->arrayNameObj) {
fprintf(fHandle, "----- object %02d -----\n",
i);
if (var_34->stringNameOffset != 0xFFFF) {
fprintf(fHandle, "name: %s\n",
getObjectName(var_34->
stringNameOffset,
ovlData->arrayNameObj));
}
}
}
fclose(fHandle);
}
#endif
return (scriptIdx);
}
int
performAction( inStruct Sentries ) {
int status;
int c, i, j;
int uFlag = 0;;
char tmpStr[100];
ruleExecInfo_t rei;
char action[100];
char *t1;
char *args[MAX_NUM_OF_ARGS_IN_ACTION];
char configDirEV[200];
char retestflagEV[200];
char reloopbackflagEV[200];
char ruleSet[RULE_SET_DEF_LENGTH];
hrtime_t ht1, ht2, ht3;
bzero( &rei, sizeof( ruleExecInfo_t ) ); /* June 17. 2009 */
/*
sprintf(configDirEV,"irodsConfigDir=/scratch/s1/sekar/irods/RODS/server/config");
sprintf(configDirEV,"irodsConfigDir=/misc/www/projects/srb-secure/cgi-bin");
putenv(configDirEV);
*/
sprintf( retestflagEV, "RETESTFLAG=%i", HTML_TEST_1 );
putenv( retestflagEV );
sprintf( reloopbackflagEV, "RELOOPBACKFLAG=%i", LOOP_BACK_1 );
putenv( reloopbackflagEV );
fprintf( stdout, "Content-type: text/html%c%c", 10, 10 );
fflush( stdout );
fprintf( stdout, "<HTML>\n<HEAD>\n<TITLE>iRODS Rule Administration</TITLE>\n</HEAD>\n<BODY bgcolor=#FFFFFF>\n" );
fprintf( stdout, "<CENTER> <B><FONT COLOR=#FF0000>iRODS Rule Application</FONT></B></CENTER>\n" );
fflush( stdout );
rei.doi = mallocAndZero( sizeof( dataObjInfo_t ) );
rei.uoip = mallocAndZero( sizeof( userInfo_t ) );
rei.uoic = mallocAndZero( sizeof( userInfo_t ) );
rei.coi = mallocAndZero( sizeof( collInfo_t ) );
rei.uoio = mallocAndZero( sizeof( userInfo_t ) );
rei.next = NULL;
strcpy( rei.doi->objPath, "" );
strcpy( rei.doi->rescName, "" );
strcpy( rei.doi->dataType, "" );
strcpy( rei.uoic->authInfo.host, "" );
rei.doi->dataSize = 100;
rei.condInputData = NULL;
rei.rsComm = NULL;
strcpy( ruleSet, "" );
for ( i = 0; i <= Sentries->m; i++ ) {
if ( !strcmp( Sentries->entries[i].name, "action" ) ) {
strcpy( action, Sentries->entries[i].val );
fprintf( stdout, "<FONT COLOR=#0000FF>Action:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "objPath" ) ) {
strcpy( rei.doi->objPath, Sentries->entries[i].val );
fprintf( stdout, "<FONT COLOR=#0000FF>$objPath:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "rescName" ) ) {
strcpy( rei.doi->rescName, Sentries->entries[i].val );
fprintf( stdout, "<FONT COLOR=#0000FF>$rescName:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "dataSize" ) ) {
rei.doi->dataSize = atol( Sentries->entries[i].val );
fprintf( stdout, "<FONT COLOR=#0000FF>$dataSize:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "dataType" ) ) {
strcpy( rei.doi->dataType, Sentries->entries[i].val );
fprintf( stdout, "<FONT COLOR=#0000FF>$dataType:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "dataOwner" ) ) {
strcpy( rei.doi->dataOwnerName, Sentries->entries[i].val );
if ( ( t1 = strstr( rei.doi->dataOwnerName, "|" ) ) != NULL ) {
*t1 = '\0';
strcpy( rei.doi->dataOwnerZone, ( char * )( t1 + 1 ) );
}
else {
strcpy( rei.doi->dataOwnerZone, "" );
}
fprintf( stdout, "<FONT COLOR=#0000FF>$dataOwner:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "dataUser" ) ) {
strcpy( rei.uoic->userName, Sentries->entries[i].val );
if ( ( t1 = strstr( rei.uoic->userName, "|" ) ) != NULL ) {
*t1 = '\0';
strcpy( rei.uoic->rodsZone, ( char * )( t1 + 1 ) );
}
else {
strcpy( rei.uoic->rodsZone, "" );
}
fprintf( stdout, "<FONT COLOR=#0000FF>$dataUser:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "dataAccess" ) ) {
strcpy( rei.doi->dataAccess, Sentries->entries[i].val );
fprintf( stdout, "<FONT COLOR=#0000FF>$dataAccess:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "hostClient" ) ) {
strcpy( rei.uoic->authInfo.host, Sentries->entries[i].val );
fprintf( stdout, "<FONT COLOR=#0000FF>$hostClient:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "proxyUser" ) ) {
strcpy( rei.uoip->userName, Sentries->entries[i].val );
if ( ( t1 = strstr( rei.uoip->userName, "|" ) ) != NULL ) {
*t1 = '\0';
strcpy( rei.uoip->rodsZone, ( char * )( t1 + 1 ) );
}
else {
strcpy( rei.uoio->rodsZone, "" );
}
fprintf( stdout, "<FONT COLOR=#0000FF>$otherUser:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "otherUser" ) ) {
strcpy( rei.uoic->userName, Sentries->entries[i].val );
if ( ( t1 = strstr( rei.uoio->userName, "|" ) ) != NULL ) {
*t1 = '\0';
strcpy( rei.uoio->rodsZone, ( char * )( t1 + 1 ) );
}
else {
strcpy( rei.uoio->rodsZone, "" );
}
fprintf( stdout, "<FONT COLOR=#0000FF>$otherUser:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "otherUserType" ) ) {
strcpy( rei.uoio->userType, Sentries->entries[i].val );
fprintf( stdout, "<FONT COLOR=#0000FF>$otherUserType:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "ruleSet" ) ) {
if ( strlen( Sentries->entries[i].val ) > 0 ) {
if ( ruleSet[0] != '\0' ) {
strcat( ruleSet, "," );
}
rstrcat( ruleSet, Sentries->entries[i].val, 999 );
}
}
else if ( !strcmp( Sentries->entries[i].name, "retestflag" ) ) {
sprintf( retestflagEV, "RETESTFLAG=%s", Sentries->entries[i].val );
putenv( retestflagEV );
fprintf( stdout, "<FONT COLOR=#0000FF>Trace Status</FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val );
}
else if ( !strcmp( Sentries->entries[i].name, "configDir" ) ) {
if ( strlen( Sentries->entries[i].val ) > 0 ) {
snprintf( configDirEV, 199, "irodsConfigDir=%s", Sentries->entries[i].val );
}
else {
sprintf( configDirEV, "irodsConfigDir=%s", MY_SERVER_CONFIG_DIR );
}
putenv( configDirEV );
}
/*
else if (!strcmp(Sentries->entries[i].name,"")){
strcpy(,Sentries->entries[i].val);
fprintf(stdout,"<FONT COLOR=#0000FF></FONT> <FONT COLOR=#FF0000>%s</FONT><BR>\n",
Sentries->entries[i].val);
}
*/
}
fprintf( stdout, "<FONT COLOR=#0000FF>Rule Set:</FONT> <FONT COLOR=#FF0000>%s</FONT><BR><HR>\n", ruleSet );
strcpy( rei.ruleSet, ruleSet );
/* fprintf(stdout,"<PRE>\n");fflush(stdout);*/
ht1 = gethrtime();
initRuleStruct( NULL, ruleSet, "core", "core" );
ht2 = gethrtime();
/*** i = applyRule(action, args, 0, &rei, SAVE_REI); ***/
i = applyRuleArgPA( action, args, 0, NULL, &rei, SAVE_REI );
ht3 = gethrtime();
if ( reTestFlag == COMMAND_TEST_1 || reTestFlag == COMMAND_TEST_MSI ) {
fprintf( stdout, "Rule Initialization Time = %.2f millisecs\n", ( float )( ht2 - ht1 ) / 1000000 );
fprintf( stdout, "Rule Execution Time = %.2f millisecs\n", ( float )( ht3 - ht1 ) / 1000000 );
}
if ( reTestFlag == HTML_TEST_1 || reTestFlag == HTML_TEST_MSI ) {
fprintf( stdout, "<BR>Rule Initialization Time = %.2f millisecs<BR>\n", ( float )( ht2 - ht1 ) / 1000000 );
fprintf( stdout, "Rule Execution Time = %.2f millisecs<BR>\n", ( float )( ht3 - ht1 ) / 1000000 );
}
if ( i != 0 ) {
rodsLogError( LOG_ERROR, i, "<BR>Rule Application Failed:" );
/* fprintf(stdout,"</PRE>\n</body>\n</HTML>\n");*/
return -1;
}
/* fprintf(stdout,"</PRE>\n</body>\n</HTML>\n");*/
return 0;
}
cellStruct *addCell(cellStruct *pHead, int16 overlayIdx, int16 objIdx, int16 type, int16 backgroundPlane, int16 scriptOverlay, int16 scriptNumber, int16 scriptType) {
int16 var;
cellStruct *newElement;
cellStruct *currentHead = pHead;
cellStruct *currentHead2;
cellStruct *currentHead3;
if (getSingleObjectParam(overlayIdx, objIdx, 2, &var) < 0) {
return 0;
}
currentHead3 = currentHead;
currentHead2 = currentHead->next;
while (currentHead2 && (currentHead2->type != 3)) {
if (currentHead2->type != 5) {
int16 lvar2;
if (getSingleObjectParam(currentHead2->overlay, currentHead2->idx, 2, &lvar2) >= 0 && lvar2 >= var)
break;
}
currentHead3 = currentHead2;
currentHead2 = currentHead2->next;
}
if (currentHead2) {
if ((currentHead2->overlay == overlayIdx) &&
(currentHead2->backgroundPlane == backgroundPlane) &&
(currentHead2->idx == objIdx) &&
(currentHead2->type == type))
return NULL;
}
currentHead = currentHead2;
newElement = (cellStruct *) mallocAndZero(sizeof(cellStruct));
if (!newElement)
return 0;
newElement->next = currentHead3->next;
currentHead3->next = newElement;
newElement->idx = objIdx;
newElement->type = type;
newElement->backgroundPlane = backgroundPlane;
newElement->overlay = overlayIdx;
newElement->freeze = 0;
newElement->parent = scriptNumber;
newElement->parentOverlay = scriptOverlay;
newElement->gfxPtr = NULL;
newElement->followObjectIdx = objIdx;
newElement->followObjectOverlayIdx = overlayIdx;
newElement->parentType = scriptType;
newElement->animStart = 0;
newElement->animEnd = 0;
newElement->animWait = 0;
newElement->animSignal = 0;
newElement->animCounter = 0;
newElement->animType = 0;
newElement->animStep = 0;
newElement->animLoop = 0;
if (currentHead) {
newElement->prev = currentHead->prev;
currentHead->prev = newElement;
} else {
newElement->prev = pHead->prev;
pHead->prev = newElement;
}
return newElement;
}
/**
* \fn msiReadMDTemplateIntoTagStruct(msParam_t* bufParam, msParam_t* tagParam, ruleExecInfo_t *rei)
*
* \brief This microservice parses a buffer containing a template-style file
* and stores the tags in a tag structure.
*
* \author Arcot Rajasekar
* \date 2007-02-01
*
* \note The template buffer should contain triplets of the form:
* <PRETAG>re1</PRETAG>kw<POSTTAG>re2</POSTTAG>.
* re1 identifies the pre-string and re2 identifies the post-string and
* any value between re1 and re2 in a metadata buffer can be
* associated with keyword kw.
*
* \usage See clients/icommands/test/rules3.0/
*
* \param[in] bufParam - a msParam of type BUF_LEN_MS_T
* \param[out] tagParam - a return msParam of type TagStruct_MS_T
* \param[in,out] rei - The RuleExecInfo structure that is automatically
* handled by the rule engine. The user does not include rei as a
* parameter in the rule invocation.
*
* \DolVarDependence none
* \DolVarModified none
* \iCatAttrDependence none
* \iCatAttrModified none
* \sideeffect none
*
* \return integer
* \retval 0 on success
* \retval USER_PARAM_TYP_ERROR when input parameter doesn't match the type
* \retval INVALID_REGEXP if the tags are not correct
* \retval NO_VALUES_FOUND if there are no tags identified
* \retval from addTagStruct
* \pre none
* \post none
* \sa addTagStruct
**/
int
msiReadMDTemplateIntoTagStruct( msParam_t* bufParam, msParam_t* tagParam, ruleExecInfo_t *rei ) {
bytesBuf_t *tmplObjBuf;
tagStruct_t *tagValues;
char *t, *t1, *t2, *t3, *t4, *t5, *t6, *t7, *t8;
/*
int len;
int l1, l2;
*/
int i, j;
/* char *preg[4];*/
regex_t preg[4];
regmatch_t pm[4];
char errbuff[100];
RE_TEST_MACRO( "Loopback on msiReadMDTemplateIntoTagStruct" );
if ( strcmp( bufParam->type, BUF_LEN_MS_T ) != 0 ||
bufParam->inpOutBuf == NULL ) {
return( USER_PARAM_TYPE_ERR );
}
tmplObjBuf = ( bytesBuf_t * ) bufParam->inpOutBuf;
/*
preg[0] = regcmp("<PRETAG>", (char *)0);
if (preg[0] == NULL)
return(INVALID_REGEXP);
preg[1] = regcmp("</PRETAG>", (char *)0);
if (preg[1] == NULL)
return(INVALID_REGEXP);
preg[2] = regcmp("<POSTTAG>", (char *)0);
if (preg[0] == NULL)
return(INVALID_REGEXP);
preg[3] = regcmp("</POSTTAG>", (char *)0);
if (preg[1] == NULL)
return(INVALID_REGEXP);
*/
j = regcomp( &preg[0], "<PRETAG>", REG_EXTENDED );
if ( j != 0 ) {
regerror( j, &preg[0], errbuff, sizeof( errbuff ) );
rodsLog( LOG_NOTICE, "msiReadMDTemplateIntoTagStruct: Error in regcomp: %s\n", errbuff );
return( INVALID_REGEXP );
}
j = regcomp( &preg[1], "</PRETAG>", REG_EXTENDED );
if ( j != 0 ) {
regerror( j, &preg[1], errbuff, sizeof( errbuff ) );
rodsLog( LOG_NOTICE, "msiReadMDTemplateIntoTagStruct: Error in regcomp: %s\n", errbuff );
return( INVALID_REGEXP );
}
j = regcomp( &preg[2], "<POSTTAG>", REG_EXTENDED );
if ( j != 0 ) {
regerror( j, &preg[2], errbuff, sizeof( errbuff ) );
rodsLog( LOG_NOTICE, "msiReadMDTemplateIntoTagStruct: Error in regcomp: %s\n", errbuff );
return( INVALID_REGEXP );
}
j = regcomp( &preg[3], "</POSTTAG>", REG_EXTENDED );
if ( j != 0 ) {
regerror( j, &preg[3], errbuff, sizeof( errbuff ) );
rodsLog( LOG_NOTICE, "msiReadMDTemplateIntoTagStruct: Error in regcomp: %s\n", errbuff );
return( INVALID_REGEXP );
}
t = ( char* )malloc( tmplObjBuf->len + 1 );
t[tmplObjBuf->len] = '\0';
memcpy( t, tmplObjBuf->buf, tmplObjBuf->len );
tagValues = ( tagStruct_t* )mallocAndZero( sizeof( tagStruct_t ) );
tagValues->len = 0;
t1 = t;
#ifdef BABABA
/*
while ((t2 = regex(preg[0], t1)) != NULL) { / * t2 starts preTag * /
if ((t3 = regex(preg[1], t2)) == NULL) / * t3 starts keyValue * /
break;
t6 = __loc1; / * t6 ends preTag * /
*t6 = '\0';
if ((t5 = regex(preg[2], t3)) == NULL) / * t5 starts postTag * /
break;
t4 = __loc1; / * t4 ends keyValue * /
*t4 = '\0';
if ((t7 = regex(preg[3], t5)) == NULL) / * t7 ends the line * /
break;
t8 = __loc1; / * t8 ends postTag * /
*t8 = '\0';
i = addTagStruct (tagValues, t2, t5, t3);
if (i != 0)
return(i);
t1 = t7;
if (*t1 == '\0')
break;
}
*/
#endif /* BABABA */
while ( regexec( &preg[0], t1, 1, &pm[0], 0 ) == 0 ) {
t2 = t1 + pm[0].rm_eo ; /* t2 starts preTag */
if ( regexec( &preg[1], t2, 1, &pm[1], 0 ) != 0 ) {
break;
}
t3 = t2 + pm[1].rm_eo ; /* t3 starts keyValue */
t6 = t2 + pm[1].rm_so; /* t6 ends preTag */
*t6 = '\0';
if ( regexec( &preg[2], t3, 1, &pm[2], 0 ) != 0 ) {
break;
}
t5 = t3 + pm[2].rm_eo ; /* t5 starts postTag */
t4 = t3 + pm[2].rm_so; /* t4 ends keyValue */
*t4 = '\0';
if ( regexec( &preg[3], t5, 1, &pm[3], 0 ) != 0 ) {
break;
}
t7 = t5 + pm[3].rm_eo; /* t7 ends the line */
t8 = t5 + pm[3].rm_so; /* t8 ends postTag */
*t8 = '\0';
/*** rodsLog(LOG_NOTICE,"msiReadMDTemplateIntoTagStruct:TAGS:%s::%s::%s::\n",t2, t5, t3);***/
i = addTagStruct( tagValues, t2, t5, t3 );
if ( i != 0 ) {
return( i );
}
t1 = t7;
if ( *t1 == '\0' ) {
break;
}
}
/*
free(preg[0]);
free(preg[1]);
free(preg[2]);
free(preg[3]);
*/
regfree( &preg[0] );
regfree( &preg[1] );
regfree( &preg[2] );
regfree( &preg[3] );
free( t );
if ( tagValues->len == 0 ) {
return( NO_VALUES_FOUND );
}
tagParam->inOutStruct = ( void * ) tagValues;
tagParam->type = ( char * ) strdup( TagStruct_MS_T );
return( 0 );
}
/**
* \fn msiExtractTemplateMDFromBuf(msParam_t* bufParam, msParam_t* tagParam, msParam_t *metadataParam, ruleExecInfo_t *rei)
*
* \brief This microservice parses a buffer containing metadata
* and uses the tags to identify Key-Value Pairs.
*
* \module core
*
* \since pre-2.1
*
* \author Arcot Rajasekar
* \date 2007-02-01
*
* \remark Terrell Russell - msi documentation, 2009-06-17
*
* \note The template structure identifies triplets
* <pre-string-regexp,post-string-regexp,keyword> and the metadata buffer
* is searched for the pre and post regular expressions and the string
* between them is associated with the keyword.
* A.l <key,value> pairs found are stored in keyValPair_t structure.
*
* \usage See clients/icommands/test/rules3.0/
*
* \param[in] bufParam - a msParam of type BUF_MS_T
* \param[in] tagParam - a msParam of type TagStruct_MS_T
* \param[out] metadataParam - a msParam of type KeyValPair_MS_T
* \param[in,out] rei - The RuleExecInfo structure that is automatically
* handled by the rule engine. The user does not include rei as a
* parameter in the rule invocation.
*
* \DolVarDependence none
* \DolVarModified none
* \iCatAttrDependence none
* \iCatAttrModified none
* \sideeffect none
*
* \return integer
* \retval 0 on success
* \retval USER_PARAM_TYP_ERROR when input parameter doesn't match the type
* \retval INVALID_REGEXP if the tags are not correct
* \retval from addKeyVal
* \pre none
* \post none
* \sa addKeyVal
**/
int
msiExtractTemplateMDFromBuf( msParam_t* bufParam, msParam_t* tagParam,
msParam_t *metadataParam, ruleExecInfo_t *rei ) {
bytesBuf_t *metaObjBuf;
tagStruct_t *tagValues;
keyValPair_t *metaDataPairs;
/* int l1, l2; */
int i, j;
/*char *preg[2]; */
regex_t preg[2];
regmatch_t pm[2];
char errbuff[100];
char *t, *t1, *t2, *t3, *t4;
char c;
RE_TEST_MACRO( "Loopback on msiExtractTemplateMetadata" );
if ( strcmp( bufParam->type, BUF_LEN_MS_T ) != 0 ||
bufParam->inpOutBuf == NULL ) {
return( USER_PARAM_TYPE_ERR );
}
if ( strcmp( tagParam->type, TagStruct_MS_T ) != 0 ) {
return( USER_PARAM_TYPE_ERR );
}
tagValues = ( tagStruct_t * ) tagParam->inOutStruct;
metaObjBuf = ( bytesBuf_t * ) bufParam->inpOutBuf;
t = ( char* )malloc( metaObjBuf->len + 1 );
t[metaObjBuf->len] = '\0';
memcpy( t, metaObjBuf->buf, metaObjBuf->len );
metaDataPairs = ( keyValPair_t* )mallocAndZero( sizeof( keyValPair_t ) );
t1 = t;
for ( i = 0; i < tagValues->len ; i++ ) {
t1 = t;
#ifdef BABABA
/*
preg[0] = regcmp(tagValues->preTag[i], (char *)0);
if (preg[0] == NULL)
return(INVALID_REGEXP);
preg[1] = regcmp(tagValues->postTag[i], (char *)0);
if (preg[1] == NULL)
return(INVALID_REGEXP);
while ((t2 = regex(preg[0], t1)) != NULL) { / * t2 starts value * /
if ((t3 = regex(preg[1], t2)) == NULL) {
free(preg[0]);
free(preg[1]);
break;
}
t4 = __loc1; / * t4 ends value * /
c = *t4;
*t4 = '\0';
j = addKeyVal(metaDataPairs, tagValues->keyWord[i], t2);
*t4 = c;
if (j != 0)
return(j);
t1 = t3;
if (*t1 == '\0')
break;
}
free(preg[0]);
free(preg[1]);
*/
#endif /* BABABA */
j = regcomp( &preg[0], tagValues->preTag[i], REG_EXTENDED );
if ( j != 0 ) {
regerror( j, &preg[0], errbuff, sizeof( errbuff ) );
rodsLog( LOG_NOTICE, "msiExtractTemplateMDFromBuf: Error in regcomp: %s\n", errbuff );
return( INVALID_REGEXP );
}
j = regcomp( &preg[1], tagValues->postTag[i], REG_EXTENDED );
if ( j != 0 ) {
regerror( j, &preg[1], errbuff, sizeof( errbuff ) );
rodsLog( LOG_NOTICE, "msiExtractTemplateMDFromBuf: Error in regcomp: %s\n", errbuff );
return( INVALID_REGEXP );
}
while ( regexec( &preg[0], t1, 1, &pm[0], 0 ) == 0 ) {
t2 = t1 + pm[0].rm_eo ; /* t2 starts value */
if ( regexec( &preg[1], t2, 1, &pm[1], 0 ) != 0 ) {
break;
}
t4 = t2 + pm[1].rm_so; /* t4 ends value */
t3 = t2 + pm[1].rm_eo;
c = *t4;
*t4 = '\0';
/*** rodsLog(LOG_NOTICE,"msiExtractTemplateMDFromBuf:KVAL:%s::%s::\n",tagValues->keyWord[i], t2); ***/
j = addKeyVal( metaDataPairs, tagValues->keyWord[i], t2 );
*t4 = c;
if ( j != 0 ) {
return( j );
}
t1 = t3;
if ( *t1 == '\0' ) {
break;
}
}
regfree( &preg[0] );
regfree( &preg[1] );
continue;
}
metadataParam->inOutStruct = ( void * ) metaDataPairs;
metadataParam->type = ( char * ) strdup( KeyValPair_MS_T );
return( 0 );
}
backgroundIncrustStruct *addBackgroundIncrust(int16 overlayIdx, int16 objectIdx, backgroundIncrustStruct *pHead, int16 scriptNumber, int16 scriptOverlay, int16 backgroundIdx, int16 saveBuffer) {
uint8 *backgroundPtr;
uint8 *ptr;
objectParamsQuery params;
backgroundIncrustStruct *newElement;
backgroundIncrustStruct *currentHead;
backgroundIncrustStruct *currentHead2;
getMultipleObjectParam(overlayIdx, objectIdx, ¶ms);
ptr = filesDatabase[params.fileIdx].subData.ptr;
// Don't process any further if not a sprite or polygon
if (!ptr) return NULL;
if ((filesDatabase[params.fileIdx].subData.resourceType != OBJ_TYPE_SPRITE) &&
(filesDatabase[params.fileIdx].subData.resourceType != OBJ_TYPE_POLY)) {
return NULL;
}
backgroundPtr = backgroundScreens[backgroundIdx];
backgroundChanged[backgroundIdx] = true;
assert(backgroundPtr != NULL);
currentHead = pHead;
currentHead2 = currentHead->next;
while (currentHead2) {
currentHead = currentHead2;
currentHead2 = currentHead->next;
}
newElement = (backgroundIncrustStruct *)mallocAndZero(sizeof(backgroundIncrustStruct));
if (!newElement)
return NULL;
newElement->next = currentHead->next;
currentHead->next = newElement;
if (!currentHead2) {
currentHead2 = pHead;
}
newElement->prev = currentHead2->prev;
currentHead2->prev = newElement;
newElement->objectIdx = objectIdx;
newElement->type = saveBuffer;
newElement->backgroundIdx = backgroundIdx;
newElement->overlayIdx = overlayIdx;
newElement->scriptNumber = scriptNumber;
newElement->scriptOverlayIdx = scriptOverlay;
newElement->X = params.X;
newElement->Y = params.Y;
newElement->scale = params.scale;
newElement->frame = params.fileIdx;
newElement->spriteId = filesDatabase[params.fileIdx].subData.index;
newElement->ptr = NULL;
strcpy(newElement->name, filesDatabase[params.fileIdx].subData.name);
if (filesDatabase[params.fileIdx].subData.resourceType == OBJ_TYPE_SPRITE) {
// sprite
int width = filesDatabase[params.fileIdx].width;
int height = filesDatabase[params.fileIdx].height;
if (saveBuffer == 1) {
backupBackground(newElement, newElement->X, newElement->Y, width, height, backgroundPtr);
}
drawSprite(width, height, NULL, filesDatabase[params.fileIdx].subData.ptr, newElement->Y,
newElement->X, backgroundPtr, filesDatabase[params.fileIdx].subData.ptrMask);
} else {
// poly
if (saveBuffer == 1) {
int newX;
int newY;
int newScale;
char *newFrame;
int sizeTable[4]; // 0 = left, 1 = right, 2 = bottom, 3 = top
// this function checks if the dataPtr is not 0, else it retrives the data for X, Y, scale and DataPtr again (OLD: mainDrawSub1Sub1)
flipPoly(params.fileIdx, (int16 *)filesDatabase[params.fileIdx].subData.ptr, params.scale, &newFrame, newElement->X, newElement->Y, &newX, &newY, &newScale);
// this function fills the sizeTable for the poly (OLD: mainDrawSub1Sub2)
getPolySize(newX, newY, newScale, sizeTable, (unsigned char*)newFrame);
int width = (sizeTable[1] + 2) - (sizeTable[0] - 2) + 1;
int height = sizeTable[3] - sizeTable[2] + 1;
backupBackground(newElement, sizeTable[0] - 2, sizeTable[2], width, height, backgroundPtr);
}
addBackgroundIncrustSub1(params.fileIdx, newElement->X, newElement->Y, NULL, params.scale, (char *)backgroundPtr, (char *)filesDatabase[params.fileIdx].subData.ptr);
}
return newElement;
}
static void syncIncrust(Common::Serializer &s) {
int numEntries = 0;
backgroundIncrustStruct *pl, *pl1;
uint8 dummyByte = 0;
uint16 dummyWord = 0;
uint32 dummyLong = 0;
if (s.isSaving()) {
// Figure out the number of entries to save
pl = backgroundIncrustHead.next;
while (pl) {
++numEntries;
pl = pl->next;
}
}
s.syncAsSint16LE(numEntries);
pl = s.isSaving() ? backgroundIncrustHead.next : &backgroundIncrustHead;
pl1 = &backgroundIncrustHead;
for (int i = 0; i < numEntries; ++i) {
backgroundIncrustStruct *t = s.isSaving() ? pl :
(backgroundIncrustStruct *)mallocAndZero(sizeof(backgroundIncrustStruct));
s.syncAsUint32LE(dummyLong);
s.syncAsSint16LE(t->objectIdx);
s.syncAsSint16LE(t->type);
s.syncAsSint16LE(t->overlayIdx);
s.syncAsSint16LE(t->X);
s.syncAsSint16LE(t->Y);
s.syncAsSint16LE(t->frame);
s.syncAsSint16LE(t->scale);
s.syncAsSint16LE(t->backgroundIdx);
s.syncAsSint16LE(t->scriptNumber);
s.syncAsSint16LE(t->scriptOverlayIdx);
s.syncAsUint32LE(dummyLong);
s.syncAsSint16LE(t->saveWidth);
s.syncAsSint16LE(t->saveHeight);
s.syncAsSint16LE(t->saveSize);
s.syncAsSint16LE(t->savedX);
s.syncAsSint16LE(t->savedY);
s.syncBytes((byte *)t->name, 13);
s.syncAsByte(dummyByte);
s.syncAsSint16LE(t->spriteId);
s.syncAsUint16LE(dummyWord);
if (t->saveSize) {
if (s.isLoading())
t->ptr = (byte *)MemAlloc(t->saveSize);
s.syncBytes(t->ptr, t->saveSize);
}
if (s.isSaving())
pl = pl->next;
else {
t->next = NULL;
pl->next = t;
t->prev = pl1->prev;
pl1->prev = t;
pl = t;
}
}
}
int
copyRuleExecInfo(ruleExecInfo_t *from, ruleExecInfo_t *to)
{
(*to) = (*from);
/****
The following structures are not copied and just the pointer is copied.
dataObjInp_t *doinp;
dataOprInp_t *dinp;
fileOpenInp_t *finp;
dataObjInp_t *doinpo;
dataOprInp_t *dinpo;
fileOpenInp_t *finpo;
***/
if (from->doi != NULL) {
to->doi = (dataObjInfo_t *) mallocAndZero(sizeof(dataObjInfo_t));
copyDataObjInfo(from->doi, to->doi);
}
else
to->doi = NULL;
if (from->rgi != NULL) {
to->rgi = (rescGrpInfo_t*)mallocAndZero(sizeof(rescGrpInfo_t));
copyRescGrpInfo(from->rgi, to->rgi);
}
else
to->rgi = NULL;
if (from->uoic != NULL) {
to->uoic = (userInfo_t*)mallocAndZero(sizeof(userInfo_t));
copyUserInfo(from->uoic, to->uoic);
}
else
to->uoic = NULL;
if (from->uoip != NULL) {
to->uoip = (userInfo_t*)mallocAndZero(sizeof(userInfo_t));
copyUserInfo(from->uoip, to->uoip);
}
else
to->uoip = NULL;
if (from->coi != NULL) {
to->coi = (collInfo_t*)mallocAndZero(sizeof(collInfo_t));
copyCollInfo(from->coi, to->coi);
}
else
to->coi = NULL;
#if 0 /* XXXXX deplicate rgio */
if (from->rgio != NULL) {
to->rgio = mallocAndZero(sizeof(rescGrpInfo_t));
copyRescGrpInfo(from->rgio, to->rgio);
}
else
to->rgi = NULL;
#endif
if (from->uoio != NULL) {
to->uoio= (userInfo_t*)mallocAndZero(sizeof(userInfo_t));
copyUserInfo(from->uoio, to->uoio);
}
else
to->uoio = NULL;
if (from->condInputData != NULL) {
to->condInputData = (keyValPair_t*)mallocAndZero(sizeof(keyValPair_t));
copyKeyValPairStruct(from->condInputData, to->condInputData);
}
else
to->condInputData = NULL;
if (from->next != NULL) {
to->next = (ruleExecInfo_t*)mallocAndZero(sizeof(ruleExecInfo_t));
copyRuleExecInfo(from->next,to->next);
}
else
to->next = NULL;
return(0);
}
static void syncOverlays2(Common::Serializer &s) {
for (int i = 1; i < numOfLoadedOverlay; i++) {
if (s.isSaving()) {
// Saving code
if (!overlayTable[i].alreadyLoaded)
continue;
ovlDataStruct *ovlData = overlayTable[i].ovlData;
// save BSS
s.syncAsSint16LE(ovlData->sizeOfData4);
if (ovlData->sizeOfData4)
s.syncBytes(ovlData->data4Ptr, ovlData->sizeOfData4);
// save variables
s.syncAsSint16LE(ovlData->size9);
for (int j = 0; j < ovlData->size9; j++) {
s.syncAsSint16LE(ovlData->arrayObjVar[j].X);
s.syncAsSint16LE(ovlData->arrayObjVar[j].Y);
s.syncAsSint16LE(ovlData->arrayObjVar[j].Z);
s.syncAsSint16LE(ovlData->arrayObjVar[j].frame);
s.syncAsSint16LE(ovlData->arrayObjVar[j].scale);
s.syncAsSint16LE(ovlData->arrayObjVar[j].state);
}
} else {
// Loading code
ovlRestoreData[i]._sBssSize = ovlRestoreData[i]._sNumObj = 0;
ovlRestoreData[i]._pBss = NULL;
ovlRestoreData[i]._pObj = NULL;
if (overlayTable[i].alreadyLoaded) {
s.syncAsSint16LE(ovlRestoreData[i]._sBssSize);
if (ovlRestoreData[i]._sBssSize) {
ovlRestoreData[i]._pBss = (uint8 *) mallocAndZero(ovlRestoreData[i]._sBssSize);
ASSERT(ovlRestoreData[i]._pBss);
s.syncBytes(ovlRestoreData[i]._pBss, ovlRestoreData[i]._sBssSize);
}
s.syncAsSint16LE(ovlRestoreData[i]._sNumObj);
if (ovlRestoreData[i]._sNumObj) {
ovlRestoreData[i]._pObj = (objectParams *) mallocAndZero(ovlRestoreData[i]._sNumObj * sizeof(objectParams));
ASSERT(ovlRestoreData[i]._pObj);
for (int j = 0; j < ovlRestoreData[i]._sNumObj; j++) {
s.syncAsSint16LE(ovlRestoreData[i]._pObj[j].X);
s.syncAsSint16LE(ovlRestoreData[i]._pObj[j].Y);
s.syncAsSint16LE(ovlRestoreData[i]._pObj[j].Z);
s.syncAsSint16LE(ovlRestoreData[i]._pObj[j].frame);
s.syncAsSint16LE(ovlRestoreData[i]._pObj[j].scale);
s.syncAsSint16LE(ovlRestoreData[i]._pObj[j].state);
}
}
}
}
}
}
int loadFileSub1(uint8 **ptr, const char *name, uint8 *ptr2) {
int i;
char buffer[256];
int fileIdx;
int unpackedSize;
uint8 *unpackedBuffer;
for (i = 0; i < 64; i++) {
if (preloadData[i].ptr) {
if (!strcmp(preloadData[i].name, name)) {
error("Unsupported code in loadFIleSub1");
}
}
}
getFileExtention(name, buffer);
if (!strcmp(buffer, ".SPL")) {
removeExtention(name, buffer);
/* if (useH32)
*{
* strcat(buffer, ".H32");
*}
* else
* if (useAdLib)
* { */
strcat(buffer,".ADL");
/* }
* else
* {
* strcatuint8(buffer,".HP");
* } */
} else {
strcpy(buffer, name);
}
fileIdx = findFileInDisks(buffer);
if (fileIdx < 0)
return (-18);
unpackedSize = loadFileVar1 = volumePtrToFileDescriptor[fileIdx].extSize + 2;
unpackedBuffer = (uint8 *)mallocAndZero(unpackedSize);
if (!unpackedBuffer) {
return (-2);
}
lastFileSize = unpackedSize;
if (volumePtrToFileDescriptor[fileIdx].size + 2 != unpackedSize) {
uint8 *pakedBuffer = (uint8 *) mallocAndZero(volumePtrToFileDescriptor[fileIdx].size + 2);
loadPackedFileToMem(fileIdx, pakedBuffer);
uint32 realUnpackedSize = READ_BE_UINT32(pakedBuffer + volumePtrToFileDescriptor[fileIdx].size - 4);
lastFileSize = realUnpackedSize;
delphineUnpack(unpackedBuffer, pakedBuffer, volumePtrToFileDescriptor[fileIdx].size);
MemFree(pakedBuffer);
} else {
loadPackedFileToMem(fileIdx, unpackedBuffer);
}
*ptr = unpackedBuffer;
return (1);
}
int16 readVolCnf() {
int i;
Common::File fileHandle;
short int sizeHEntry;
volumeDataLoaded = 0;
for (i = 0; i < 20; i++) {
volumeData[i].ident[0] = 0;
volumeData[i].ptr = NULL;
volumeData[i].diskNumber = i + 1;
volumeData[i].size = 0;
}
fileHandle.open("VOL.CNF");
if (!fileHandle.isOpen()) {
return (0);
}
numOfDisks = fileHandle.readSint16BE();
sizeHEntry = fileHandle.readSint16BE(); // size of one header entry - 20 bytes
for (i = 0; i < numOfDisks; i++) {
// fread(&volumeData[i],20,1,fileHandle);
fileHandle.read(&volumeData[i].ident, 10);
fileHandle.read(&volumeData[i].ptr, 4);
volumeData[i].diskNumber = fileHandle.readSint16BE();
volumeData[i].size = fileHandle.readSint32BE();
debug(1, "Disk number: %d", volumeData[i].diskNumber);
}
for (i = 0; i < numOfDisks; i++) {
dataFileName *ptr;
volumeData[i].size = fileHandle.readSint32BE();
ptr = (dataFileName *) mallocAndZero(volumeData[i].size);
volumeData[i].ptr = ptr;
if (!ptr) {
fileHandle.close();
return (-2);
}
fileHandle.read(ptr, volumeData[i].size);
}
fileHandle.close();
volumeDataLoaded = 1;
//#define dumpResources
#ifdef dumpResources
for (i = 0; i < numOfDisks; i++) {
int j;
char nameBuffer[256];
fileEntry *buffer;
sprintf(nameBuffer, "D%d.", i + 1);
fileHandle.open(nameBuffer);
short int numEntry;
short int sizeEntry;
numEntry = fileHandle.readSint16BE();
sizeEntry = fileHandle.readSint16BE();
buffer = (fileEntry *) mallocAndZero(numEntry * sizeEntry);
for (j = 0; j < numEntry; j++) {
fileHandle.seek(4 + j*0x1E);
fileHandle.read(buffer[j].name, 14);
buffer[j].offset = fileHandle.readSint32BE();
buffer[j].size = fileHandle.readSint32BE();
buffer[j].extSize = fileHandle.readSint32BE();
buffer[j].unk3 = fileHandle.readSint32BE();
fileHandle.seek(buffer[j].offset);
char *bufferLocal;
bufferLocal = (char *)mallocAndZero(buffer[j].size);
fileHandle.read(bufferLocal, buffer[j].size);
char nameBuffer[256];
sprintf(nameBuffer, "%s", buffer[j].name);
if (buffer[j].size == buffer[j].extSize) {
Common::DumpFile fout;
fout.open(nameBuffer);
if (fout.isOpen())
fout.write(bufferLocal, buffer[j].size);
} else {
char *uncompBuffer = (char *)mallocAndZero(buffer[j].extSize + 500);
delphineUnpack((uint8 *) uncompBuffer, (const uint8 *) bufferLocal, buffer[j].size);
Common::File fout;
fout.open(nameBuffer, Common::File::kFileWriteMode);
if (fout.isOpen())
fout.write(uncompBuffer, buffer[j].extSize);
//MemFree(uncompBuffer);
}
MemFree(bufferLocal);
}
fileHandle.close();
}
#endif
return (1);
}
