static bool genCmpFP(CompilationUnit *cUnit, MIR *mir, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
bool isDouble;
int defaultResult;
bool ltNaNBias;
RegLocation rlResult;
switch(mir->dalvikInsn.opCode) {
case OP_CMPL_FLOAT:
isDouble = false;
defaultResult = -1;
break;
case OP_CMPG_FLOAT:
isDouble = false;
defaultResult = 1;
break;
case OP_CMPL_DOUBLE:
isDouble = true;
defaultResult = -1;
break;
case OP_CMPG_DOUBLE:
isDouble = true;
defaultResult = 1;
break;
default:
return true;
}
if (isDouble) {
rlSrc1 = loadValueWide(cUnit, rlSrc1, kFPReg);
rlSrc2 = loadValueWide(cUnit, rlSrc2, kFPReg);
dvmCompilerClobberSReg(cUnit, rlDest.sRegLow);
rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
loadConstant(cUnit, rlResult.lowReg, defaultResult);
newLIR2(cUnit, kThumb2Vcmpd, S2D(rlSrc1.lowReg, r1Src2.highReg),
S2D(rlSrc2.lowReg, rlSrc2.highReg));
} else {
rlSrc1 = loadValue(cUnit, rlSrc1, kFPReg);
rlSrc2 = loadValue(cUnit, rlSrc2, kFPReg);
dvmCompilerClobberSReg(cUnit, rlDest.sRegLow);
rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
loadConstant(cUnit, rlResult.lowReg, defaultResult);
newLIR2(cUnit, kThumb2Vcmps, rlSrc1.lowReg, rlSrc2.lowReg);
}
assert(!FPREG(rlResult.lowReg));
newLIR0(cUnit, kThumb2Fmstat);
genIT(cUnit, (defaultResult == -1) ? kArmCondGt : kArmCondMi, "");
newLIR2(cUnit, kThumb2MovImmShift, rlResult.lowReg,
modifiedImmediate(-defaultResult)); // Must not alter ccodes
genIT(cUnit, kArmCondEq, "");
loadConstant(cUnit, rlResult.lowReg, 0);
storeValue(cUnit, rlDest, rlResult);
return false;
}
/*
This function returns the address of a free block on the disk.
The value returned will be the relative word address of the corresponding entry in the free list.
*/
int FindFreeBlock(){
int i,j;
for(i = DISK_FREE_LIST ; i < DISK_FREE_LIST + NO_OF_FREE_LIST_BLOCKS ;i++){
for(j = 0 ; j < BLOCK_SIZE; j++){
if( getValue(disk[i].word[j]) == 0 ){
storeValue( disk[i].word[j] , 1 );
return ((i-DISK_FREE_LIST)*BLOCK_SIZE + j);
}
}
}
return -1;
}
/*
createDisk creates the disk file if not present.
if format is equal to zero then the function creates the disk but does not format it.
if format is not equal to zero then the function will create and format the disk.
Formatting is done as follows:
1. A memory copy of the disk is maintained. This copy contains NO_BLOCKS_TO_COPY + EXTRA_BLOCKS (in this case 13 + 1) blocks.
The extra block is a temporary block. This memory copy is called the virtual disk. This is first cleared.
2. Then the memory freelist is initialised.
3. The fat blocks are also initialised. The basic block entries are all set to -1. The memory copy is then committed to the
disk file.
4. Finally the entry for init process is made.
*/
void createDisk(int format){
int fd;
if(format)
{
fd = open(DISK_NAME, O_CREAT | O_TRUNC | O_SYNC, 0666);
clearVirtDisk();
close(fd);
// loadFileToVirtualDisk(); note: commented this line
int i=0,j=0;
for(j=0; j<(NO_OF_FREE_LIST_BLOCKS*BLOCK_SIZE); j++)
{
i=j/BLOCK_SIZE;
if( (j>=DATA_START_BLOCK) && (j<(DATA_START_BLOCK+NO_OF_DATA_BLOCKS) ))
storeValue(disk[DISK_FREE_LIST+i].word[j], 0);
else
storeValue(disk[DISK_FREE_LIST+i].word[j], 1);
}
for(i=0; i<NO_OF_FREE_LIST_BLOCKS;i++)
writeToDisk(DISK_FREE_LIST+i, DISK_FREE_LIST+i);
for(j=0; j<NO_OF_FAT_BLOCKS; j++)
{
for(i=FATENTRY_BASICBLOCK; i<BLOCK_SIZE; i=i+FATENTRY_SIZE)
{
storeValue(disk[FAT + j].word[i], -1);
}
writeToDisk(FAT+j, FAT+j);
}
initializeINIT();
}
else
{
fd = open(DISK_NAME, O_CREAT, 0666);
close(fd);
}
}
void DesignerSettings::toSettings(QSettings *settings) const
{
settings->beginGroup(QLatin1String(DesignerSettingsGroupKey::QML_SETTINGS_GROUP));
settings->beginGroup(QLatin1String(DesignerSettingsGroupKey::QML_DESIGNER_SETTINGS_GROUP));
QHash<QByteArray, QVariant>::const_iterator i = constBegin();
while (i != constEnd()) {
storeValue(settings, i.key(), i.value());
++i;
}
settings->endGroup();
settings->endGroup();
}
void Inter_v7::o7_getSystemProperty() {
const char *property = _vm->_game->_script->evalString();
if (!scumm_stricmp(property, "TotalPhys")) {
// HACK
storeValue(1000000);
return;
}
if (!scumm_stricmp(property, "AvailPhys")) {
// HACK
storeValue(1000000);
return;
}
if (!scumm_stricmp(property, "TimeGMT")) {
renewTimeInVars();
storeValue(0);
return;
}
warning("Inter_v7::o7_getSystemProperty(): Unknown property \"%s\"", property);
storeValue(0);
}
void BaseStatusContainer::disconnectAndStoreLastStatus(bool disconnectWithCurrentDescription,
const QString &disconnectDescription)
{
if (!isValidStorage())
return;
storeValue("LastStatusDescription", status().description());
storeValue("LastStatusName", statusName());
if (status().type() == "Offline")
return;
Status disconnectStatus;
disconnectStatus.setType("Offline");
QString description;
if (disconnectWithCurrentDescription)
description = status().description();
else
description = disconnectDescription;
disconnectStatus.setDescription(description);
setStatus(disconnectStatus);
}
static bool genInlinedMinMaxInt(CompilationUnit *cUnit, MIR *mir, bool isMin)
{
RegLocation rlSrc1 = dvmCompilerGetSrc(cUnit, mir, 0);
RegLocation rlSrc2 = dvmCompilerGetSrc(cUnit, mir, 1);
rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
RegLocation rlDest = inlinedTarget(cUnit, mir, false);
RegLocation rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
opRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
genIT(cUnit, (isMin) ? kArmCondGt : kArmCondLt, "E");
opRegReg(cUnit, kOpMov, rlResult.lowReg, rlSrc2.lowReg);
opRegReg(cUnit, kOpMov, rlResult.lowReg, rlSrc1.lowReg);
genBarrier(cUnit);
storeValue(cUnit, rlDest, rlResult);
return false;
}
static bool genArithOpFloat(CompilationUnit *cUnit, MIR *mir,
RegLocation rlDest, RegLocation rlSrc1,
RegLocation rlSrc2)
{
int op = kThumbBkpt;
RegLocation rlResult;
/*
* Don't attempt to optimize register usage since these opcodes call out to
* the handlers.
*/
switch (mir->dalvikInsn.opcode) {
case OP_ADD_FLOAT_2ADDR:
case OP_ADD_FLOAT:
op = kThumb2Vadds;
break;
case OP_SUB_FLOAT_2ADDR:
case OP_SUB_FLOAT:
op = kThumb2Vsubs;
break;
case OP_DIV_FLOAT_2ADDR:
case OP_DIV_FLOAT:
op = kThumb2Vdivs;
break;
case OP_MUL_FLOAT_2ADDR:
case OP_MUL_FLOAT:
op = kThumb2Vmuls;
break;
case OP_REM_FLOAT_2ADDR:
case OP_REM_FLOAT:
case OP_NEG_FLOAT: {
return genArithOpFloatPortable(cUnit, mir, rlDest, rlSrc1,
rlSrc2);
}
default:
return true;
}
rlSrc1 = loadValue(cUnit, rlSrc1, kFPReg);
rlSrc2 = loadValue(cUnit, rlSrc2, kFPReg);
rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kFPReg, true);
newLIR3(cUnit, (ArmOpcode)op, rlResult.lowReg, rlSrc1.lowReg,
rlSrc2.lowReg);
storeValue(cUnit, rlDest, rlResult);
return false;
}
static void popStackFrame(VM *vm, const int **ip, int *bp, uint returnValues)
{
uint expectedReturnValues;
const int *oldIP = *ip;
int oldBP = *bp;
*bp = IVPop(&vm->callStack);
*ip = vmBytecode + IVPop(&vm->callStack);
expectedReturnValues = (uint)*(*ip)++;
assert(returnValues >= expectedReturnValues); /* TODO: Fail nicely */
while (expectedReturnValues--)
{
storeValue(vm, *bp, *(*ip)++, loadValue(vm, oldBP, *oldIP++));
}
IVSetSize(&vm->stack, (size_t)oldBP);
}
/****************************************************************************
Desc: Set a FLMINT value for a vector element.
****************************************************************************/
RCODE XFLAPI F_DataVector::setINT(
FLMUINT uiElementNumber,
FLMINT iNum)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE ucStorageBuf [FLM_MAX_NUM_BUF_SIZE];
FLMUINT uiStorageLen;
FLMBOOL bNeg = FALSE;
if (iNum < 0)
{
bNeg = TRUE;
iNum = -iNum;
}
uiStorageLen = sizeof( ucStorageBuf);
if( ((FLMUINT)iNum) <= gv_uiMaxUInt32Val)
{
if( RC_BAD( rc = flmNumber64ToStorage( (FLMUINT64)iNum,
&uiStorageLen, ucStorageBuf, bNeg, FALSE)))
{
goto Exit;
}
}
else
{
if( RC_BAD( rc = flmNumber64ToStorage( (FLMUINT64)iNum,
&uiStorageLen, ucStorageBuf, bNeg, FALSE)))
{
goto Exit;
}
}
if (RC_BAD( rc = storeValue( uiElementNumber,
XFLM_NUMBER_TYPE, ucStorageBuf, uiStorageLen)))
{
goto Exit;
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Set a FLMUINT value for a vector element.
****************************************************************************/
RCODE XFLAPI F_DataVector::setUINT(
FLMUINT uiElementNumber,
FLMUINT uiNum)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE ucStorageBuf [FLM_MAX_NUM_BUF_SIZE];
FLMUINT uiStorageLen;
uiStorageLen = sizeof( ucStorageBuf);
if (uiNum <= gv_uiMaxUInt32Val)
{
if (RC_BAD( rc = flmNumber64ToStorage( uiNum,
&uiStorageLen, ucStorageBuf, FALSE, FALSE)))
{
goto Exit;
}
}
else
{
if (RC_BAD( rc = flmNumber64ToStorage( uiNum,
&uiStorageLen, ucStorageBuf, FALSE, FALSE)))
{
goto Exit;
}
}
if (RC_BAD( rc = storeValue( uiElementNumber,
XFLM_NUMBER_TYPE, ucStorageBuf, uiStorageLen)))
{
goto Exit;
}
Exit:
return( rc);
}
void ContactShared::store()
{
if (!isValidStorage())
return;
ensureLoaded();
Shared::store();
storeValue("Id", Id);
storeValue("Priority", Priority);
storeValue("Dirty", RosterEntryState::Synchronized != Entry->state());
// Detached property needs to be always stored, see the load() method.
storeValue("Detached", RosterEntryState::Detached == Entry->state());
storeValue("Account", ContactAccount->uuid().toString());
storeValue("Buddy", !isAnonymous() ? OwnerBuddy->uuid().toString() : QString());
removeValue("Avatar");
removeValue("Contact");
}
/*
This function adds the name, size and basic block address of the file to corresponding entry in the fat.
The first arguement is a relative address
*/
void AddEntryToMemFat(int startIndexInFat, char *nameOfFile, int size_of_file, int addrOfBasicBlock){
strcpy(disk[FAT + (startIndexInFat / BLOCK_SIZE)].word[startIndexInFat % BLOCK_SIZE],nameOfFile);
storeValue( disk[FAT + (startIndexInFat / BLOCK_SIZE)].word[startIndexInFat % BLOCK_SIZE + FATENTRY_FILESIZE] , size_of_file );
storeValue( disk[FAT + (startIndexInFat / BLOCK_SIZE)].word[startIndexInFat % BLOCK_SIZE + FATENTRY_BASICBLOCK] , addrOfBasicBlock );
}
/****************************************************************************
Desc: Populate a vector's data components from the data part of a key.
****************************************************************************/
RCODE F_DataVector::inputData(
IXD * pIxd,
const FLMBYTE * pucData,
FLMUINT uiInputLen)
{
RCODE rc = NE_XFLM_OK;
ICD * pIcd = pIxd->pFirstData;
FLMUINT uiDataComponent = 0;
FLMUINT uiDataLength;
FLMUINT uiSENLen;
while (pIcd)
{
if (!uiInputLen)
{
break;
}
// Get the data length - it is stored as a SEN
uiSENLen = f_getSENLength( *pucData);
if (uiSENLen > uiInputLen)
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
if( RC_BAD( rc = f_decodeSEN( &pucData,
&pucData[ uiSENLen], &uiDataLength)))
{
goto Exit;
}
uiInputLen -= uiSENLen;
if (uiDataLength > uiInputLen)
{
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
// Store the name ID
if (RC_BAD( rc = setNameId( uiDataComponent + pIxd->uiNumKeyComponents,
pIcd->uiDictNum,
(FLMBOOL)((pIcd->uiFlags & ICD_IS_ATTRIBUTE)
? TRUE
: FALSE), TRUE)))
{
goto Exit;
}
// Store the data into the vector.
if (RC_BAD( rc = storeValue( uiDataComponent + pIxd->uiNumKeyComponents,
icdGetDataType( pIcd),
pucData, uiDataLength, NULL)))
{
goto Exit;
}
pucData += uiDataLength;
uiInputLen -= uiDataLength;
pIcd = pIcd->pNextDataComponent;
uiDataComponent++;
}
// Output the remaining name IDs, even if the data is missing.
while (pIcd)
{
// Store the name ID
if (RC_BAD( rc = setNameId( uiDataComponent + pIxd->uiNumKeyComponents,
pIcd->uiDictNum,
(FLMBOOL)((pIcd->uiFlags & ICD_IS_ATTRIBUTE)
? TRUE
: FALSE), TRUE)))
{
goto Exit;
}
pIcd = pIcd->pNextDataComponent;
uiDataComponent++;
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Populate a vector's components from the key part of an index key.
****************************************************************************/
RCODE F_DataVector::inputKey(
IXD * pIxd,
const FLMBYTE * pucKey,
FLMUINT uiKeyLen)
{
RCODE rc = NE_XFLM_OK;
const FLMBYTE * pucKeyEnd = pucKey + uiKeyLen;
FLMBYTE ucDataBuf [XFLM_MAX_KEY_SIZE];
FLMUINT uiDataLen;
ICD * pIcd;
FLMUINT uiLanguage = pIxd->uiLanguage;
FLMUINT uiComponentLen;
FLMUINT uiDataType;
FLMBOOL bDataRightTruncated;
FLMBOOL bFirstSubstring;
FLMBOOL bIsText;
FLMUINT uiComponent;
FLMUINT64 ui64Id;
FLMUINT uiDictNumber;
flmAssert( uiKeyLen);
// Loop for each compound piece of key
uiComponent = 0;
pIcd = pIxd->pFirstKey;
while (pIcd)
{
if (uiKeyLen < 2)
{
rc = RC_SET_AND_ASSERT( NE_XFLM_BTREE_ERROR);
goto Exit;
}
uiComponentLen = getKeyComponentLength( pucKey);
bDataRightTruncated = isKeyComponentTruncated( pucKey);
uiKeyLen -= 2;
pucKey += 2;
if (uiComponentLen > uiKeyLen)
{
rc = RC_SET_AND_ASSERT( NE_XFLM_BTREE_ERROR);
goto Exit;
}
bFirstSubstring = FALSE;
bIsText = (icdGetDataType( pIcd) == XFLM_TEXT_TYPE &&
!(pIcd->uiFlags & (ICD_PRESENCE | ICD_METAPHONE)))
? TRUE
: FALSE;
uiDataType = icdGetDataType( pIcd);
uiDictNumber = pIcd->uiDictNum;
if (uiComponentLen)
{
if (pIcd->uiFlags & ICD_PRESENCE)
{
FLMUINT uiNum;
if (uiComponentLen != 4 || bDataRightTruncated)
{
rc = RC_SET_AND_ASSERT( NE_XFLM_BTREE_ERROR);
goto Exit;
}
uiNum = (FLMUINT)f_bigEndianToUINT32( pucKey);
// What is stored in the key better match the dictionary
// number of the ICD.
if (pIcd->uiDictNum != ELM_ROOT_TAG)
{
if (uiNum != uiDictNumber)
{
rc = RC_SET_AND_ASSERT( NE_XFLM_BTREE_ERROR);
goto Exit;
}
}
else
{
uiDictNumber = uiNum;
}
if (RC_BAD( rc = setUINT( uiComponent, uiNum)))
{
goto Exit;
}
}
else if (pIcd->uiFlags & ICD_METAPHONE)
{
uiDataLen = sizeof( ucDataBuf);
if ( uiComponentLen)
{
if( RC_BAD( rc = flmCollationNum2StorageNum( pucKey,
uiComponentLen, ucDataBuf, &uiDataLen)))
{
goto Exit;
}
}
else
{
uiDataLen = 0;
}
if (bDataRightTruncated)
{
rc = RC_SET_AND_ASSERT( NE_XFLM_BTREE_ERROR);
goto Exit;
}
// Allocate and copy value into the component. NOTE:
// storeValue handles zero length data.
if (RC_BAD( rc = storeValue( uiComponent, XFLM_NUMBER_TYPE,
ucDataBuf, uiDataLen)))
{
goto Exit;
}
}
else
{
// Grab only the Nth section of key if compound key
switch (uiDataType)
{
case XFLM_TEXT_TYPE:
{
FLMBOOL bTmpTruncated = FALSE;
if (uiComponentLen)
{
uiDataLen = sizeof( ucDataBuf);
if (RC_BAD( rc = flmColText2StorageText( pucKey,
uiComponentLen,
ucDataBuf, &uiDataLen, uiLanguage,
&bTmpTruncated, &bFirstSubstring)))
{
goto Exit;
}
if (bTmpTruncated != bDataRightTruncated)
{
rc = RC_SET_AND_ASSERT( NE_XFLM_BTREE_ERROR);
goto Exit;
}
}
else
{
uiDataLen = 0;
}
break;
}
case XFLM_NUMBER_TYPE:
{
if (uiComponentLen)
{
uiDataLen = sizeof( ucDataBuf);
if( RC_BAD( rc = flmCollationNum2StorageNum( pucKey,
uiComponentLen, ucDataBuf, &uiDataLen)))
{
goto Exit;
}
}
else
{
uiDataLen = 0;
}
if (bDataRightTruncated)
{
rc = RC_SET_AND_ASSERT( NE_XFLM_BTREE_ERROR);
goto Exit;
}
break;
}
case XFLM_BINARY_TYPE:
{
uiDataLen = uiComponentLen;
if (uiComponentLen > sizeof( ucDataBuf))
{
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
goto Exit;
}
if (uiComponentLen)
{
f_memcpy( ucDataBuf, pucKey, uiComponentLen);
}
break;
}
default:
rc = RC_SET( NE_XFLM_DATA_ERROR);
goto Exit;
}
// Allocate and copy value into the component. NOTE:
// storeValue handles zero length data.
if (RC_BAD( rc = storeValue( uiComponent, uiDataType, ucDataBuf,
uiDataLen)))
{
goto Exit;
}
// Set first sub-string and truncated flags.
if ((pIcd->uiFlags & ICD_SUBSTRING) && !bFirstSubstring)
{
setLeftTruncated( uiComponent);
}
if (bDataRightTruncated)
{
setRightTruncated( uiComponent);
}
}
}
else
{
if ((pIcd->uiFlags & ICD_PRESENCE) && uiDictNumber == ELM_ROOT_TAG)
{
uiDictNumber = 0;
}
}
// Store the name ID
if (RC_BAD( rc = setNameId( uiComponent, uiDictNumber,
(FLMBOOL)((pIcd->uiFlags & ICD_IS_ATTRIBUTE)
? TRUE
: FALSE), FALSE)))
{
goto Exit;
}
// Position to the end of this component
flmAssert( uiKeyLen >= uiComponentLen);
pucKey += uiComponentLen;
uiKeyLen -= uiComponentLen;
uiComponent++;
pIcd = pIcd->pNextKeyComponent;
}
// See if we have a document ID.
if (RC_BAD( rc = f_decodeSEN64( &pucKey, pucKeyEnd, &m_ui64DocumentID)))
{
goto Exit;
}
// Get the node IDs for the key components, if any
pIcd = pIxd->pFirstKey;
uiComponent = 0;
while (pIcd)
{
// Extract the component node ID
if (RC_BAD( rc = f_decodeSEN64( &pucKey, pucKeyEnd, &ui64Id)))
{
goto Exit;
}
// No need to store if it is zero
if (ui64Id)
{
if (RC_BAD( rc = setID( uiComponent, ui64Id)))
{
goto Exit;
}
}
uiComponent++;
pIcd = pIcd->pNextKeyComponent;
}
// Get the node IDs for the data components, if any
pIcd = pIxd->pFirstData;
while (pIcd)
{
// Extract the component node ID
if (RC_BAD( rc = f_decodeSEN64( &pucKey, pucKeyEnd, &ui64Id)))
{
goto Exit;
}
// No need to store if it is zero
if (ui64Id)
{
if (RC_BAD( rc = setID( uiComponent, ui64Id)))
{
goto Exit;
}
}
// Store the name ID
if (RC_BAD( rc = setNameId( uiComponent, pIcd->uiDictNum,
(FLMBOOL)((pIcd->uiFlags & ICD_IS_ATTRIBUTE)
? TRUE
: FALSE), TRUE)))
{
goto Exit;
}
uiComponent++;
pIcd = pIcd->pNextDataComponent;
}
// Get the node IDs for the context components, if any
pIcd = pIxd->pFirstContext;
while (pIcd)
{
// Extract the component node ID
if (RC_BAD( rc = f_decodeSEN64( &pucKey, pucKeyEnd, &ui64Id)))
{
goto Exit;
}
// No need to store if it is zero
if (ui64Id)
{
if (RC_BAD( rc = setID( uiComponent, ui64Id)))
{
goto Exit;
}
}
// Store the name ID
if (RC_BAD( rc = setNameId( uiComponent, pIcd->uiDictNum,
(FLMBOOL)((pIcd->uiFlags & ICD_IS_ATTRIBUTE)
? TRUE
: FALSE), TRUE)))
{
goto Exit;
}
uiComponent++;
pIcd = pIcd->pNextKeyComponent;
}
Exit:
return( rc);
}
void Store::hintBlock(const BinaryString &digest, const BinaryString &hint)
{
// Values for digest are candidate nodes, re-hash to store hints
storeValue(Store::Hash(digest), hint, Temporary);
}
static bool genConversion(CompilationUnit *cUnit, MIR *mir)
{
Opcode opcode = mir->dalvikInsn.opcode;
int op = kThumbBkpt;
bool longSrc = false;
bool longDest = false;
int srcReg;
RegLocation rlSrc;
RegLocation rlDest;
RegLocation rlResult;
switch (opcode) {
case OP_INT_TO_FLOAT:
longSrc = false;
longDest = false;
op = kThumb2VcvtIF;
break;
case OP_FLOAT_TO_INT:
longSrc = false;
longDest = false;
op = kThumb2VcvtFI;
break;
case OP_DOUBLE_TO_FLOAT:
longSrc = true;
longDest = false;
op = kThumb2VcvtDF;
break;
case OP_FLOAT_TO_DOUBLE:
longSrc = false;
longDest = true;
op = kThumb2VcvtFd;
break;
case OP_INT_TO_DOUBLE:
longSrc = false;
longDest = true;
op = kThumb2VcvtID;
break;
case OP_DOUBLE_TO_INT:
longSrc = true;
longDest = false;
op = kThumb2VcvtDI;
break;
case OP_LONG_TO_DOUBLE:
case OP_FLOAT_TO_LONG:
case OP_LONG_TO_FLOAT:
case OP_DOUBLE_TO_LONG:
return genConversionPortable(cUnit, mir);
default:
return true;
}
if (longSrc) {
rlSrc = dvmCompilerGetSrcWide(cUnit, mir, 0, 1);
rlSrc = loadValueWide(cUnit, rlSrc, kFPReg);
srcReg = S2D(rlSrc.lowReg, rlSrc.highReg);
} else {
rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
rlSrc = loadValue(cUnit, rlSrc, kFPReg);
srcReg = rlSrc.lowReg;
}
if (longDest) {
rlDest = dvmCompilerGetDestWide(cUnit, mir, 0, 1);
rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kFPReg, true);
newLIR2(cUnit, (ArmOpcode)op, S2D(rlResult.lowReg, rlResult.highReg),
srcReg);
storeValueWide(cUnit, rlDest, rlResult);
} else {
rlDest = dvmCompilerGetDest(cUnit, mir, 0);
rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kFPReg, true);
newLIR2(cUnit, (ArmOpcode)op, rlResult.lowReg, srcReg);
storeValue(cUnit, rlDest, rlResult);
}
return false;
}
CbkReturnValueE SerializerBase::storeStream(Base &_rb, FncData &_rfd, void */*_pctx*/){
SerializerBase &rs(static_cast<SerializerBase&>(_rb));
idbgx(Debug::ser_bin, "");
if(!rs.cpb) return Success;
int32 toread = rs.be - rs.cpb;
if(toread < MINSTREAMBUFLEN) return Wait;
toread -= 2;//the buffsize
if(toread > _rfd.s){
toread = static_cast<int32>(_rfd.s);
}
if(toread > CRCValue<uint16>::maximum()){
toread = CRCValue<uint16>::maximum();
}
if(toread == 0){
rs.cpb = storeValue(rs.cpb, (uint16)0);
return Success;
}
std::istream &ris = *reinterpret_cast<std::istream*>(_rfd.p);
ris.read(rs.cpb + 2, toread);
int rv;
if(ris.eof() || ris.fail()){
rv = -1;
}else{
rv = ris.gcount();
}
idbgx(Debug::ser_bin, "toread = "<<toread<<" rv = "<<rv);
if(rv > 0){
if((rs.streamsz + rv) > rs.lmts.streamlimit){
rs.streamerr = rs.err = ERR_STREAM_LIMIT;
idbgx(Debug::ser_bin, "ERR_STREAM_LIMIT");
return Failure;
}
toread = rv;
const CRCValue<uint16> crcsz((uint16)toread);
storeValue(rs.cpb, (uint16)crcsz);
idbgx(Debug::ser_bin, "store crcsz = "<<crcsz<<" sz = "<<toread);
idbgx(Debug::ser_bin, "store value "<<(uint16)crcsz);
rs.cpb += toread + 2;
rs.streamsz += toread;
}else if(rv == 0){
idbgx(Debug::ser_bin, "done storing stream");
rs.cpb = storeValue(rs.cpb, (uint16)0);
return Success;
}else{
rs.streamerr = ERR_STREAM_READ;
idbgx(Debug::ser_bin, "ERR_STREAM_READ");
rs.cpb = storeValue(rs.cpb, (uint16)0xffff);
return Success;
}
if(_rfd.s != -1ULL){
_rfd.s -= toread;
if(_rfd.s == 0){
return Continue;
}
}
idbgx(Debug::ser_bin, "streamsz = "<<rs.streamsz);
return Continue;
}
void AccountShared::store()
{
if (!isValidStorage())
return;
Shared::store();
storeValue("Identity", AccountIdentity.uuid().toString());
storeValue("Protocol", ProtocolName);
storeValue("Id", id());
storeValue("RememberPassword", RememberPassword);
if (RememberPassword && HasPassword)
storeValue("Password", pwHash(password()));
else
removeValue("Password");
storeValue("UseProxy", ProxySettings.enabled());
storeValue("ProxyHost", ProxySettings.address());
storeValue("ProxyPort", ProxySettings.port());
storeValue("ProxyRequiresAuthentication", ProxySettings.requiresAuthentication());
storeValue("ProxyUser", ProxySettings.user());
storeValue("ProxyPassword", ProxySettings.password());
storeValue("PrivateStatus", PrivateStatus);
}
static VM *execute(VM *vm)
{
int maxInstructions = 100;
while (maxInstructions--)
{
int i = *vm->ip;
int arg = i >> 8;
if (DEBUG_TRACE)
{
traceLine(vm, (int)(vm->ip - vmBytecode));
fflush(stdout);
}
vm->ip++;
switch ((Instruction)(i & 0xff))
{
case OP_NULL:
storeValue(vm, vm->bp, arg, VNull);
break;
case OP_TRUE:
storeValue(vm, vm->bp, arg, VTrue);
break;
case OP_FALSE:
storeValue(vm, vm->bp, arg, VFalse);
break;
case OP_EMPTY_LIST:
storeValue(vm, vm->bp, arg, VEmptyList);
break;
case OP_LIST:
{
vref result;
vref *array;
vref *write;
assert(arg);
array = VCreateArray((size_t)arg);
for (write = array; arg--; write++)
{
vref value = loadValue(vm, vm->bp, *vm->ip++);
if (value == VFuture)
{
vm->ip += arg;
VAbortArray(array);
result = VFuture;
goto storeList;
}
*write = value;
assert(HeapGetObjectType(*write) != TYPE_FUTURE);
}
result = VFinishArray(array);
storeList:
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_FILELIST:
{
vref string = refFromInt(arg);
vref result;
if (string == VFuture)
{
result = VFuture;
}
else
{
result = VCreateFilelistGlob(VGetString(string), VStringLength(string));
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_STORE_CONSTANT:
storeValue(vm, vm->bp, arg, refFromInt(*vm->ip++));
break;
case OP_COPY:
storeValue(vm, vm->bp, *vm->ip++, loadValue(vm, vm->bp, arg));
break;
case OP_NOT:
storeValue(vm, vm->bp, *vm->ip++,
VNot(loadValue(vm, vm->bp, arg)));
break;
case OP_NEG:
{
vref result = VNeg(vm, loadValue(vm, vm->bp, arg));
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_INV:
{
vref result = VInv(vm, loadValue(vm, vm->bp, arg));
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_ITER_NEXT:
{
vref collection = loadValue(vm, vm->bp, *vm->ip++);
int indexVariable = *vm->ip++;
vref index = loadValue(vm, vm->bp, indexVariable);
vref step = loadValue(vm, vm->bp, *vm->ip++);
if (index == VFuture || step == VFuture)
{
index = VFuture;
storeValue(vm, vm->bp, indexVariable, index);
goto iterNextFuture;
}
else
{
index = VAdd(vm, index, step);
storeValue(vm, vm->bp, indexVariable, index);
}
if (collection == VFuture)
{
iterNextFuture:
assert(0);
}
switch (VGetBool(VValidIndex(vm, collection, index)))
{
case TRUTHY:
storeValue(vm, vm->bp, *vm->ip++, VIndexedAccess(vm, collection, index));
break;
case FALSY:
vm->ip += arg - 2;
break;
case FUTURE:
unreachable;
}
break;
}
case OP_EQUALS:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VEquals(value1, value2);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_NOT_EQUALS:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VEquals(value1, value2);
if (!result)
{
return vm;
}
switch (VGetBool(result))
{
case TRUTHY: result = VFalse; break;
case FALSY: result = VTrue; break;
case FUTURE: break;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_LESS_EQUALS:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VLessEquals(vm, value1, value2);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_GREATER_EQUALS:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VLessEquals(vm, value2, value1);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_LESS:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VLess(vm, value1, value2);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_GREATER:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VLess(vm, value2, value1);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_ADD:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VAdd(vm, value1, value2);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_SUB:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VSub(vm, value1, value2);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_MUL:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VMul(vm, value1, value2);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_DIV:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VDiv(vm, value1, value2);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_REM:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VRem(vm, value1, value2);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_CONCAT_LIST:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VConcat(vm, value1, value2);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_CONCAT_STRING:
{
vref result;
assert(!IVSize(&temp));
for (i = 0; i < arg; i++)
{
IVAdd(&temp, intFromRef(loadValue(vm, vm->bp, *vm->ip++)));
}
result = VConcatString((size_t)arg, (vref*)IVGetWritePointer(&temp, 0));
storeValue(vm, vm->bp, *vm->ip++, result);
IVSetSize(&temp, 0);
break;
}
case OP_INDEXED_ACCESS:
{
vref collection = loadValue(vm, vm->bp, arg);
vref index = loadValue(vm, vm->bp, *vm->ip++);
vref result = VIndexedAccess(vm, collection, index);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_RANGE:
{
vref value1 = loadValue(vm, vm->bp, arg);
vref value2 = loadValue(vm, vm->bp, *vm->ip++);
vref result = VRange(vm, value1, value2);
if (!result)
{
return vm;
}
storeValue(vm, vm->bp, *vm->ip++, result);
break;
}
case OP_JUMP:
vm->ip += arg + 1;
break;
case OP_BRANCH_TRUE:
{
vref value = loadValue(vm, vm->bp, *vm->ip++);
VBool b = VGetBool(value);
vm->base.clonePoints++;
if (vm->child && vm->base.clonePoints >= vm->child->clonePoints)
{
if (vm->base.clonePoints > vm->child->clonePoints)
{
VMDispose(vm->child);
vm->child = null;
goto branchTrueNoChild;
}
assert(!vm->child->fullVM);
if (b == FUTURE)
{
VMReplaceCloneBranch(vm, vm->ip + arg);
}
else
{
uint keepChild;
if (b == FALSY)
{
keepChild = 0;
}
else
{
vm->ip += arg;
keepChild = 1;
}
vm->child = VMDisposeBranch((VMBranch*)vm->child, keepChild);
}
}
else
{
branchTrueNoChild:
switch (b)
{
case FALSY:
break;
case FUTURE:
assert(!vm->child);
VMCloneBranch(vm, vm->ip);
/* fallthrough */
case TRUTHY:
vm->ip += arg;
break;
}
}
break;
}
case OP_BRANCH_FALSE:
{
vref value = loadValue(vm, vm->bp, *vm->ip++);
VBool b = VGetBool(value);
vm->base.clonePoints++;
if (vm->child && vm->base.clonePoints >= vm->child->clonePoints)
{
if (vm->base.clonePoints > vm->child->clonePoints)
{
VMDispose(vm->child);
vm->child = null;
goto branchFalseNoChild;
}
assert(!vm->child->fullVM);
if (b == FUTURE)
{
VMReplaceCloneBranch(vm, vm->ip);
vm->ip += arg;
}
else
{
uint keepChild;
if (b == FALSY)
{
vm->ip += arg;
keepChild = 0;
}
else
{
keepChild = 1;
}
vm->child = VMDisposeBranch((VMBranch*)vm->child, keepChild);
}
}
else
{
branchFalseNoChild:
switch (b)
{
case TRUTHY:
break;
case FUTURE:
assert(!vm->child);
VMCloneBranch(vm, vm->ip);
/* fallthrough */
case FALSY:
vm->ip += arg;
break;
}
}
break;
}
case OP_RETURN:
assert(IVSize(&vm->callStack));
popStackFrame(vm, &vm->ip, &vm->bp, (uint)arg);
break;
case OP_RETURN_VOID:
if (!IVSize(&vm->callStack))
{
vm->base.clonePoints++;
VMHalt(vm, 0);
return vm;
}
popStackFrame(vm, &vm->ip, &vm->bp, 0);
break;
case OP_INVOKE:
{
vref *values;
int function = *vm->ip++;
values = (vref*)IVGetAppendPointer(&vm->stack, (size_t)arg);
for (i = 0; i < arg; i++)
{
*values++ = loadValue(vm, vm->bp, *vm->ip++);
}
IVAdd(&vm->callStack, (int)(vm->ip - vmBytecode));
IVAdd(&vm->callStack, vm->bp);
initStackFrame(vm, &vm->ip, &vm->bp, function, (uint)arg);
break;
}
case OP_INVOKE_NATIVE:
{
nativefunctionref nativeFunction = refFromInt(arg);
vref value;
int storeAt;
assert(!vm->job);
vm->base.clonePoints++;
if (vm->child && vm->base.clonePoints >= vm->child->clonePoints)
{
VM *child = (VM*)vm->child;
assert(vm->child->fullVM);
VMReplaceChild(vm, child);
}
value = NativeInvoke(vm, nativeFunction);
if (vm->idle)
{
return vm;
}
storeAt = *vm->ip++;
storeValue(vm, vm->bp, storeAt, value);
if (vm->job)
{
vm->job->storeAt = storeAt;
vm->idle = true;
/* TODO: Activate speculative execution */
JobExecute(vm->job);
if (unlikely(vm->failMessage))
{
return vm;
}
/* vm = VMClone(vm, vm->ip); */
}
break;
}
case OP_FUNCTION:
case OP_FUNCTION_UNLINKED:
case OP_LOAD_FIELD:
case OP_STORE_FIELD:
case OP_ITER_NEXT_INDEXED:
case OP_JUMPTARGET:
case OP_JUMP_INDEXED:
case OP_BRANCH_TRUE_INDEXED:
case OP_BRANCH_FALSE_INDEXED:
case OP_INVOKE_UNLINKED:
case OP_UNKNOWN_VALUE:
case OP_FILE:
case OP_LINE:
case OP_ERROR:
default:
unreachable;
}
}
return vm;
}
/**
* @brief Computes temperature-dependent focal length
*
* This method computes temperature dependent focal lengths based upon a 5th
* order polynomial using the FocalPlaneTemperature keyword value stored in the
* ISIS label (it is the FOCAL_PLANE_TEMPERATURE PDS keyword). At the time of
* this writing, only (the two) linear terms are used.
*
* In addition, this method is initially coded to be backword compatible but
* this feature is likely to be removed when the kernels become fully adopted.
*
* IMPORTANT: The computed temperature dependent focal length is stored in the
* label of the cube during spiceinit. This implementation uses the special
* recording of keywords as retrieved from kernels and stores them as a string
* value so (SOCET) folks can easily read and apply the focal lengths in their
* environments. String storage is preferred over storing as double since
* these values are stored in hexidecimal format.
*
* @author Kris Becker (8/13/2012)
* @internal
* @history 2012-10-22 Kris Becker - Store temperature dependant keyword in instrument
* neutral keyword called TempDependentFocalLength.
*
* @param filterCode Integer MDIS instrument/filter code
* @param label Pvl label from cube being initialized where temperature
* keywords are extracted from.
*
* @return double Computed temperature dependant focal length
*/
double MdisCamera::computeFocalLength(const QString &filterCode,
Pvl &label) {
double focalLength(0.0);
QString tdflKey("TempDependentFocalLength");
// Determine if the desired value is already computed. We are interested
// in the temperature dependent value firstly. Backward compatibility is
// considered below.
QVariant my_tdfl = readStoredValue(tdflKey, SpiceStringType, 0);
if (my_tdfl.isValid()) {
focalLength = IString(my_tdfl.toString()).ToDouble();
}
else {
// Hasn't been computed yet (in spiceinit now - maybe) or the proper
// IK containing polynomial parameters is not in use.
// Original Code ensures backward compatibility
focalLength = getDouble("INS" + filterCode + "_FOCAL_LENGTH");
// Check for disabling of temperature dependent focal length
bool tdfl_disabled(false);
#ifndef DISABLE_TDFL_DISABLING
try {
IString tdfl_state = getString("DISABLE_MDIS_TD_FOCAL_LENGTH");
tdfl_disabled = ( "TRUE" == tdfl_state.UpCase() );
}
catch (IException &ie) {
tdfl_disabled = false;
}
#endif
// Attempt to retrieve parameters necessary for temperature-dependent focal
// length and computed it
if ( !tdfl_disabled ) {
// Wrap a try clause all around this so that if it fails, will return
// default
try {
PvlGroup &inst = label.findGroup("Instrument", Pvl::Traverse);
double fpTemp = inst["FocalPlaneTemperature"];
double fl(0.0);
QString fptCoeffs = "INS" + filterCode + "_FL_TEMP_COEFFS";
// Compute 5th order polynomial
for (int i = 0 ; i < 6 ; i++) {
fl += getDouble(fptCoeffs, i) * pow(fpTemp, (double) i);
}
// Store computed focal length
focalLength = fl;
storeValue(tdflKey, 0, SpiceStringType, QVariant(focalLength));
}
catch (IException &ie) {
// Noop when supporting old IKs
throw IException(ie, IException::Programmer,
"Failed to compute temperature-dependent focal length",
_FILEINFO_);
}
}
}
return (focalLength);
}
/*
* Generate array load
*/
static void genArrayGet(CompilationUnit *cUnit, MIR *mir, OpSize size,
RegLocation rlArray, RegLocation rlIndex,
RegLocation rlDest, int scale)
{
RegisterClass regClass = dvmCompilerRegClassBySize(size);
int lenOffset = OFFSETOF_MEMBER(ArrayObject, length);
int dataOffset = OFFSETOF_MEMBER(ArrayObject, contents);
RegLocation rlResult;
rlArray = loadValue(cUnit, rlArray, kCoreReg);
rlIndex = loadValue(cUnit, rlIndex, kCoreReg);
int regPtr;
/* null object? */
ArmLIR * pcrLabel = NULL;
if (!(mir->OptimizationFlags & MIR_IGNORE_NULL_CHECK)) {
pcrLabel = genNullCheck(cUnit, rlArray.sRegLow,
rlArray.lowReg, mir->offset, NULL);
}
regPtr = dvmCompilerAllocTemp(cUnit);
if (!(mir->OptimizationFlags & MIR_IGNORE_RANGE_CHECK)) {
int regLen = dvmCompilerAllocTemp(cUnit);
/* Get len */
loadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
/* regPtr -> array data */
opRegRegImm(cUnit, kOpAdd, regPtr, rlArray.lowReg, dataOffset);
genBoundsCheck(cUnit, rlIndex.lowReg, regLen, mir->offset,
pcrLabel);
dvmCompilerFreeTemp(cUnit, regLen);
} else {
/* regPtr -> array data */
opRegRegImm(cUnit, kOpAdd, regPtr, rlArray.lowReg, dataOffset);
}
if ((size == kLong) || (size == kDouble)) {
if (scale) {
int rNewIndex = dvmCompilerAllocTemp(cUnit);
opRegRegImm(cUnit, kOpLsl, rNewIndex, rlIndex.lowReg, scale);
opRegReg(cUnit, kOpAdd, regPtr, rNewIndex);
dvmCompilerFreeTemp(cUnit, rNewIndex);
} else {
opRegReg(cUnit, kOpAdd, regPtr, rlIndex.lowReg);
}
rlResult = dvmCompilerEvalLoc(cUnit, rlDest, regClass, true);
HEAP_ACCESS_SHADOW(true);
loadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
HEAP_ACCESS_SHADOW(false);
dvmCompilerFreeTemp(cUnit, regPtr);
storeValueWide(cUnit, rlDest, rlResult);
} else {
rlResult = dvmCompilerEvalLoc(cUnit, rlDest, regClass, true);
HEAP_ACCESS_SHADOW(true);
loadBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlResult.lowReg,
scale, size);
HEAP_ACCESS_SHADOW(false);
dvmCompilerFreeTemp(cUnit, regPtr);
storeValue(cUnit, rlDest, rlResult);
}
}
/**
* store_model() - store the given model into the given mxStruct structure
*/
void store_model(struct model *model, mxArray *mxOut[] )
{
int i = 0;
int numfields;
int dims[] = { 1,1 };
mxArray *mxStruct;
const char *fields[] = { "sv_num", "upper_bound", "b", "totwords",
"totdoc", "loo_error", "loo_recall", "loo_precision",
"xa_error","xa_recall", "xa_precision", "maxdiff",
"r_delta_sq", "r_delta_avg", "model_length", "loss",
"vcdim", "alpha", "lin_weights", "index",
"supvec" , "kernel_parm","example_length","a" };
numfields = 24;
mxStruct = mxCreateStructMatrix(1,1, numfields, fields);
storeValue(mxStruct, "sv_num", model->sv_num);
storeValue(mxStruct, "upper_bound", model->at_upper_bound);
storeValue(mxStruct, "b", model->b);
storeValue(mxStruct, "totwords", model->totwords);
storeValue(mxStruct, "totdoc", model->totdoc);
storeValue(mxStruct, "loo_error", model->loo_error);
storeValue(mxStruct, "loo_recall", model->loo_recall);
storeValue(mxStruct, "loo_precision", model->loo_precision);
storeValue(mxStruct, "xa_error", model->xa_error);
storeValue(mxStruct, "xa_recall", model->xa_recall);
storeValue(mxStruct, "xa_precision", model->xa_precision);
storeValue(mxStruct, "maxdiff", model->maxdiff);
storeValue(mxStruct, "r_delta_sq", model->r_delta_sq);
storeValue(mxStruct, "r_delta_avg", model->r_delta_avg);
storeValue(mxStruct, "model_length", model->model_length);
storeValue(mxStruct, "example_length", model->example_length);
storeValue(mxStruct, "loss", model->loss);
storeValue(mxStruct, "vcdim", model->vcdim);
storeArray(mxStruct, "alpha", model->alpha, model->totdoc);
storeArray(mxStruct, "a", model->a, model->totdoc);
if (model->lin_weights != NULL)
storeArray(mxStruct, "lin_weights", model->lin_weights, model->totdoc+2);
else {
if (verbosity > 0)
printf("Skipping lin_weights (array is empty)\n");
}
if (model->index != NULL)
storeArrayLong(mxStruct, "index", model->index, (int) model->totdoc);
else {
if (verbosity > 0)
printf("Skipping model->index (array is empty)\n");
}
if (model->supvec != NULL)
storeDocs(mxStruct,"supvec", model->supvec, model->sv_num, model->totwords);
else {
if (verbosity > 0) printf("Skipping supvec (array is empty)\n");
}
store_kern_parms(mxStruct, "kernel_parm", &(model->kernel_parm));
mxOut[0] = mxStruct;
}
/****************************************************************************
Desc: Set a UTF8 value for a vector element.
****************************************************************************/
RCODE XFLAPI F_DataVector::setUTF8(
FLMUINT uiElementNumber,
const FLMBYTE * pszUTF8,
FLMUINT uiBytesInBuffer)
{
RCODE rc = NE_XFLM_OK;
FLMBYTE * pucDataPtr;
FLMUINT uiLen;
FLMBYTE ucTmpBuf [64];
// A NULL or empty pszNative string is allowed - on those cases
// just set the data type.
if (pszUTF8 == NULL || *pszUTF8 == 0)
{
rc = storeValue( uiElementNumber, XFLM_TEXT_TYPE, NULL, 0);
goto Exit;
}
// See if it will fit in our temporary buffer on the stack.
uiLen = sizeof( ucTmpBuf);
if (RC_OK( rc = flmUTF8ToStorage(
pszUTF8, uiBytesInBuffer, ucTmpBuf, &uiLen)))
{
if (RC_BAD( rc = storeValue( uiElementNumber,
XFLM_TEXT_TYPE, ucTmpBuf, uiLen)))
{
goto Exit;
}
}
else if (rc != NE_XFLM_CONV_DEST_OVERFLOW)
{
goto Exit;
}
else
{
// Determine the length needed.
if (RC_BAD( rc = flmUTF8ToStorage(
pszUTF8, uiBytesInBuffer, NULL, &uiLen)))
{
goto Exit;
}
// Allocate space for it in the vector and get a pointer
// back so we can then store it.
if (RC_BAD( rc = storeValue( uiElementNumber,
XFLM_TEXT_TYPE, NULL, uiLen, &pucDataPtr)))
{
goto Exit;
}
// Store it out to the space we just allocated.
if (RC_BAD( rc = flmUTF8ToStorage(
pszUTF8, uiBytesInBuffer, pucDataPtr, &uiLen)))
{
goto Exit;
}
}
Exit:
return( rc);
}
/*
This function loads the executable file corresponding to the first arguement to an appropriate location on the disk.
This function systematically uses the above functions to do this action.
*/
int loadExecutableToDisk(char *name)
{
FILE *fileToBeLoaded;
int freeBlock[SIZE_EXEFILE_BASIC];
int i,j,k,l,file_size=0,num_of_lines=0,num_of_blocks_reqd=0;
for(i=0;i<SIZE_EXEFILE_BASIC;i++)
freeBlock[i]=-1;
char c='\0',*s;
char filename[50];
s = strrchr(name,'\\');
if(s!=NULL)
strcpy(filename,s+1);
else
strcpy(filename,name);
filename[15]='\0';
addext(filename,".xsm");
expandpath(name);
fileToBeLoaded = fopen(name, "r");
if(fileToBeLoaded == NULL){
printf("File %s not found.\n", name);
return -1;
}
if(fileToBeLoaded == NULL){
printf("The file could not be opened");
return -1;
}
while(c!=EOF)
{
c=fgetc(fileToBeLoaded);
if(c=='\n')
num_of_lines++;
}
num_of_blocks_reqd = (num_of_lines / (BLOCK_SIZE/2)) + 1;
if(num_of_blocks_reqd > SIZE_EXEFILE)
{
printf("The size of file exceeds %d blocks",SIZE_EXEFILE);
return -1;
}
fseek(fileToBeLoaded,0,SEEK_SET);
for(i = 0; i < num_of_blocks_reqd + 1; i++)
{
if((freeBlock[i] = FindFreeBlock()) == -1){
printf("Insufficient disk space!\n");
FreeUnusedBlock(freeBlock, SIZE_EXEFILE_BASIC);
return -1;
}
}
i = CheckRepeatedName(filename);
if( i < FAT_SIZE ){
printf("Disk already contains the file with this name. Try again with a different name.\n");
FreeUnusedBlock(freeBlock, SIZE_EXEFILE_BASIC);
return -1;
}
k = FindEmptyFatEntry();
if( k == -1 ){
FreeUnusedBlock(freeBlock, SIZE_EXEFILE_BASIC);
printf("No free FAT entry found.\n");
return -1;
}
for(i = DISK_FREE_LIST ;i < DISK_FREE_LIST + NO_OF_FREE_LIST_BLOCKS; i++) //updating disk free list in disk
writeToDisk(i, i);
emptyBlock(TEMP_BLOCK); //note:need to modify this
for( i = 1 ; i < SIZE_EXEFILE_BASIC ; i++ )
{
storeValue(disk[TEMP_BLOCK].word[i-1],freeBlock[i]);
}
writeToDisk(TEMP_BLOCK,freeBlock[0]);
for(i=0;i<num_of_blocks_reqd;i++)
{
j = writeFileToDisk(fileToBeLoaded, freeBlock[i+1], ASSEMBLY_CODE);
file_size++;
}
AddEntryToMemFat(k, filename, file_size * BLOCK_SIZE, freeBlock[0]);
for(i = FAT; i < FAT + NO_OF_FAT_BLOCKS ; i++){
writeToDisk(i,i);
}
close(fileToBeLoaded);
return 0;
}
void Inter_v7::o7_findFile() {
Common::String file = findFile(getFile(_vm->_game->_script->evalString()));
storeString(file.c_str());
storeValue(file.empty() ? 0 : 1);
}
/*
This function loads a data file to the disk.
*/
int loadDataToDisk(char *name)
{
FILE *fileToBeLoaded;
int freeBlock[MAX_DATAFILE_SIZE_BASIC];
int i,j,k,num_of_chars=0,num_of_blocks_reqd=0,file_size=0,num_of_words=0;
for(i=0;i<MAX_DATAFILE_SIZE_BASIC;i++)
freeBlock[i]=-1;
char c='\0',*s;
char filename[50],buf[16];
s = strrchr(name,'\\');
if(s!=NULL)
strcpy(filename,s+1);
else
strcpy(filename,name);
filename[15]='\0';
addext(filename,".dat");
expandpath(name);
fileToBeLoaded = fopen(name, "r");
if(fileToBeLoaded == NULL)
{
printf("File \'%s\' not found.!\n", name);
return -1;
}
if(fileToBeLoaded == NULL)
{
printf("The file could not be opened!");
return -1;
}
fseek(fileToBeLoaded, 0L, SEEK_END);
num_of_chars = ftell(fileToBeLoaded);
fseek(fileToBeLoaded,0,SEEK_SET);
while(1)
{
fgets(buf,16,fileToBeLoaded);
num_of_words++;
if(feof(fileToBeLoaded))
break;
}
num_of_blocks_reqd = (num_of_words/512) + 1;
//printf("\n Chars = %d, Words = %d, Blocks(chars) = %d, Blocks(words) = %d",num_of_chars,num_of_words,num_of_blocks_reqd,(num_of_words/512));
if(num_of_blocks_reqd > MAX_DATAFILE_SIZE)
{
printf("The size of file exceeds %d blocks",MAX_DATAFILE_SIZE);
return -1;
}
fseek(fileToBeLoaded,0,SEEK_SET);
for(i = 0; i < num_of_blocks_reqd + 1; i++)
{
if((freeBlock[i] = FindFreeBlock()) == -1){
printf("not sufficient space in disk to hold a new file.\n");
FreeUnusedBlock(freeBlock, MAX_DATAFILE_SIZE_BASIC);
return -1;
}
}
i = CheckRepeatedName(filename);
if( i < FAT_SIZE )
{
printf("Disk already contains the file with this name. Try again with a different name.\n");
FreeUnusedBlock(freeBlock, MAX_DATAFILE_SIZE_BASIC);
return -1;
}
k = FindEmptyFatEntry();
if( k == -1 )
{
FreeUnusedBlock(freeBlock, MAX_DATAFILE_SIZE_BASIC);
printf("No free FAT entry found.\n");
return -1;
}
for(i = DISK_FREE_LIST ;i < DISK_FREE_LIST + NO_OF_FREE_LIST_BLOCKS; i++) //updating disk free list in disk
writeToDisk(i, i);
emptyBlock(TEMP_BLOCK); //note:need to modify this
for( i = 1 ; i < MAX_DATAFILE_SIZE_BASIC ; i++ )
{
storeValue(disk[TEMP_BLOCK].word[i-1],freeBlock[i]);
}
writeToDisk(TEMP_BLOCK,freeBlock[0]);
for(i=0;i<num_of_blocks_reqd;i++)
{
j = writeFileToDisk(fileToBeLoaded, freeBlock[i+1], DATA_FILE);
file_size++;
}
AddEntryToMemFat(k, filename, file_size * BLOCK_SIZE, freeBlock[0]);
for(i = FAT; i < FAT + NO_OF_FAT_BLOCKS ; i++){
writeToDisk(i,i); //updating disk fat entry note:check for correctness
}
close(fileToBeLoaded);
return 0;
}
void Inter_v7::storeValue(uint32 value) {
uint16 type;
uint16 index = _vm->_game->_script->readVarIndex(0, &type);
storeValue(index, type, value);
}
QWidget * ExtArgNumber::createEditor(QWidget * parent)
{
QString text = defaultValue();
if ( _argument->pref_valptr && *_argument->pref_valptr)
{
QString storeValue(*_argument->pref_valptr);
if ( storeValue.length() > 0 && storeValue.compare(text) != 0 )
text = storeValue;
}
textBox = (QLineEdit *)ExtArgText::createEditor(parent);
textBox->disconnect(SIGNAL(textChanged(QString)));
if ( _argument->arg_type == EXTCAP_ARG_INTEGER || _argument->arg_type == EXTCAP_ARG_UNSIGNED )
{
QIntValidator * textValidator = new QIntValidator(parent);
if ( _argument->range_start != NULL )
{
int val = 0;
if ( _argument->arg_type == EXTCAP_ARG_INTEGER )
val = extcap_complex_get_int(_argument->range_start);
else if ( _argument->arg_type == EXTCAP_ARG_UNSIGNED )
{
guint tmp = extcap_complex_get_uint(_argument->range_start);
if ( tmp > G_MAXINT )
{
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Defined value for range_start of %s exceeds valid integer range", _argument->call );
val = G_MAXINT;
}
else
val = (gint)tmp;
}
textValidator->setBottom(val);
}
if ( _argument->arg_type == EXTCAP_ARG_UNSIGNED && textValidator->bottom() < 0 )
{
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "%s sets negative bottom range for unsigned value, setting to 0", _argument->call );
textValidator->setBottom(0);
}
if ( _argument->range_end != NULL )
{
int val = 0;
if ( _argument->arg_type == EXTCAP_ARG_INTEGER )
val = extcap_complex_get_int(_argument->range_end);
else if ( _argument->arg_type == EXTCAP_ARG_UNSIGNED )
{
guint tmp = extcap_complex_get_uint(_argument->range_end);
if ( tmp > G_MAXINT )
{
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Defined value for range_end of %s exceeds valid integer range", _argument->call );
val = G_MAXINT;
}
else
val = (gint)tmp;
}
textValidator->setTop(val);
}
textBox->setValidator(textValidator);
}
else if ( _argument->arg_type == EXTCAP_ARG_DOUBLE )
{
QDoubleValidator * textValidator = new QDoubleValidator(parent);
if ( _argument->range_start != NULL )
textValidator->setBottom(extcap_complex_get_double(_argument->range_start));
if ( _argument->range_end != NULL )
textValidator->setTop(extcap_complex_get_double(_argument->range_end));
textBox->setValidator(textValidator);
}
textBox->setText(text.trimmed());
connect(textBox, SIGNAL(textChanged(QString)), SLOT(onStringChanged(QString)));
return textBox;
}
