thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Encapsulating stack adjustments

Browse source 
svn-id: r41589
This commit is contained in:
Sven Hesse 2009-06-16 20:14:56 +00:00
parent 4aec580f91
commit 1996a8011c
2 changed files with 43 additions and 104 deletions
Download patch file Download diff file Expand all files Collapse all files

145
engines/gob/parse.cpp
View file

@ -769,6 +769,12 @@ void Parse::loadValue(byte operation, uint32 varBase, byte *operPtr, int32 *valP
} }
} }
void Parse::stackPop(byte *&operPtr, int32 *&valPtr, int16 &stkPos, int count) {
operPtr -= count;
valPtr -= count;
stkPos -= count;
}
void Parse::simpleArithmetic1(byte *&operPtr, int32 *&valPtr, int16 &stkPos) { void Parse::simpleArithmetic1(byte *&operPtr, int32 *&valPtr, int16 &stkPos) {
switch (operPtr[-1]) { switch (operPtr[-1]) {
case OP_ADD: case OP_ADD:
@ -778,38 +784,28 @@ void Parse::simpleArithmetic1(byte *&operPtr, int32 *&valPtr, int16 &stkPos) {
valPtr[-2] = encodePtr((byte *) _vm->_parse->_resultStr, kResStr); valPtr[-2] = encodePtr((byte *) _vm->_parse->_resultStr, kResStr);
} }
strcat(_vm->_parse->_resultStr, (char *) decodePtr(valPtr[0])); strcat(_vm->_parse->_resultStr, (char *) decodePtr(valPtr[0]));
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
} }
break; break;
case OP_MUL: case OP_MUL:
valPtr[-2] *= valPtr[0]; valPtr[-2] *= valPtr[0];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_DIV: case OP_DIV:
valPtr[-2] /= valPtr[0]; valPtr[-2] /= valPtr[0];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_MOD: case OP_MOD:
valPtr[-2] %= valPtr[0]; valPtr[-2] %= valPtr[0];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_BITAND: case OP_BITAND:
valPtr[-2] &= valPtr[0]; valPtr[-2] &= valPtr[0];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
} }
} }
@ -819,14 +815,10 @@ void Parse::simpleArithmetic2(byte *&operPtr, int32 *&valPtr, int16 &stkPos) {
if (operPtr[-2] == OP_NEG) { if (operPtr[-2] == OP_NEG) {
operPtr[-2] = OP_LOAD_IMM_INT16; operPtr[-2] = OP_LOAD_IMM_INT16;
valPtr[-2] = -valPtr[-1]; valPtr[-2] = -valPtr[-1];
stkPos--; stackPop(operPtr, valPtr, stkPos);
operPtr--;
valPtr--;
} else if (operPtr[-2] == OP_NOT) { } else if (operPtr[-2] == OP_NOT) {
operPtr[-2] = (operPtr[-1] == GOB_FALSE) ? GOB_TRUE : GOB_FALSE; operPtr[-2] = (operPtr[-1] == GOB_FALSE) ? GOB_TRUE : GOB_FALSE;
stkPos--; stackPop(operPtr, valPtr, stkPos);
operPtr--;
valPtr--;
} }
} }
@ -834,30 +826,22 @@ void Parse::simpleArithmetic2(byte *&operPtr, int32 *&valPtr, int16 &stkPos) {
switch (operPtr[-2]) { switch (operPtr[-2]) {
case OP_MUL: case OP_MUL:
valPtr[-3] *= valPtr[-1]; valPtr[-3] *= valPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_DIV: case OP_DIV:
valPtr[-3] /= valPtr[-1]; valPtr[-3] /= valPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_MOD: case OP_MOD:
valPtr[-3] %= valPtr[-1]; valPtr[-3] %= valPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_BITAND: case OP_BITAND:
valPtr[-3] &= valPtr[-1]; valPtr[-3] &= valPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
} }
} }
@ -880,51 +864,37 @@ bool Parse::complexArithmetic(byte *&operPtr, int32 *&valPtr, int16 &stkPos,
} }
strcat(_vm->_parse->_resultStr, (char *) decodePtr(valPtr[-1])); strcat(_vm->_parse->_resultStr, (char *) decodePtr(valPtr[-1]));
} }
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_SUB: case OP_SUB:
values[brackStart] -= valPtr[-1]; values[brackStart] -= valPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_BITOR: case OP_BITOR:
values[brackStart] |= valPtr[-1]; values[brackStart] |= valPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_MUL: case OP_MUL:
valPtr[-3] *= valPtr[-1]; valPtr[-3] *= valPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_DIV: case OP_DIV:
valPtr[-3] /= valPtr[-1]; valPtr[-3] /= valPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_MOD: case OP_MOD:
valPtr[-3] %= valPtr[-1]; valPtr[-3] %= valPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_BITAND: case OP_BITAND:
valPtr[-3] &= valPtr[-1]; valPtr[-3] &= valPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_OR: case OP_OR:
@ -932,9 +902,7 @@ bool Parse::complexArithmetic(byte *&operPtr, int32 *&valPtr, int16 &stkPos,
// (x OR true) == true // (x OR true) == true
if (operPtr[-3] == GOB_FALSE) if (operPtr[-3] == GOB_FALSE)
operPtr[-3] = operPtr[-1]; operPtr[-3] = operPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_AND: case OP_AND:
@ -942,51 +910,37 @@ bool Parse::complexArithmetic(byte *&operPtr, int32 *&valPtr, int16 &stkPos,
// (x AND true) == x // (x AND true) == x
if (operPtr[-3] == GOB_TRUE) if (operPtr[-3] == GOB_TRUE)
operPtr[-3] = operPtr[-1]; operPtr[-3] = operPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_LESS: case OP_LESS:
operPtr[-3] = (cmpHelper(operPtr, valPtr) < 0) ? GOB_TRUE : GOB_FALSE; operPtr[-3] = (cmpHelper(operPtr, valPtr) < 0) ? GOB_TRUE : GOB_FALSE;
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_LEQ: case OP_LEQ:
operPtr[-3] = (cmpHelper(operPtr, valPtr) <= 0) ? GOB_TRUE : GOB_FALSE; operPtr[-3] = (cmpHelper(operPtr, valPtr) <= 0) ? GOB_TRUE : GOB_FALSE;
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_GREATER: case OP_GREATER:
operPtr[-3] = (cmpHelper(operPtr, valPtr) > 0) ? GOB_TRUE : GOB_FALSE; operPtr[-3] = (cmpHelper(operPtr, valPtr) > 0) ? GOB_TRUE : GOB_FALSE;
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_GEQ: case OP_GEQ:
operPtr[-3] = (cmpHelper(operPtr, valPtr) >= 0) ? GOB_TRUE : GOB_FALSE; operPtr[-3] = (cmpHelper(operPtr, valPtr) >= 0) ? GOB_TRUE : GOB_FALSE;
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_EQ: case OP_EQ:
operPtr[-3] = (cmpHelper(operPtr, valPtr) == 0) ? GOB_TRUE : GOB_FALSE; operPtr[-3] = (cmpHelper(operPtr, valPtr) == 0) ? GOB_TRUE : GOB_FALSE;
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
case OP_NEQ: case OP_NEQ:
operPtr[-3] = (cmpHelper(operPtr, valPtr) != 0) ? GOB_TRUE : GOB_FALSE; operPtr[-3] = (cmpHelper(operPtr, valPtr) != 0) ? GOB_TRUE : GOB_FALSE;
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
break; break;
default: default:
@ -1058,9 +1012,7 @@ int16 Parse::parseExpr(byte stopToken, byte *type) {
loadValue(operation, varBase, operPtr, valPtr); loadValue(operation, varBase, operPtr, valPtr);
if ((stkPos > 0) && ((operPtr[-1] == OP_NEG) || (operPtr[-1] == OP_NOT))) { if ((stkPos > 0) && ((operPtr[-1] == OP_NEG) || (operPtr[-1] == OP_NOT))) {
stkPos--; stackPop(operPtr, valPtr, stkPos);
operPtr--;
valPtr--;
if (*operPtr == OP_NEG) { if (*operPtr == OP_NEG) {
*operPtr = OP_LOAD_IMM_INT16; *operPtr = OP_LOAD_IMM_INT16;
@ -1087,9 +1039,7 @@ int16 Parse::parseExpr(byte stopToken, byte *type) {
if ((operPtr[-2] == OP_LOAD_IMM_INT16) || (operPtr[-2] == OP_LOAD_IMM_STR)) if ((operPtr[-2] == OP_LOAD_IMM_INT16) || (operPtr[-2] == OP_LOAD_IMM_STR))
valPtr[-2] = valPtr[-1]; valPtr[-2] = valPtr[-1];
stkPos--; stackPop(operPtr, valPtr, stkPos);
operPtr--;
valPtr--;
simpleArithmetic2(operPtr, valPtr, stkPos); simpleArithmetic2(operPtr, valPtr, stkPos);
@ -1123,9 +1073,7 @@ int16 Parse::parseExpr(byte stopToken, byte *type) {
if ((stkPos > 1) && (operPtr[-2] == OP_BEGIN_EXPR)) { if ((stkPos > 1) && (operPtr[-2] == OP_BEGIN_EXPR)) {
skipExpr(OP_END_EXPR); skipExpr(OP_END_EXPR);
operPtr[-2] = operPtr[-1]; operPtr[-2] = operPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
} else { } else {
skipExpr(stopToken); skipExpr(stopToken);
} }
@ -1136,17 +1084,12 @@ int16 Parse::parseExpr(byte stopToken, byte *type) {
else else
operPtr[-1] = GOB_FALSE; operPtr[-1] = GOB_FALSE;
stkPos--; stackPop(operPtr, valPtr, stkPos);
operPtr--;
valPtr--;
} }
} else } else
operPtr[0] = operation; operPtr[0] = operation;
} else { } else
stkPos--; stackPop(operPtr, valPtr, stkPos);
operPtr--;
valPtr--;
}
if (operation != stopToken) if (operation != stopToken)
continue; continue;
@ -1171,20 +1114,14 @@ int16 Parse::parseExpr(byte stopToken, byte *type) {
} }
strcat(_vm->_parse->_resultStr, (char *) decodePtr(valPtr[-1])); strcat(_vm->_parse->_resultStr, (char *) decodePtr(valPtr[-1]));
} }
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
} else if (operPtr[-2] == OP_SUB) { } else if (operPtr[-2] == OP_SUB) {
valPtr[-3] -= valPtr[-1]; valPtr[-3] -= valPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
} else if (operPtr[-2] == OP_BITOR) { } else if (operPtr[-2] == OP_BITOR) {
valPtr[-3] |= valPtr[-1]; valPtr[-3] |= valPtr[-1];
stkPos -= 2; stackPop(operPtr, valPtr, stkPos, 2);
operPtr -= 2;
valPtr -= 2;
} }
} }
} }

2
engines/gob/parse.h
View file

@ -139,6 +139,8 @@ private:
uint16 *size = 0, uint16 *type = 0); uint16 *size = 0, uint16 *type = 0);
int cmpHelper(byte *operPtr, int32 *valPtr); int cmpHelper(byte *operPtr, int32 *valPtr);
void stackPop(byte *&operPtr, int32 *&valPtr, int16 &stkPos, int count = 1);
void loadValue(byte operation, uint32 varBase, byte *operPtr, int32 *valPtr); void loadValue(byte operation, uint32 varBase, byte *operPtr, int32 *valPtr);
void simpleArithmetic1(byte *&operPtr, int32 *&valPtr, int16 &stkPos); void simpleArithmetic1(byte *&operPtr, int32 *&valPtr, int16 &stkPos);
void simpleArithmetic2(byte *&operPtr, int32 *&valPtr, int16 &stkPos); void simpleArithmetic2(byte *&operPtr, int32 *&valPtr, int16 &stkPos);