From 1758c5b211a39c29a193546348e7cc6e7bc2e8c9 Mon Sep 17 00:00:00 2001 From: Eugene Sandulenko Date: Tue, 5 Apr 2005 15:07:40 +0000 Subject: Initial checking of Gob engine svn-id: r17388 --- gob/parse.cpp | 1210 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1210 insertions(+) create mode 100644 gob/parse.cpp (limited to 'gob/parse.cpp') diff --git a/gob/parse.cpp b/gob/parse.cpp new file mode 100644 index 0000000000..aef83d367d --- /dev/null +++ b/gob/parse.cpp @@ -0,0 +1,1210 @@ +/* +** Gobliiins 1 +** Original game by CoktelVision +** +** Reverse engineered by Ivan Dubrov +** +*/ +#include "gob/gob.h" +#include "gob/global.h" +#include "gob/parse.h" +#include "gob/util.h" +#include "gob/debug.h" +#include "gob/inter.h" + +namespace Gob { + +int16 parse_parseExpr(char arg_0, byte *arg_2) { + int32 values[20]; + byte operStack[20]; + int32 prevPrevVal; + int32 prevVal; + int32 curVal; + int32 *valPtr; + char *operPtr; + byte *arrDescPtr; + char var_C; + byte operation; + int16 dimCount; + int16 temp; + int16 temp2; + uint16 offset; + int16 dim; + char var_1A; + int16 stkPos; + int16 brackStart; + + stkPos = -1; + operPtr = (char *)(operStack - 1); + valPtr = values - 1; + + while (1) { + stkPos++; + operPtr++; + valPtr++; + operation = *inter_execPtr++; + if (operation >= 19 && operation <= 29) { + switch (operation) { + case 19: + *operPtr = 20; + *valPtr = READ_LE_UINT32(inter_execPtr); + inter_execPtr += 4; + break; + + case 20: + *operPtr = 20; + *valPtr = inter_load16(); + break; + + case 22: + *operPtr = 22; + *valPtr = (int32)inter_execPtr; + inter_execPtr += strlen(inter_execPtr) + 1; + break; + + case 23: + *operPtr = 20; + *valPtr = READ_LE_UINT32(inter_variables + inter_load16() * 4); + break; + + case 25: + *operPtr = 22; + temp = inter_load16() * 4; + *valPtr = (int32)(inter_variables + temp); + if (*inter_execPtr == 13) { + inter_execPtr++; + temp += parse_parseValExpr(); + *operPtr = 20; + *valPtr = *(inter_variables + temp); + } + break; + + case 26: + case 28: + *operPtr = operation - 6; + temp = inter_load16(); + dimCount = *inter_execPtr++; + arrDescPtr = (byte *)inter_execPtr; + inter_execPtr += dimCount; + offset = 0; + dim = 0; + for (dim = 0; dim < dimCount; dim++) { + temp2 = parse_parseValExpr(); + offset = offset * arrDescPtr[dim] + temp2; + } + + if (operation == 26) { + *valPtr = READ_LE_UINT32(inter_variables + temp * 4 + offset * 4); + break; + } + *valPtr = (int32)(inter_variables + temp * 4 + offset * inter_animDataSize * 4); + if (*inter_execPtr == 13) { + inter_execPtr++; + temp2 = parse_parseValExpr(); + *operPtr = 20; + *valPtr = *(inter_variables + temp * 4 + offset * 4 * inter_animDataSize + temp2); + } + break; + + case 29: + operation = *inter_execPtr++; + parse_parseExpr(10, 0); + + switch (operation) { + case 5: + inter_resVal = inter_resVal * inter_resVal; + break; + + case 0: + case 1: + case 6: + curVal = 1; + prevVal = 1; + + do { + prevPrevVal = prevVal; + prevVal = curVal; + curVal = (curVal + inter_resVal / curVal) / 2; + } while (curVal != prevVal && curVal != prevPrevVal); + inter_resVal = curVal; + break; + + case 10: + inter_resVal = util_getRandom(inter_resVal); + break; + + case 7: + if (inter_resVal < 0) + inter_resVal = -inter_resVal; + break; + } + *operPtr = 20; + *valPtr = inter_resVal; + } + + if (stkPos > 0 && (operPtr[-1] == 1 || operPtr[-1] == 11)) { + stkPos--; + operPtr--; + valPtr--; + + if (*operPtr == 1) { + *operPtr = 20; + valPtr[0] = -valPtr[1]; + } else if (*operPtr == 11) { + if (operPtr[1] == 23) + *operPtr = 24; + else + *operPtr = 23; + } + } + + if (stkPos <= 0) + continue; + + switch (operPtr[-1]) { + case 2: + if (operPtr[-2] == 22) { + if ((char *)valPtr[-2] != inter_resStr) { + strcpy(inter_resStr, (char *)valPtr[-2]); + valPtr[-2] = (int32)inter_resStr; + } + strcat((char *)valPtr[-2], (char *)valPtr[0]); + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + } + break; + + case 5: + valPtr[-2] *= valPtr[0]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 6: + valPtr[-2] /= valPtr[0]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 7: + valPtr[-2] %= valPtr[0]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 8: + valPtr[-2] &= valPtr[0]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + } + continue; + } // op>= 19 && op <= 29 + + if (operation == arg_0 || operation == 30 || operation == 31 || operation == 10) { + while (stkPos >= 2) { + var_1A = 0; + if (operPtr[-2] == 9 && (operation == 10 || operation == arg_0)) { + operPtr[-2] = operPtr[-1]; + if (operPtr[-2] == 20 || operPtr[-2] == 22) + valPtr[-2] = valPtr[-1]; + + stkPos--; + operPtr--; + valPtr--; + + if (stkPos > 1) { + if (operPtr[-2] == 1) { + operPtr[-2] = 20; + valPtr[-2] = -valPtr[-1]; + stkPos--; + operPtr--; + valPtr--; + } else if (operPtr[-2] == 11) { + if (operPtr[-1] == 23) + operPtr[-2] = 24; + else + operPtr[-2] = 23; + + stkPos--; + operPtr--; + valPtr--; + } + } // stkPos > 1 + + if (stkPos > 2) { + switch (operPtr[-2]) { + case 5: + valPtr[-3] *= valPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + case 6: + valPtr[-3] /= valPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 7: + valPtr[-3] %= valPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 8: + valPtr[-3] &= valPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + } // switch + } // stkPos > 2 + + if (operation != arg_0) + break; + } // if(operPtr[-2] == 9 && ...) + + for (brackStart = stkPos - 2; brackStart > 0 && + operStack[brackStart] < 30 && + operStack[brackStart] != 9; brackStart--); + + if (operStack[brackStart] >= 30 || operStack[brackStart] == 9) + brackStart++; + + switch (operPtr[-2]) { + case 2: + if (operStack[brackStart] == 20) { + values[brackStart] += valPtr[-1]; + } else if (operStack[brackStart] == 22) { + if ((char *)values[brackStart] + != inter_resStr) { + strcpy(inter_resStr, (char *)values[brackStart]); + values[brackStart] = (int32)inter_resStr; + } + strcat((char *)values[brackStart], (char *)valPtr[-1]); + } + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + continue; + + case 3: + values[brackStart] -= valPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + continue; + + case 4: + values[brackStart] |= valPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + continue; + + case 5: + valPtr[-3] *= valPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 6: + valPtr[-3] /= valPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 7: + valPtr[-3] %= valPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 8: + valPtr[-3] &= valPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 30: + if (operPtr[-3] == 23) + operPtr[-3] = operPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 31: + if (operPtr[-3] == 24) + operPtr[-3] = operPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 32: + var_C = operPtr[-3]; + operPtr[-3] = 23; + if (var_C == 20) { + if (valPtr[-3] < valPtr[-1]) + operPtr[-3] = 24; + } else if (var_C == 22) { + if ((char *)valPtr[-3] != inter_resStr) { + strcpy(inter_resStr, (char *)valPtr[-3]); + valPtr[-3] = (int32)inter_resStr; + } + if (strcmp((char *)valPtr[-3], (char *)valPtr[-1]) < 0) + operPtr[-3] = 24; + } + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 33: + var_C = operPtr[-3]; + operPtr[-3] = 23; + if (var_C == 20) { + if (valPtr[-3] <= valPtr[-1]) + operPtr[-3] = 24; + } else if (var_C == 22) { + if ((char *)valPtr[-3] != inter_resStr) { + strcpy(inter_resStr, (char *)valPtr[-3]); + valPtr[-3] = (int32)inter_resStr; + } + if (strcmp((char *)valPtr[-3], (char *)valPtr[-1]) <= 0) + operPtr[-3] = 24; + } + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 34: + var_C = operPtr[-3]; + operPtr[-3] = 23; + if (var_C == 20) { + if (valPtr[-3] > valPtr[-1]) + operPtr[-3] = 24; + } else if (var_C == 22) { + if ((char *)valPtr[-3] != inter_resStr) { + strcpy(inter_resStr, (char *)valPtr[-3]); + valPtr[-3] = (int32)inter_resStr; + } + if (strcmp((char *)valPtr[-3], (char *)valPtr[-1]) > 0) + operPtr[-3] = 24; + } + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 35: + var_C = operPtr[-3]; + operPtr[-3] = 23; + if (var_C == 20) { + if (valPtr[-3] >= valPtr[-1]) + operPtr[-3] = 24; + } else if (var_C == 22) { + if ((char *)valPtr[-3] != inter_resStr) { + strcpy(inter_resStr, (char *)valPtr[-3]); + valPtr[-3] = (int32)inter_resStr; + } + if (strcmp((char *)valPtr[-3], (char *)valPtr[-1]) >= 0) + operPtr[-3] = 24; + } + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 36: + var_C = operPtr[-3]; + operPtr[-3] = 23; + if (var_C == 20) { + if (valPtr[-3] == valPtr[-1]) + operPtr[-3] = 24; + } else if (var_C == 22) { + if ((char *)valPtr[-3] != inter_resStr) { + strcpy(inter_resStr, (char *)valPtr[-3]); + valPtr[-3] = (int32)inter_resStr; + } + if (strcmp((char *)valPtr[-3], (char *)valPtr[-1]) == 0) + operPtr[-3] = 24; + } + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + case 37: + var_C = operPtr[-3]; + operPtr[-3] = 23; + if (var_C == 20) { + if (valPtr[-3] != valPtr[-1]) + operPtr[-3] = 24; + } else if (var_C == 22) { + if ((char *)valPtr[-3] != inter_resStr) { + strcpy(inter_resStr, (char *)valPtr[-3]); + valPtr[-3] = (int32)inter_resStr; + } + if (strcmp((char *)valPtr[-3], (char *)valPtr[-1]) != 0) + operPtr[-3] = 24; + } + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + break; + + default: + var_1A = 1; + break; + } // switch + + if (var_1A != 0) + break; + } // while(stkPos >= 2) + + if (operation == 30 || operation == 31) { + if (operPtr[-1] == 20) { + if (valPtr[-1] != 0) + operPtr[-1] = 24; + else + operPtr[-1] = 23; + } + + if ((operation == 30 && operPtr[-1] == 24) || + (operation == 31 && operPtr[-1] == 23)) { + if (stkPos > 1 && operPtr[-2] == 9) { + parse_skipExpr(10); + operPtr[-2] = operPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + } else { + parse_skipExpr(arg_0); + } + operation = inter_execPtr[-1]; + if (stkPos > 0 && operPtr[-1] == 11) { + if (operPtr[0] == 23) + operPtr[-1] = 24; + else + operPtr[-1] = 23; + + stkPos--; + operPtr--; + valPtr--; + } + } else + operPtr[0] = operation; + } else { + stkPos--; + operPtr--; + valPtr--; + } + + if (operation != arg_0) + continue; + + if (arg_2 != 0) + *arg_2 = operStack[0]; + + switch (operStack[0]) { + case 20: + inter_resVal = values[0]; + break; + + case 22: + if ((char *)values[0] != inter_resStr) + strcpy(inter_resStr, + (char *)values[0]); + break; + + case 11: + if (arg_2 != 0) + *arg_2 ^= 1; + break; + + case 23: + case 24: + break; + + default: + inter_resVal = 0; + if (arg_2 != 0) + *arg_2 = 20; + break; + } + return 0; + } // operation == arg_0 || operation == 30 || operation == 31 || operation == 10 + + if (operation < 1 || operation > 11) { + if (operation < 32 || operation > 37) + continue; + + if (stkPos > 2) { + if (operPtr[-2] == 2) { + if (operPtr[-3] == 20) { + valPtr[-3] += valPtr[-1]; + } else if (operPtr[-3] == 22) { + if ((char *)valPtr[-3] != inter_resStr) { + strcpy(inter_resStr, (char *)valPtr[-3]); + valPtr[-3] = (int32)inter_resStr; + } + strcat((char *)valPtr[-3], (char *)valPtr[-1]); + } + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + + } else if (operPtr[-2] == 3) { + valPtr[-3] -= valPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + } else if (operPtr[-2] == 4) { + valPtr[-3] |= valPtr[-1]; + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + } + } + } + *operPtr = operation; + } +} + +void parse_skipExpr(char arg_0) { + int16 dimCount; + char operation; + int16 num; + int16 dim; + + num = 0; + while (1) { + operation = *inter_execPtr++; + + if (operation >= 19 && operation <= 29) { + switch (operation) { + case 20: + case 23: + inter_execPtr += 2; + break; + + case 19: + inter_execPtr += 4; + break; + + case 22: + inter_execPtr += strlen(inter_execPtr) + 1; + break; + + case 25: + inter_execPtr += 2; + if (*inter_execPtr == 13) { + inter_execPtr++; + parse_skipExpr(12); + } + break; + + case 26: + case 28: + dimCount = inter_execPtr[2]; + inter_execPtr += 3 + dimCount; // ??? + for (dim = 0; dim < dimCount; dim++) + parse_skipExpr(12); + + if (operation == 28 && *inter_execPtr == 13) { + inter_execPtr++; + parse_skipExpr(12); + } + break; + + case 29: + inter_execPtr++; + parse_skipExpr(10); + } + continue; + } // if(operation >= 19 && operation <= 29) + + if (operation == 9) { + num++; + continue; + } + + if (operation == 11 || (operation >= 1 && operation <= 8)) + continue; + + if (operation >= 30 && operation <= 37) + continue; + + if (operation == 10) + num--; + + if (operation != arg_0) + continue; + + if (arg_0 != 10 || num < 0) + return; + } +} + +int16 parse_parseValExpr() { + int16 values[20]; + byte operStack[20]; + int16 *valPtr; + byte *operPtr; + byte *arrDesc; + unsigned operation; + int16 temp2; + int16 dim; + int16 dimCount; + int16 temp; + int16 offset; + int16 stkPos; + int16 brackPos; + static int16 flag = 0; + int16 oldflag; + + oldflag = flag; + if (flag == 0) { + flag = 1; + parse_printExpr(99); + } + + stkPos = -1; + operPtr = operStack - 1; + valPtr = values - 1; + + while (1) { + stkPos++; + operPtr++; + valPtr++; + + operation = *inter_execPtr++; + if (operation >= 19 && operation <= 29) { + *operPtr = 20; + switch (operation) { + case 19: + *valPtr = READ_LE_UINT32(inter_execPtr); + inter_execPtr += 4; + break; + + case 20: + *valPtr = inter_load16(); + break; + + case 23: + *valPtr = READ_LE_UINT16(inter_variables + inter_load16() * 4); + break; + + case 25: + temp = inter_load16() * 4; + inter_execPtr++; + temp += parse_parseValExpr(); + *valPtr = *(inter_variables + temp); + break; + + case 26: + case 28: + temp = inter_load16(); + dimCount = *inter_execPtr++; + arrDesc = (byte*)inter_execPtr; + inter_execPtr += dimCount; + offset = 0; + for (dim = 0; dim < dimCount; dim++) { + temp2 = parse_parseValExpr(); + offset = arrDesc[dim] * offset + temp2; + } + if (operation == 26) { + *valPtr = READ_LE_UINT16(inter_variables + temp * 4 + offset * 4); + } else { + inter_execPtr++; + temp2 = parse_parseValExpr(); + *valPtr = *(inter_variables + temp * 4 + offset * 4 * inter_animDataSize + temp2); + } + break; + + case 29: + operation = *inter_execPtr++; + parse_parseExpr(10, 0); + + if (operation == 5) { + inter_resVal = inter_resVal * inter_resVal; + } else if (operation == 7) { + if (inter_resVal < 0) + inter_resVal = -inter_resVal; + } else if (operation == 10) { + inter_resVal = util_getRandom(inter_resVal); + } + *valPtr = inter_resVal; + break; + + } // switch + if (stkPos > 0 && operPtr[-1] == 1) { + stkPos--; + operPtr--; + valPtr--; + operPtr[0] = 20; + valPtr[0] = -valPtr[1]; + } + + if (stkPos > 0 && operPtr[-1] > 4 && operPtr[-1] < 9) { + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + + switch (operPtr[1]) { + case 5: + valPtr[0] *= valPtr[2]; + break; + + case 6: + valPtr[0] /= valPtr[2]; + break; + + case 7: + valPtr[0] %= valPtr[2]; + break; + + case 8: + valPtr[0] &= valPtr[2]; + break; + } + } // if(stkPos > 0 && cmdPtr[-1] > 4 && cmdPtr[-1] < 9) + continue; + } + + if (operation >= 1 && operation <= 9) { + *operPtr = operation; + continue; + } + + while (stkPos >= 2) { + if (operPtr[-2] == 9) { + stkPos--; + operPtr--; + valPtr--; + + operPtr[-1] = operPtr[0]; + valPtr[-1] = valPtr[0]; + if (stkPos > 1 && operPtr[-2] == 1) { + valPtr[-2] = 20; + valPtr[-2] = -valPtr[-1]; + + stkPos--; + operPtr--; + valPtr--; + } + + if (stkPos > 2 && operPtr[-2] > 4 + && operPtr[-2] < 9) { + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + switch (operPtr[0]) { + case 5: + operPtr[-1] *= operPtr[1]; + break; + + case 6: + operPtr[-1] /= operPtr[1]; + break; + + case 7: + operPtr[-1] %= operPtr[1]; + break; + + case 8: + operPtr[-1] &= operPtr[1]; + break; + } + } + if (operation == 10) + break; + } // operPtr[-2] == 9 + + for (brackPos = stkPos - 2; brackPos > 0 && + operStack[brackPos] < 30 + && operStack[brackPos] != 9; brackPos--); + + if (operStack[brackPos] >= 30 + || operStack[brackPos] == 9) + brackPos++; + + if (operPtr[-2] < 2 || operPtr[-2] > 8) + break; + + stkPos -= 2; + operPtr -= 2; + valPtr -= 2; + switch (operPtr[0]) { + case 2: + values[brackPos] += valPtr[1]; + continue; + case 3: + values[brackPos] -= valPtr[1]; + continue; + case 4: + values[brackPos] |= valPtr[1]; + continue; + case 5: + valPtr[-1] *= valPtr[1]; + continue; + case 6: + valPtr[-1] /= valPtr[1]; + continue; + case 7: + valPtr[-1] %= valPtr[1]; + continue; + case 8: + valPtr[-1] &= valPtr[1]; + continue; + } + } + + if (operation != 10) { + flag = oldflag; + return values[0]; + } + + stkPos--; + operPtr--; + valPtr--; + } +} + +int16 parse_parseVarIndex() { + int16 temp2; + char *arrDesc; + int16 dim; + int16 dimCount; + int16 operation; + int16 temp; + int16 offset; + int16 val; + + operation = *inter_execPtr++; + debug(5, "var parse = %d\n", operation); + switch (operation) { + case 23: + case 25: + temp = inter_load16() * 4; + debug(5, "oper = %d\n", (int16)*inter_execPtr); + if (operation == 25 && *inter_execPtr == 13) { + inter_execPtr++; + val = parse_parseValExpr(); + temp += val; + debug(5, "parse subscript = %d\n", val); + } + return temp; + + case 26: + case 28: + temp = inter_load16() * 4; + dimCount = *inter_execPtr++; + arrDesc = inter_execPtr; + inter_execPtr += dimCount; + offset = 0; + for (dim = 0; dim < dimCount; dim++) { + temp2 = parse_parseValExpr(); + offset = arrDesc[dim] * offset + temp2; + } + offset *= 4; + if (operation != 28) + return temp + offset; + + if (*inter_execPtr == 13) { + inter_execPtr++; + temp += parse_parseValExpr(); + } + return offset * inter_animDataSize + temp; + + default: + return 0; + } +} + +void parse_printExpr(char arg_0) { + int16 dimCount; + char operation; + int16 num; + int16 dim; + char *arrDesc; + char func; + char saved = 0; + static char *savedPos = 0; + + if (savedPos == 0) { + savedPos = inter_execPtr; + saved = 1; + } + + num = 0; + while (1) { + operation = *inter_execPtr++; + + if (operation >= 19 && operation <= 29) { + switch (operation) { + case 19: + debug(5, "%l", READ_LE_UINT32(inter_execPtr)); + inter_execPtr += 4; + break; + + case 20: + debug(5, "%d", inter_load16()); + break; + + case 22: + debug(5, "\42%s\42", inter_execPtr); + inter_execPtr += strlen(inter_execPtr) + 1; + break; + + case 23: + debug(5, "var_%d", inter_load16()); + break; + + case 25: + debug(5, "(&var_%d)", inter_load16()); + if (*inter_execPtr == 13) { + inter_execPtr++; + debug(5, "{"); + parse_printExpr(12); +// debug(5, "}"); + } + break; + + case 26: + case 28: + if (operation == 28) + debug(5, "(&"); + + debug(5, "var_%d[", inter_load16()); + dimCount = *inter_execPtr++; + arrDesc = inter_execPtr; + inter_execPtr += dimCount; + for (dim = 0; dim < dimCount; dim++) { + parse_printExpr(12); + debug(5, " of %d", (int16)arrDesc[dim]); + if (dim != dimCount - 1) + debug(5, ","); + } + debug(5, "]"); + if (operation == 28) + debug(5, ")"); + + if (operation == 28 && *inter_execPtr == 13) { + inter_execPtr++; + debug(5, "{"); + parse_printExpr(12); +// debug(5, "}"); + } + break; + + case 29: + func = *inter_execPtr++; + if (func == 5) + debug(5, "sqr("); + else if (func == 10) + debug(5, "rand("); + else if (func == 7) + debug(5, "abs("); + else if (func == 0 || func == 1 || func == 6) + debug(5, "sqrt("); + else + debug(5, "id("); + parse_printExpr(10); + break; + + case 12: + debug(5, "}"); + break; + + default: + debug(5, "<%d>", (int16)operation); + break; + } + continue; + } // if(operation >= 19 && operation <= 29) + switch (operation) { + case 9: + debug(5, "("); + break; + + case 11: + debug(5, "!"); + break; + + case 10: + debug(5, ")"); + break; + + case 1: + debug(5, "-"); + break; + + case 2: + debug(5, "+"); + break; + + case 3: + debug(5, "-"); + break; + + case 4: + debug(5, "|"); + break; + + case 5: + debug(5, "*"); + break; + + case 6: + debug(5, "/"); + break; + + case 7: + debug(5, "%"); + break; + + case 8: + debug(5, "&"); + break; + + case 30: + debug(5, "||"); + break; + + case 31: + debug(5, "&&"); + break; + + case 32: + debug(5, "<"); + break; + + case 33: + debug(5, "<="); + break; + + case 34: + debug(5, ">"); + break; + + case 35: + debug(5, ">="); + break; + + case 36: + debug(5, "=="); + break; + + case 37: + debug(5, "!="); + break; + + case 99: + debug(5, "\n"); + break; + + case 12: + debug(5, "}"); + break; + + default: + debug(5, "<%d>", (int16)operation); + break; + } + + if (operation == 9) { + num++; + continue; + } + + if (operation == 11 || (operation >= 1 && operation <= 8)) + continue; + + if (operation >= 30 && operation <= 37) + continue; + + if (operation == 10) + num--; + + if (operation == arg_0) { + if (arg_0 != 10 || num < 0) { + + if (saved != 0) { + inter_execPtr = savedPos; + savedPos = 0; + } + return; + } + } + } +} + +void parse_printVarIndex() { + char *arrDesc; + int16 dim; + int16 dimCount; + int16 operation; + int16 temp; + + char *pos = inter_execPtr; + + operation = *inter_execPtr++; + switch (operation) { + case 23: + case 25: + temp = inter_load16() * 4; + debug(5, "&var_%d", temp); + if (operation == 25 && *inter_execPtr == 13) { + inter_execPtr++; + debug(5, "+"); + parse_printExpr(99); + } + break; + + case 26: + case 28: + debug(5, "&var_%d[", inter_load16()); + dimCount = *inter_execPtr++; + arrDesc = inter_execPtr; + inter_execPtr += dimCount; + for (dim = 0; dim < dimCount; dim++) { + parse_printExpr(12); + debug(5, " of %d", (int16)arrDesc[dim]); + if (dim != dimCount - 1) + debug(5, ","); + } + debug(5, "]"); + + if (operation == 28 && *inter_execPtr == 13) { + inter_execPtr++; + debug(5, "+"); + parse_printExpr(99); + } + break; + + default: + debug(5, "var_0"); + break; + } + debug(5, "\n"); + inter_execPtr = pos; + return; +} + +} // End of namespace Gob -- cgit v1.2.3