void BytecodeVisitor::visitStoreNode(StoreNode *node) {
LOG_Visitor("visitStoreNode");
VariableInContextDescriptor variableDescriptor = context->getVariableDescriptor(node->var()->name());
if (node->op() == tINCRSET || node->op() == tDECRSET) {
loadVariable(variableDescriptor, node);
}
node->value()->visit(this);
VarType varType = context->getVariableByID(variableDescriptor)->type();
cast(varType, node, "storing node");
switch (node->op()) {
case tINCRSET:
bc()->addInsn(varType == VT_DOUBLE ? BC_DADD : BC_IADD);
break;
case tDECRSET:
bc()->addInsn(BC_SWAP);
bc()->addInsn(varType == VT_DOUBLE ? BC_DSUB : BC_ISUB);
break;
case tASSIGN:
break;
default:
throw TranslationError("Incorrect storing variable operation", node->position());
}
storeVariable(variableDescriptor, node);
}
Word Story::read(OperandType operandType)
{
switch(operandType)
{
case OperandType::Large:
return readNextWord();
case OperandType::Small:
return readNextByte();
case OperandType::Variable:
{
auto variableID = readNextByte();
return loadVariable(variableID);
}
case OperandType::Omitted:
{
throw Exception("Omitted unexpected");
}
default:
{
throw Exception("unexpected operand type");
}
}
}
void BytecodeVisitor::visitForNode(ForNode *node) {
LOG_Visitor("visitForNode");
VariableInContextDescriptor variableDescriptor = context->getVariableDescriptor(node->var()->name());
BinaryOpNode *innerExpression = (BinaryOpNode *) node->inExpr();
if (innerExpression->kind() != tRANGE) {
throw TranslationError(string("Incorrect binary operation in for-expression. Exptected: RANGE, got: ")
+ tokenStr(innerExpression->kind()), node->position());
}
if (node->var()->type() != VT_INT) {
throw TranslationError(string("Incorrect type of for-variable. Exptected: INT, got: ")
+ typeToName(node->var()->type()), node->position());
}
innerExpression->left()->visit(this);
bc()->addInsn(BC_ILOADM1);
bc()->addInsn(BC_IADD);
storeVariable(variableDescriptor, innerExpression);
Label begin(bc());
Label end(bc());
{
bc()->bind(begin);
loadVariable(variableDescriptor, innerExpression);
bc()->addInsn(BC_ILOAD1);
bc()->addInsn(BC_IADD);
storeVariable(variableDescriptor, innerExpression);
//condition
innerExpression->right()->visit(this);
loadVariable(variableDescriptor, innerExpression);
bc()->addInsn(BC_SWAP);
// goto end if greater
bc()->addBranch(BC_IFICMPG, end);
node->body()->visit(this);
bc()->addBranch(BC_JA, begin);
}
bc()->bind(end);
}
Word Story::loadVariableInPlace(Byte variableID)
{
if(variableID == 0)
{
// We return the peek of the stack
return peek();
}
else
{
return loadVariable(variableID);
}
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
BypassMonitor w;
/** VARAPI */
loadVariable();
if4Init();
w.show();
return a.exec();
}
LoadedFunction *loadFunction(Common::SeekableReadStream *stream) {
int a;
// Reserve memory...
LoadedFunction *buildFunc = new LoadedFunction;
if (!checkNew(buildFunc))
return NULL;
// See what it was called by and load if we need to...
buildFunc->originalNumber = stream->readUint16BE();
buildFunc->calledBy = NULL;
if (stream->readByte()) {
buildFunc->calledBy = loadFunction(stream);
if (!buildFunc->calledBy)
return NULL;
}
buildFunc->timeLeft = stream->readUint32LE();
buildFunc->runThisLine = stream->readUint16BE();
buildFunc->freezerLevel = 0;
buildFunc->cancelMe = stream->readByte();
buildFunc->returnSomething = stream->readByte();
buildFunc->isSpeech = stream->readByte();
loadVariable(&(buildFunc->reg), stream);
loadFunctionCode(buildFunc);
buildFunc->stack = loadStack(stream, NULL);
for (a = 0; a < buildFunc->numLocals; a++) {
loadVariable(&(buildFunc->localVars[a]), stream);
}
return buildFunc;
}
bool DataLoader::loadAllVariableLists(FILE *fp) {
// lendo as variáveis globais
int count_n_variables;
fread(&count_n_variables, 1, sizeof(int), fp);
for(int i = 0; i < count_n_variables; i++) {
gameData->variableList->push_back(loadVariable(fp));
}
// lendos as variáveis dos objetos
for(std::vector<GameObject*>::iterator it1 = gameData->objectList->begin(); it1 != gameData->objectList->end(); ++it1) {
GameObject *gameObject = *it1;
fread(&count_n_variables, 1, sizeof(int), fp);
for(int i = 0; i < count_n_variables; i++) {
gameObject->variableList->push_back(loadVariable(fp));
}
}
return true;
}
VariableStack *loadStack(Common::SeekableReadStream *stream, VariableStack **last) {
int elements = stream->readUint16BE();
int a;
VariableStack *first = NULL;
VariableStack **changeMe = &first;
for (a = 0; a < elements; a++) {
VariableStack *nS = new VariableStack;
if (!checkNew(nS))
return NULL;
loadVariable(&(nS->thisVar), stream);
if (last && a == elements - 1) {
*last = nS;
}
nS->next = NULL;
(*changeMe) = nS;
changeMe = &(nS->next);
}
return first;
}
VariablesListViewItem::VariablesListViewItem(KListViewItem *parent, Variable* variable)
: KListViewItem(parent), m_variable(variable),m_isRenameable(false)
{
//setMultiLinesEnabled(true);
loadVariable();
}
void AffectEngine::run() {
// if it's procedure and variable combination
ASTParameter *astParam1 = parameterList.at(0);
ASTParameter *astParam2 = parameterList.at(1);
FastSearchInteger second;
FastSearchInteger first;
// there is no need to check if both is underscore
if (astParam1->getParameterType() == VT_UNDERSCORE && astParam2->getParameterType() == VT_UNDERSCORE) {
/*if (pkbManager->getFollows()->IsThereFollow)
failed = false;
else
failed true;*/
failed = !pkbManager->getAffects()->exists();
return;
}
if (astParam1->getParameterType() == VT_UNDERSCORE)
CommonUtility::convertToMap(myQM->getAllStatementList(), first);
else
loadVariable(0, first);
if (astParam2->getParameterType() == VT_UNDERSCORE)
CommonUtility::convertToMap(myQM->getAllStatementList(), second);
else
loadVariable(1, second);
FastSearchString finalListOne;
FastSearchString finalListTwo;
FastSearchInteger::iterator iter;
vector<int>::const_iterator iterParentList;
FastSearchInteger::iterator iterSecond;
bool exist;
bool keepRelationship = astParam1->updateAble() && astParam2->updateAble() ;
vector<pair<string, string>> resultList;
if (first.size() < second.size()) {
for (iter = first.begin(); iter != first.end(); iter++) { // for every statement find the modified value
vector<int> &childList = pkbManager->getAffects()->getAffects(iter->first);
exist = false;
for (iterParentList = childList.begin(); iterParentList != childList.end(); iterParentList++) { // for each variable returned check against the variable list
iterSecond = second.find(*iterParentList);
if (iterSecond != second.end()) {
exist = true;
if (keepRelationship)
resultList.push_back(pair<string, string>(CommonUtility::NumberToString(iter->first), CommonUtility::NumberToString(iterSecond->first)));
else if (astParam2->updateAble())
finalListTwo[CommonUtility::NumberToString(iterSecond->first)] = true;
else if (!astParam1->updateAble()) {
return; // both are not updatable.
}
}
}
if (exist && !keepRelationship && astParam1->updateAble())
finalListOne[CommonUtility::NumberToString(iter->first)] = true;
}
} else {
for (iterSecond = second.begin(); iterSecond != second.end(); iterSecond++) { // for every statement find the modified value
vector<int> &childList = pkbManager->getAffects()->getAffected(iterSecond->first);
exist = false;
for (iterParentList = childList.begin(); iterParentList != childList.end(); iterParentList++) { // for each variable returned check against the variable list
iter = first.find(*iterParentList);
if (iter != first.end()) {
exist = true;
if (keepRelationship)
resultList.push_back(pair<string, string>(CommonUtility::NumberToString(iter->first), CommonUtility::NumberToString(iterSecond->first)));
else if (astParam1->updateAble())
finalListOne[CommonUtility::NumberToString(iter->first)] = true;
else if (!astParam2->updateAble()) {
return; // both are not updatable.
}
}
}
if (exist && !keepRelationship && astParam2->updateAble())
finalListTwo[CommonUtility::NumberToString(iterSecond->first)] = true;
}
}
updateVariable(resultList, finalListOne, finalListTwo, keepRelationship);
failed = (finalListOne.size() == 0 && finalListTwo.size() == 0 && resultList.size() == 0);
}
void BytecodeVisitor::visitLoadNode(LoadNode *node) {
LOG_Visitor("visitLoadNode");
VariableInContextDescriptor variableDescriptor = context->getVariableDescriptor(node->var()->name());
topOfStackType = loadVariable(variableDescriptor, node);
}
void UsesEngine::handleProcedureVariable() {
// special case 1:
// Modifies(procedure p , _);
// declare necessary variable
bool keepRelationship = QueryClass::keepRelationship();
vector<pair<string, string>> relationship;
ASTParameter *astParam1 = parameterList.at(0);
ASTParameter *astParam2 = parameterList.at(1);
FastSearchString procedureList;
FastSearchString second;
if (astParam2->getParameterType() == VT_UNDERSCORE)
CommonUtility::convertToMap(myQM->getAllVariable(), second);
else
loadVariable(1, second);
if (astParam1->getParameterType() == VT_UNDERSCORE)
procedureList = myQM->getAllProcedureList();
else {
loadVariable(0, procedureList);
}
FastSearchString finalProcedureList;
FastSearchString finalVariableList;
FastSearchString::const_iterator iter;
bool exist = false;
if (second.size() < procedureList.size()) {
vector<string>::const_iterator iterProcedureResult;
for (iter = second.begin(); iter != second.end(); iter++) {
vector<string> &procedureListResult = pkbManager->getUses()->getUsesProc(iter->first);
exist = false;
for (iterProcedureResult = procedureListResult.begin(); iterProcedureResult != procedureListResult.end(); iterProcedureResult++) {
if (procedureList.find(*iterProcedureResult) != procedureList.end()) { // found
exist = true;
if (keepRelationship)
relationship.push_back(pair<string, string>(*iterProcedureResult, iter->first));
else if (astParam1->updateAble()) {
finalProcedureList[*iterProcedureResult] = true;
} else { // if the first one is not updateable, just need to care for second one
if (!astParam2->updateAble())
return; // we have got what we come for.
break;
}
}
}
if (exist && !keepRelationship && astParam2->updateAble())
finalVariableList[iter->first] = true;
}
} else {
vector<string>::iterator iterVarResult;
for (iter = procedureList.begin(); iter != procedureList.end(); iter++) {
vector<string> &varListResult = pkbManager->getUses()->getUsedVar(iter->first);
exist = false;
for (iterVarResult = varListResult.begin(); iterVarResult != varListResult.end(); iterVarResult++) {
if (second.find(*iterVarResult) != second.end()) { // found
exist = true;
if (keepRelationship)
relationship.push_back(pair<string, string>(iter->first, *iterVarResult));
else if (astParam2->updateAble()) {
finalVariableList[*iterVarResult] = true;
} else { // if the first one is not updateable, just need to care for second one
if (!astParam1->updateAble())
return; // we have got what we come for.
// if param2 is not updatable, super unlikely after the optimization
break;
}
}
}
if (exist && !keepRelationship && astParam1->updateAble())
finalProcedureList[iter->first] = true;
}
}
updateVariable(relationship, finalProcedureList, finalVariableList, keepRelationship);
// both constant already handled above
failed = (finalProcedureList.size() == 0 && finalVariableList.size() == 0&& relationship.size() == 0);
}
bool loadGame(const Common::String &fname) {
Common::InSaveFile *fp = g_system->getSavefileManager()->openForLoading(fname);
FILETIME savedGameTime;
while (allRunningFunctions)
finishFunction(allRunningFunctions);
if (fp == NULL)
return false;
bool headerBad = false;
if (fp->readByte() != 'S')
headerBad = true;
if (fp->readByte() != 'L')
headerBad = true;
if (fp->readByte() != 'U')
headerBad = true;
if (fp->readByte() != 'D')
headerBad = true;
if (fp->readByte() != 'S')
headerBad = true;
if (fp->readByte() != 'A')
headerBad = true;
if (headerBad) {
fatal(ERROR_GAME_LOAD_NO, fname);
return NULL;
}
char c;
c = fp->readByte();
while ((c = fp->readByte()))
;
int majVersion = fp->readByte();
int minVersion = fp->readByte();
ssgVersion = VERSION(majVersion, minVersion);
if (ssgVersion >= VERSION(1, 4)) {
if (!g_sludge->_gfxMan->skipThumbnail(fp))
return fatal(ERROR_GAME_LOAD_CORRUPT, fname);
}
uint32 bytes_read = fp->read(&savedGameTime, sizeof(FILETIME));
if (bytes_read != sizeof(FILETIME) && fp->err()) {
warning("Reading error in loadGame.");
}
if (savedGameTime.dwLowDateTime != fileTime.dwLowDateTime || savedGameTime.dwHighDateTime != fileTime.dwHighDateTime) {
return fatal(ERROR_GAME_LOAD_WRONG, fname);
}
// DON'T ADD ANYTHING NEW BEFORE THIS POINT!
if (ssgVersion >= VERSION(1, 4)) {
allowAnyFilename = fp->readByte();
}
captureAllKeys = fp->readByte();
fp->readByte(); // updateDisplay (part of movie playing)
g_sludge->_txtMan->loadFont(ssgVersion, fp);
killAllPeople();
killAllRegions();
int camerX = fp->readUint16BE();
int camerY = fp->readUint16BE();
float camerZ;
if (ssgVersion >= VERSION(2, 0)) {
camerZ = fp->readFloatLE();
} else {
camerZ = 1.0;
}
brightnessLevel = fp->readByte();
g_sludge->_gfxMan->loadHSI(fp, 0, 0, true);
g_sludge->_evtMan->loadHandlers(fp);
loadRegions(fp);
if (!g_sludge->_cursorMan->loadCursor(fp)) {
return false;
}
LoadedFunction *rFunc;
LoadedFunction **buildList = &allRunningFunctions;
int countFunctions = fp->readUint16BE();
while (countFunctions--) {
rFunc = loadFunction(fp);
rFunc->next = NULL;
(*buildList) = rFunc;
buildList = &(rFunc->next);
}
for (int a = 0; a < numGlobals; a++) {
unlinkVar(globalVars[a]);
loadVariable(&globalVars[a], fp);
}
loadPeople(fp);
if (fp->readByte()) {
if (!setFloor(fp->readUint16BE()))
return false;
} else
setFloorNull();
if (!g_sludge->_gfxMan->loadZBuffer(fp))
return false;
if (!g_sludge->_gfxMan->loadLightMap(ssgVersion, fp)) {
return false;
}
fadeMode = fp->readByte();
g_sludge->_speechMan->load(fp);
loadStatusBars(fp);
g_sludge->_soundMan->loadSounds(fp);
saveEncoding = fp->readUint16BE();
if (ssgVersion >= VERSION(1, 6)) {
if (ssgVersion < VERSION(2, 0)) {
// aaLoad
fp->readByte();
fp->readFloatLE();
fp->readFloatLE();
}
blur_loadSettings(fp);
}
if (ssgVersion >= VERSION(1, 3)) {
g_sludge->_gfxMan->loadColors(fp);
// Read parallax layers
while (fp->readByte()) {
int im = fp->readUint16BE();
int fx = fp->readUint16BE();
int fy = fp->readUint16BE();
if (!g_sludge->_gfxMan->loadParallax(im, fx, fy))
return false;
}
g_sludge->_languageMan->loadLanguageSetting(fp);
}
g_sludge->_gfxMan->nosnapshot();
if (ssgVersion >= VERSION(1, 4)) {
if (fp->readByte()) {
if (!g_sludge->_gfxMan->restoreSnapshot(fp))
return false;
}
}
delete fp;
g_sludge->_gfxMan->setCamera(camerX, camerY, camerZ);
clearStackLib();
return true;
}
void SimpleInterpreter::run(ostream &out) {
stack.resize(50);
bytecodes.clear();
indices.clear();
vars.clear();
bytecodes.push_back(bytecode);
indices.push_back(0);
contextID.push_back(0);
callsCounter.push_back(0);
SP = 0;
while (!bytecodes.empty()) {
indexType ¤tIndex = indices.back();
Bytecode &bytecode = *bytecodes.back();
Instruction instruction = bytecode.getInsn(currentIndex);
size_t instructionLength = bytecodeLength(instruction);
#ifdef LOG_INTERPRETER
const char* bcName = bytecodeName(instruction, 0);
cout << "index: " << currentIndex << ", instruction: " << bcName << endl;
#endif
switch (instruction) {
case BC_DLOAD: pushVariable(bytecode.getDouble(currentIndex + 1));
break;
case BC_ILOAD: pushVariable(bytecode.getInt64(currentIndex + 1));
break;
case BC_SLOAD: pushVariable(constantById(bytecode.getUInt16(currentIndex + 1)).c_str());
break;
case BC_DLOAD0: pushVariable(0.0);
break;
case BC_ILOAD0: pushVariable((signedIntType) 0);
break;
case BC_SLOAD0: pushVariable("");
break;
case BC_DLOAD1: pushVariable(1.0);
break;
case BC_ILOAD1: pushVariable((signedIntType) 1);
break;
case BC_DLOADM1: pushVariable(-1.0);
break;
case BC_ILOADM1: pushVariable((signedIntType) - 1);
break;
case BC_DADD: binary_operation(VT_DOUBLE, add<double>);
break;
case BC_IADD: binary_operation(VT_INT, add < signedIntType > );
break;
case BC_DSUB: binary_operation(VT_DOUBLE, sub<double>);
break;
case BC_ISUB: binary_operation(VT_INT, sub < signedIntType > );
break;
case BC_DMUL: binary_operation(VT_DOUBLE, mul<double>);
break;
case BC_IMUL: binary_operation(VT_INT, mul < signedIntType > );
break;
case BC_DDIV: binary_operation(VT_DOUBLE, _div<double>);
break;
case BC_IDIV: binary_operation(VT_INT, _div < signedIntType > );
break;
case BC_IMOD: binary_operation(VT_INT, mod < signedIntType > );
break;
case BC_DNEG: unary_operation(VT_DOUBLE, neg<double>);
break;
case BC_INEG: unary_operation(VT_INT, neg < signedIntType > );
break;
case BC_IAOR: binary_operation(VT_INT, _or < signedIntType > );
break;
case BC_IAAND: binary_operation(VT_INT, _and < signedIntType > );
break;
case BC_IAXOR: binary_operation(VT_INT, _xor < signedIntType > );
break;
case BC_IPRINT: out << popVariable().getIntValue();
out.flush();
break;
case BC_DPRINT: out << popVariable().getDoubleValue();
out.flush();
break;
case BC_SPRINT: out << popVariable().getStringValue();
out.flush();
break;
case BC_SWAP: {
auto v1 = popVariable();
auto v2 = popVariable();
pushVariable(v1);
pushVariable(v2);
break;
}
case BC_STOREDVAR0:
case BC_STOREIVAR0:
case BC_STORESVAR0: storeVariable(0);
break;
case BC_STOREDVAR1:
case BC_STOREIVAR1:
case BC_STORESVAR1: storeVariable(1);
break;
case BC_STOREDVAR2:
case BC_STOREIVAR2:
case BC_STORESVAR2: storeVariable(2);
break;
case BC_STOREDVAR3:
case BC_STOREIVAR3:
case BC_STORESVAR3: storeVariable(3);
break;
case BC_LOADDVAR:
case BC_LOADIVAR:
case BC_LOADSVAR: pushVariable(loadVariable(bytecode.getUInt16(currentIndex + 1)));
break;
case BC_LOADDVAR0:
case BC_LOADIVAR0:
case BC_LOADSVAR0: pushVariable(loadVariable(0));
break;
case BC_LOADDVAR1:
case BC_LOADIVAR1:
case BC_LOADSVAR1: pushVariable(loadVariable(1));
break;
case BC_LOADIVAR2:
case BC_LOADSVAR2:
case BC_LOADDVAR2: pushVariable(loadVariable(2));
break;
case BC_LOADDVAR3:
case BC_LOADIVAR3:
case BC_LOADSVAR3: pushVariable(loadVariable(3));
break;
case BC_STOREDVAR:
case BC_STOREIVAR:
case BC_STORESVAR: storeVariable(bytecode.getUInt16(currentIndex + 1));
break;
case BC_LOADCTXDVAR:
case BC_LOADCTXIVAR:
case BC_LOADCTXSVAR: pushVariable(loadVariable(bytecode.getUInt16(currentIndex + 1), bytecode.getUInt16(currentIndex + 3)));
break;
case BC_STORECTXDVAR:
case BC_STORECTXIVAR:
case BC_STORECTXSVAR: storeVariable(bytecode.getUInt16(currentIndex + 1), bytecode.getUInt16(currentIndex + 3));
break;
case BC_DCMP: binary_operation<double, signedIntType>(VT_DOUBLE, _cmp<double>);
break;
case BC_ICMP: binary_operation(VT_INT, _cmp < signedIntType > );
break;
case BC_JA: {
currentIndex += bytecode.getInt16(currentIndex + 1) + 1;
continue;
}
case BC_IFICMPNE: {
if (!check_condition(_neq<signedIntType>))
break;
currentIndex += bytecode.getInt16(currentIndex + 1) + 1;
continue;
}
case BC_IFICMPE: {
if (!check_condition(_eq<signedIntType>))
break;
currentIndex += bytecode.getInt16(currentIndex + 1) + 1;
continue;
}
case BC_IFICMPG: {
if (!check_condition(_g<signedIntType>))
break;
currentIndex += bytecode.getInt16(currentIndex + 1) + 1;
continue;
}
case BC_IFICMPGE: {
if (!check_condition(_ge<signedIntType>))
break;
currentIndex += bytecode.getInt16(currentIndex + 1) + 1;
continue;
}
case BC_IFICMPL: {
if (!check_condition(_l<signedIntType>))
break;
currentIndex += bytecode.getInt16(currentIndex + 1) + 1;
continue;
}
case BC_IFICMPLE: {
if (!check_condition(_le<signedIntType>))
break;
currentIndex += bytecode.getInt16(currentIndex + 1) + 1;
continue;
}
case BC_STOP: {
indices.clear();
bytecodes.clear();
continue;
}
case BC_CALLNATIVE: {
callNative(bytecode.getUInt16(currentIndex + 1));
break;
}
case BC_CALL: {
TranslatedFunction *f = functionById(bytecode.getUInt16(currentIndex + 1));
bytecodes.push_back(static_cast<BytecodeFunction *>(f)->bytecode());
indices.push_back(0);
contextID.push_back(f->id());
detectCallWithFunctionID(contextID.back());
continue;
}
case BC_RETURN: {
indices.pop_back();
bytecodes.pop_back();
if (!indices.empty()) {
indices.back() += bytecodeLength(BC_CALL);
}
if (callsCounter[contextID.back()] > 0) {
callsCounter[contextID.back()]--;
}
contextID.pop_back();
continue;
}
case BC_I2D: pushVariable((double) popVariable().getIntValue());
break;
case BC_D2I: pushVariable((signedIntType) popVariable().getDoubleValue());
break;
case BC_S2I: pushVariable((signedIntType) popVariable().getStringValue());
break;
case BC_BREAK: break;
case BC_INVALID: throw InterpretationError("BC_Invalid instruction");
default: throw InterpretationError(string("Unknown interpreting instruction: ") + bytecodeName(instruction, 0));
}
currentIndex += instructionLength;
}
}
TypedVariable const& loadVariable(uint16_t id) {
return loadVariable(contextID.back(), id);
}