diff options
author | Paul Gilbert | 2012-05-19 12:33:14 +1000 |
---|---|---|
committer | Paul Gilbert | 2012-05-19 12:33:14 +1000 |
commit | 5d18a71045bd933fc2efc7ed6e60ef7763745cb7 (patch) | |
tree | 45510e6b53ab4395de1885a9d4ba014e8124a6e4 /engines/tony/mpal | |
parent | bcaeacf1246b652f1564fc7696719ca9429b5acf (diff) | |
download | scummvm-rg350-5d18a71045bd933fc2efc7ed6e60ef7763745cb7.tar.gz scummvm-rg350-5d18a71045bd933fc2efc7ed6e60ef7763745cb7.tar.bz2 scummvm-rg350-5d18a71045bd933fc2efc7ed6e60ef7763745cb7.zip |
TONY: Converting comments to English and formatting
Diffstat (limited to 'engines/tony/mpal')
-rw-r--r-- | engines/tony/mpal/expr.cpp | 293 | ||||
-rw-r--r-- | engines/tony/mpal/expr.h | 65 | ||||
-rw-r--r-- | engines/tony/mpal/loadmpc.cpp | 235 | ||||
-rw-r--r-- | engines/tony/mpal/loadmpc.h | 21 |
4 files changed, 247 insertions, 367 deletions
diff --git a/engines/tony/mpal/expr.cpp b/engines/tony/mpal/expr.cpp index 19170ce60c..5e09e5dec6 100644 --- a/engines/tony/mpal/expr.cpp +++ b/engines/tony/mpal/expr.cpp @@ -61,9 +61,9 @@ namespace Tony { namespace MPAL { -/****************************************************************************\ -* Operazioni matematiche gestite -\****************************************************************************/ +/** + * @defgroup Mathamatical operations + */ #define OP_MUL ((1<<4)|0) #define OP_DIV ((1<<4)|1) @@ -85,32 +85,24 @@ namespace MPAL { #define OP_OR ((10<<4)|0) -/****************************************************************************\ -* enum ExprListTypes -* ------------------ -* Description: Tipi di oggetto che possono essere contenuti in una struttura -* EXPRESSION. -\****************************************************************************/ - -enum ExprListTypes -{ - ELT_NUMBER=1, - ELT_VAR=2, - ELT_PARENTH=3, - ELT_PARENTH2=4 +/** + * Object types that can be contained in an EXPRESSION structure + */ +enum ExprListTypes { + ELT_NUMBER = 1, + ELT_VAR = 2, + ELT_PARENTH = 3, + ELT_PARENTH2 = 4 }; -/****************************************************************************\ -* Structures -\****************************************************************************/ - -/****************************************************************************\ -* typedef EXPRESSION -* ------------------ -* Description: Struttura per gestire le operazioni matematiche -\****************************************************************************/ +/** + * @defgroup Structures + */ +/** + * Mathamatical framework to manage operations + */ typedef struct { byte type; // Tipo di oggetto (vedi enum ExprListTypes) byte unary; // Unary operatore (NON SUPPORTATO) @@ -128,38 +120,31 @@ typedef struct { typedef EXPRESSION* LPEXPRESSION; -/****************************************************************************\ -* -* Function: LPEXPRESSION DuplicateExpression(HGLOBAL h); -* -* Description: Duplica un'espressione matematica. L'espressione duplicata -* sara' formata da memoria non swappabile. -* -* Input: HGLOBAL h Handle dell'espressione originale -* -* Return: Pointer all'espressione clone della prima -* -\****************************************************************************/ - +/** + * Duplicate a mathematical expression. + * + * @param h Handle to the original expression + * @retruns Pointer to the cloned expression + */ static byte *DuplicateExpression(HGLOBAL h) { int i, num; byte *orig, *clone; LPEXPRESSION one, two; - orig=(byte *)GlobalLock(h); + orig = (byte *)GlobalLock(h); - num=*(byte *)orig; - one=(LPEXPRESSION)(orig+1); + num = *(byte *)orig; + one = (LPEXPRESSION)(orig+1); - clone = (byte *)GlobalAlloc(GMEM_FIXED, sizeof(EXPRESSION)*num+1); - two=(LPEXPRESSION)(clone+1); + clone = (byte *)GlobalAlloc(GMEM_FIXED, sizeof(EXPRESSION) * num + 1); + two = (LPEXPRESSION)(clone + 1); - CopyMemory(clone,orig,sizeof(EXPRESSION)*num+1); + CopyMemory(clone, orig, sizeof(EXPRESSION) * num + 1); - for (i=0;i<num;i++) { - if (one->type==ELT_PARENTH) { - two->type=ELT_PARENTH2; - two->val.pson=DuplicateExpression(two->val.son); + for (i = 0; i < num; i++) { + if (one->type == ELT_PARENTH) { + two->type = ELT_PARENTH2; + two->val.pson = DuplicateExpression(two->val.son); } one++; @@ -173,41 +158,41 @@ static byte *DuplicateExpression(HGLOBAL h) { static int Compute(int a, int b, byte symbol) { switch (symbol) { case OP_MUL: - return a*b; + return a * b; case OP_DIV: - return a/b; + return a / b; case OP_MODULE: - return a%b; + return a % b; case OP_ADD: - return a+b; + return a + b; case OP_SUB: - return a-b; + return a - b; case OP_SHL: - return a<<b; + return a << b; case OP_SHR: - return a>>b; + return a >> b; case OP_MINOR: - return a<b; + return a < b; case OP_MAJOR: - return a>b; + return a > b; case OP_MINEQ: - return a<=b; + return a <= b; case OP_MAJEQ: - return a>=b; + return a >= b; case OP_EQUAL: - return a==b; + return a == b; case OP_NOEQUAL: - return a!=b; + return a != b; case OP_BITAND: - return a&b; + return a & b; case OP_BITXOR: - return a^b; + return a ^ b; case OP_BITOR: - return a|b; + return a | b; case OP_AND: - return a&&b; + return a && b; case OP_OR: - return a||b; + return a || b; default: GLOBALS.mpalError = 1; break; @@ -220,52 +205,45 @@ static void Solve(LPEXPRESSION one, int num) { LPEXPRESSION two, three; int j; - while (num>1) { - two=one+1; - if ((two->symbol==0) || (one->symbol&0xF0) <= (two->symbol&0xF0)) { - two->val.num=Compute(one->val.num,two->val.num,one->symbol); - CopyMemory(one,two,(num-1)*sizeof(EXPRESSION)); + while (num > 1) { + two=one + 1; + if ((two->symbol == 0) || (one->symbol & 0xF0) <= (two->symbol & 0xF0)) { + two->val.num=Compute(one->val.num, two->val.num,one->symbol); + CopyMemory(one, two, (num - 1) * sizeof(EXPRESSION)); num--; } else { - j=1; - three=two+1; - while ((three->symbol!=0) && (two->symbol&0xF0)>(three->symbol&0xF0)) { + j = 1; + three = two + 1; + while ((three->symbol != 0) && (two->symbol & 0xF0)>(three->symbol & 0xF0)) { two++; three++; j++; } - three->val.num=Compute(two->val.num,three->val.num,two->symbol); - CopyMemory(two,three,(num-j-1)*sizeof(EXPRESSION)); + three->val.num = Compute(two->val.num, three->val.num, two->symbol); + CopyMemory(two, three, (num - j - 1) * sizeof(EXPRESSION)); num--; } } } -/****************************************************************************\ -* -* Function: int EvaluateAndFreeExpression(byte *expr); -* -* Description: Calcola il risultato di una espressione matematica, sosti- -* tuendo ad eventuali variabili il valore corrente. -* -* Input: byte *expr Pointer all'espressione duplicata -* tramite DuplicateExpression -* -* Return: Valore dell'espressione -* -\****************************************************************************/ - +/** + * Calculates the result of a mathematical expression, replacing the current + * value of any variable. + * + * @param expr Pointer to an expression duplicated by DuplicateExpression + * @returns Value + */ static int EvaluateAndFreeExpression(byte *expr) { int i,num,val; LPEXPRESSION one,cur; - num=*expr; - one=(LPEXPRESSION)(expr+1); + num = *expr; + one = (LPEXPRESSION)(expr + 1); // 1) Sostituzioni delle variabili - for (i=0,cur=one;i<num;i++,cur++) { + for (i=0, cur=one; i < num; i++, cur++) { if (cur->type==ELT_VAR) { cur->type=ELT_NUMBER; cur->val.num=varGetValue(cur->val.name); @@ -273,39 +251,30 @@ static int EvaluateAndFreeExpression(byte *expr) { } // 2) Sostituzioni delle parentesi (tramite ricorsione) - for (i=0,cur=one;i<num;i++,cur++) { - if (cur->type==ELT_PARENTH2) { - cur->type=ELT_NUMBER; - cur->val.num=EvaluateAndFreeExpression(cur->val.pson); + for (i = 0, cur = one; i < num; i++, cur++) { + if (cur->type == ELT_PARENTH2) { + cur->type = ELT_NUMBER; + cur->val.num = EvaluateAndFreeExpression(cur->val.pson); } } // 3) Risoluzione algebrica - Solve(one,num); - val=one->val.num; + Solve(one, num); + val = one->val.num; GlobalFree(expr); return val; } -/****************************************************************************\ -* -* Function: byte *ParseExpression(byte *buf, HGLOBAL *h); -* -* Description: Esegue il parsing da file .MPC di un'espressione matematica. -* -* Input: byte *buf Buffer contenente l'espressione -* compilata. -* HGLOBAL *h Pointer a un handle che, alla fine -* dell'esecuzione, puntera' alla -* zona di memoria contenete l'espres- -* sione parsata -* -* Return: Puntatore al buffer subito dopo l'espressione, o NULL in caso -* di errore. -* -\****************************************************************************/ +/** + * Parses a mathematical expression from the MPC file + * + * @param buf Buffer containing the expression to evaluate + * @param h Pointer to a handle that, at the end of execution, + * will point to the area of memory containing the parsed expression + * @returns Pointer to the buffer immediately after the expression, or NULL if error. + */ const byte *ParseExpression(const byte *lpBuf, HGLOBAL *h) { LPEXPRESSION cur; byte *start; @@ -317,36 +286,36 @@ const byte *ParseExpression(const byte *lpBuf, HGLOBAL *h) { if (num == 0) return NULL; - *h = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT, num * sizeof(EXPRESSION) + 1); + *h = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, num * sizeof(EXPRESSION) + 1); if (*h==NULL) return NULL; - start=(byte *)GlobalLock(*h); - *start=(byte)num; + start = (byte *)GlobalLock(*h); + *start = (byte)num; - cur=(LPEXPRESSION)(start+1); + cur = (LPEXPRESSION)(start + 1); - for (i=0;i<num;i++) { - cur->type=*(lpBuf); - cur->unary=*(lpBuf+1); - lpBuf+=2; + for (i = 0;i < num; i++) { + cur->type = *(lpBuf); + cur->unary = *(lpBuf + 1); + lpBuf += 2; switch (cur->type) { case ELT_NUMBER: - cur->val.num=*(int *)lpBuf; - lpBuf+=4; + cur->val.num = *(int *)lpBuf; + lpBuf += 4; break; case ELT_VAR: - cur->val.name=(char *)GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,(*lpBuf)+1); - if (cur->val.name==NULL) + cur->val.name = (char *)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, (*lpBuf) + 1); + if (cur->val.name == NULL) return NULL; - CopyMemory(cur->val.name,lpBuf+1,*lpBuf); - lpBuf+=*lpBuf+1; + CopyMemory(cur->val.name, lpBuf + 1, *lpBuf); + lpBuf += *lpBuf + 1; break; case ELT_PARENTH: - lpBuf=ParseExpression(lpBuf,&cur->val.son); - if (lpBuf==NULL) + lpBuf=ParseExpression(lpBuf, &cur->val.son); + if (lpBuf == NULL) return NULL; break; @@ -354,13 +323,13 @@ const byte *ParseExpression(const byte *lpBuf, HGLOBAL *h) { return NULL; } - cur->symbol=*lpBuf; + cur->symbol = *lpBuf; lpBuf++; cur++; } - if (*lpBuf!=0) + if (*lpBuf != 0) return NULL; lpBuf++; @@ -369,18 +338,12 @@ const byte *ParseExpression(const byte *lpBuf, HGLOBAL *h) { } -/****************************************************************************\ -* -* Function: int EvaluateExpression(HGLOBAL h); -* -* Description: Calcola il valore di un'espressione matematica -* -* Input: HGLOBAL h Handle all'espressione -* -* Return: Valore numerico -* -\****************************************************************************/ - +/** + * Calculate the value of a mathamatical expression + * + * @param h Handle to the expression + * @returns Numeric value + */ int EvaluateExpression(HGLOBAL h) { int ret; @@ -392,28 +355,22 @@ int EvaluateExpression(HGLOBAL h) { } -/****************************************************************************\ -* -* Function: bool CompareExpressions(HGLOBAL h1, HGLOBAL h2); -* -* Description: Confronta due espressioni matematiche tra loro -* -* Input: HGLOBAL h1,h2 Espressioni da confrontare -* -* Return: true se sono uguali, false se sono diverse -* -\****************************************************************************/ - +/** + * Compare two mathematical expressions together + * + * @param h1 Expression to be compared + * @param h2 Expression to be compared + */ bool CompareExpressions(HGLOBAL h1, HGLOBAL h2) { - int i,num1,num2; + int i, num1, num2; byte *e1, *e2; LPEXPRESSION one, two; - e1=(byte *)GlobalLock(h1); - e2=(byte *)GlobalLock(h2); + e1 = (byte *)GlobalLock(h1); + e2 = (byte *)GlobalLock(h2); - num1=*(byte *)e1; - num2=*(byte *)e2; + num1 = *(byte *)e1; + num2 = *(byte *)e2; if (num1 != num2) { GlobalUnlock(h1); @@ -421,11 +378,11 @@ bool CompareExpressions(HGLOBAL h1, HGLOBAL h2) { return false; } - one=(LPEXPRESSION)(e1+1); - two=(LPEXPRESSION)(e2+1); + one = (LPEXPRESSION)(e1+1); + two = (LPEXPRESSION)(e2+1); - for (i=0;i<num1;i++) { - if (one->type!=two->type || (i!=num1-1 && one->symbol!=two->symbol)) { + for (i = 0; i < num1; i++) { + if (one->type != two->type || (i != num1 - 1 && one->symbol != two->symbol)) { GlobalUnlock(h1); GlobalUnlock(h2); return false; @@ -449,7 +406,7 @@ bool CompareExpressions(HGLOBAL h1, HGLOBAL h2) { break; case ELT_PARENTH: - if (!CompareExpressions(one->val.son,two->val.son)) { + if (!CompareExpressions(one->val.son, two->val.son)) { GlobalUnlock(h1); GlobalUnlock(h2); return false; diff --git a/engines/tony/mpal/expr.h b/engines/tony/mpal/expr.h index 582f6d381d..3a9f0f3208 100644 --- a/engines/tony/mpal/expr.h +++ b/engines/tony/mpal/expr.h @@ -55,60 +55,37 @@ namespace Tony { namespace MPAL { /****************************************************************************\ -* Prototipi di funzione -\****************************************************************************/ - -/****************************************************************************\ -* -* Function: byte *ParseExpression(byte *buf, HGLOBAL *h); -* -* Description: Esegue il parsing da file .MPC di un'espressione matematica. -* -* Input: byte *buf Buffer contenente l'espressione -* compilata. -* HGLOBAL *h Pointer a un handle che, alla fine -* dell'esecuzione, puntera' alla -* zona di memoria contenete l'espres- -* sione parsata -* -* Return: Puntatore al buffer subito dopo l'espressione, o NULL in caso -* di errore. -* +* Function Prototypes \****************************************************************************/ +/** + * Parses a mathematical expression from the MPC file + * + * @param buf Buffer containing the expression to evaluate + * @param h Pointer to a handle that, at the end of execution, + * will point to the area of memory containing the parsed expression + * @returns Pointer to the buffer immediately after the expression, or NULL if error. + */ const byte *ParseExpression(const byte *lpBuf, HGLOBAL *h); -/****************************************************************************\ -* -* Function: int EvaluateExpression(HGLOBAL h); -* -* Description: Calcola il valore di un'espressione matematica -* -* Input: HGLOBAL h Handle all'espressione -* -* Return: Valore numerico -* -\****************************************************************************/ - +/** + * Calculate the value of a mathamatical expression + * + * @param h Handle to the expression + * @returns Numeric value + */ int EvaluateExpression(HGLOBAL h); -/****************************************************************************\ -* -* Function: bool CompareExpressions(HGLOBAL h1, HGLOBAL h2); -* -* Description: Confronta due espressioni matematiche tra loro -* -* Input: HGLOBAL h1,h2 Espressioni da confrontare -* -* Return: TRUE se sono uguali, FALSE se sono diverse -* -\****************************************************************************/ - +/** + * Compare two mathematical expressions together + * + * @param h1 Expression to be compared + * @param h2 Expression to be compared + */ bool CompareExpressions(HGLOBAL h1, HGLOBAL h2); - } // end of namespace MPAL } // end of namespace Tony diff --git a/engines/tony/mpal/loadmpc.cpp b/engines/tony/mpal/loadmpc.cpp index 6430325503..6a1213bc19 100644 --- a/engines/tony/mpal/loadmpc.cpp +++ b/engines/tony/mpal/loadmpc.cpp @@ -76,22 +76,14 @@ static bool CompareCommands(struct command *cmd1, struct command *cmd2) { } -/****************************************************************************\ -* -* Function: LPBTYE ParseScript(byte *lpBuf, LPMPALSCRIPT lpmsScript); -* -* Description: Esegue il parsing da file .MPC di uno script e inserisce il -* tutto dentro una struttura -* -* Input: byte *lpBuf Buffer contenente lo script compilato -* LPMPALSCRIPT lpmsScript Puntatore a una struttura che verra' -* riempita con i dati dello script -* lato -* -* Return: Puntatore al buffer dopo l'item, o NULL in caso di errore -* -\****************************************************************************/ - +/** + * Parses a script from the MPC file, and inserts it's data into a structure + * + * @param lpBuf Buffer containing the compiled script. + * @param lpmsScript Pointer to a structure that will be filled with the + * data of the script. + * @returns Pointer to the buffer after the item, or NULL on failure. + */ static const byte *ParseScript(const byte *lpBuf, LPMPALSCRIPT lpmsScript) { int curCmd,j,len; uint i; @@ -102,14 +94,14 @@ static const byte *ParseScript(const byte *lpBuf, LPMPALSCRIPT lpmsScript) { lpmsScript->nMoments = READ_LE_UINT16(lpBuf); lpBuf += 2; - curCmd=0; + curCmd = 0; - for (i=0;i<lpmsScript->nMoments;i++) { + for (i = 0; i < lpmsScript->nMoments; i++) { lpmsScript->Moment[i].dwTime = (int32)READ_LE_UINT32(lpBuf); lpBuf += 4; - lpmsScript->Moment[i].nCmds=*lpBuf; lpBuf++; + lpmsScript->Moment[i].nCmds = *lpBuf; lpBuf++; - for (j=0;j<lpmsScript->Moment[i].nCmds;j++) { - lpmsScript->Command[curCmd].type=*lpBuf; lpBuf++; + for (j = 0; j < lpmsScript->Moment[i].nCmds; j++) { + lpmsScript->Command[curCmd].type = *lpBuf; lpBuf++; switch (lpmsScript->Command[curCmd].type) { case 1: lpmsScript->Command[curCmd].nCf = READ_LE_UINT16(lpBuf); lpBuf += 2; @@ -121,14 +113,14 @@ static const byte *ParseScript(const byte *lpBuf, LPMPALSCRIPT lpmsScript) { case 2: // Variable assign len=*lpBuf; lpBuf++; - lpmsScript->Command[curCmd].lpszVarName=(char *)GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,len+1); - if (lpmsScript->Command[curCmd].lpszVarName==NULL) + lpmsScript->Command[curCmd].lpszVarName = (char *)GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,len+1); + if (lpmsScript->Command[curCmd].lpszVarName == NULL) return NULL; CopyMemory(lpmsScript->Command[curCmd].lpszVarName, lpBuf, len); lpBuf+=len; lpBuf = ParseExpression(lpBuf, &lpmsScript->Command[curCmd].expr); - if (lpBuf==NULL) + if (lpBuf == NULL) return NULL; break; @@ -136,7 +128,7 @@ static const byte *ParseScript(const byte *lpBuf, LPMPALSCRIPT lpmsScript) { return NULL; } - lpmsScript->Moment[i].CmdNum[j]=curCmd; + lpmsScript->Moment[i].CmdNum[j] = curCmd; curCmd++; } } @@ -145,26 +137,17 @@ static const byte *ParseScript(const byte *lpBuf, LPMPALSCRIPT lpmsScript) { } -/****************************************************************************\ -* -* Function: byte *ParseDialog(byte *lpBuf, LPMPALDIALOG lpmdDialog); -* -* Description: Esegue il parsing da file .MPC di un dialog, e inserisce il -* tutto dentro una struttura -* -* Input: byte *lpBuf Buffer contenente il dialogo compi- -* lato -* LPMPALDIALOG lpmdDialog Puntatore a una struttura che verra' -* riempita con i dati del dialogo -* compilato -* -* Return: Puntatore al buffer dopo il dialogo, o NULL in caso di errore -* -\****************************************************************************/ - +/** + * Parses a dialog from the MPC file, and inserts it's data into a structure + * + * @param lpBuf Buffer containing the compiled dialog. + * @param lpmdDialog Pointer to a structure that will be filled with the + * data of the dialog. + * @returns Pointer to the buffer after the item, or NULL on failure. + */ static const byte *ParseDialog(const byte *lpBuf, LPMPALDIALOG lpmdDialog) { - uint32 i,j,z,kk; - uint32 num,num2,num3; + uint32 i, j, z, kk; + uint32 num, num2, num3; byte *lpLock; uint32 curCmd; uint32 len; @@ -309,7 +292,7 @@ static const byte *ParseDialog(const byte *lpBuf, LPMPALDIALOG lpmdDialog) { lpmdDialog->Choice[i].Select[j].wPlayGroup[num3] = 0; } - // Segna l'ultimo select + // Mark the last selection lpmdDialog->Choice[i].Select[num2].dwData = 0; } @@ -318,70 +301,61 @@ static const byte *ParseDialog(const byte *lpBuf, LPMPALDIALOG lpmdDialog) { return lpBuf; } -/****************************************************************************\ -* -* Function: byte *ParseItem(byte *lpBuf, LPMPALITEM lpmiItem); -* -* Description: Esegue il parsing da file .MPC di un item, e inserisce il -* tutto dentro una struttura -* -* Input: byte *lpBuf Buffer contenete l'item compilato -* LPMPALITEM lpmiItem Puntatore a una struttura che verra' -* riempita con i dati dell'item -* compilato -* -* Return: Puntatore al buffer dopo l'item, o NULL in caso di errore -* -* Note: E' necessario che la struttura passata come parametro sia -* stata completamente inizializzata a 0 (con una ZeroMemory, -* ad esempio). -* -\****************************************************************************/ +/** + * Parses an item from the MPC file, and inserts it's data into a structure + * + * @param lpBuf Buffer containing the compiled dialog. + * @param lpmiItem Pointer to a structure that will be filled with the + * data of the item. + * @returns Pointer to the buffer after the item, or NULL on failure. + * @remarks It's necessary that the structure that is passed has been + * completely initialised to 0 beforehand. + */ static const byte *ParseItem(const byte *lpBuf, LPMPALITEM lpmiItem) { byte len; - uint32 i,j,kk; + uint32 i, j, kk; uint32 curCmd; lpmiItem->nObj = (int32)READ_LE_UINT32(lpBuf); lpBuf += 4; - len=*lpBuf; + len = *lpBuf; lpBuf++; - CopyMemory(lpmiItem->lpszDescribe,lpBuf, MIN((byte)127, len)); - lpBuf+=len; + CopyMemory(lpmiItem->lpszDescribe, lpBuf, MIN((byte)127, len)); + lpBuf += len; if (len >= MAX_DESCRIBE_SIZE) - error("Describe too long in item #%d",lpmiItem->nObj); + error("Describe too long in item #%d", lpmiItem->nObj); lpmiItem->nActions=*lpBuf; lpBuf++; /* Alloca le azioni */ - if (lpmiItem->nActions>0) - lpmiItem->Action = (ItemAction *)GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,sizeof(struct ItemAction)*(int)lpmiItem->nActions); + if (lpmiItem->nActions > 0) + lpmiItem->Action = (ItemAction *)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(struct ItemAction) * (int)lpmiItem->nActions); - curCmd=0; + curCmd = 0; - for (i=0;i<lpmiItem->nActions;i++) { - lpmiItem->Action[i].num=*lpBuf; + for (i = 0; i < lpmiItem->nActions; i++) { + lpmiItem->Action[i].num = *lpBuf; lpBuf++; lpmiItem->Action[i].wParm = READ_LE_UINT16(lpBuf); lpBuf += 2; - if (lpmiItem->Action[i].num==0xFF) { + if (lpmiItem->Action[i].num == 0xFF) { lpmiItem->Action[i].wTime = READ_LE_UINT16(lpBuf); lpBuf += 2; - lpmiItem->Action[i].perc=*lpBuf; + lpmiItem->Action[i].perc = *lpBuf; lpBuf++; } - if (*lpBuf==0) { + if (*lpBuf == 0) { lpBuf++; - lpmiItem->Action[i].when=NULL; + lpmiItem->Action[i].when = NULL; } else { lpBuf++; lpBuf = ParseExpression(lpBuf,&lpmiItem->Action[i].when); @@ -395,8 +369,8 @@ static const byte *ParseItem(const byte *lpBuf, LPMPALITEM lpmiItem) { if (lpmiItem->Action[i].nCmds >= MAX_COMMANDS_PER_ACTION) error("Too much commands in action #%d in item #%d",lpmiItem->Action[i].num,lpmiItem->nObj); - for (j=0;j<lpmiItem->Action[i].nCmds;j++) { - lpmiItem->Command[curCmd].type=*lpBuf; + for (j = 0; j < lpmiItem->Action[i].nCmds; j++) { + lpmiItem->Command[curCmd].type = *lpBuf; lpBuf++; switch (lpmiItem->Command[curCmd].type) { case 1: // Call custom function @@ -408,16 +382,16 @@ static const byte *ParseItem(const byte *lpBuf, LPMPALITEM lpmiItem) { break; case 2: // Variable assign - len=*lpBuf; + len = *lpBuf; lpBuf++; - lpmiItem->Command[curCmd].lpszVarName=(char *)GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,len+1); - if (lpmiItem->Command[curCmd].lpszVarName==NULL) + lpmiItem->Command[curCmd].lpszVarName = (char *)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, len + 1); + if (lpmiItem->Command[curCmd].lpszVarName == NULL) return NULL; - CopyMemory(lpmiItem->Command[curCmd].lpszVarName,lpBuf,len); - lpBuf+=len; + CopyMemory(lpmiItem->Command[curCmd].lpszVarName, lpBuf, len); + lpBuf += len; - lpBuf=ParseExpression(lpBuf,&lpmiItem->Command[curCmd].expr); - if (lpBuf==NULL) + lpBuf=ParseExpression(lpBuf, &lpmiItem->Command[curCmd].expr); + if (lpBuf == NULL) return NULL; break; @@ -425,15 +399,15 @@ static const byte *ParseItem(const byte *lpBuf, LPMPALITEM lpmiItem) { return NULL; } - for (kk=0;kk<curCmd;kk++) { + for (kk = 0; kk < curCmd; kk++) { if (CompareCommands(&lpmiItem->Command[kk],&lpmiItem->Command[curCmd])) { - lpmiItem->Action[i].CmdNum[j]=kk; + lpmiItem->Action[i].CmdNum[j] = kk; break; } } if (kk==curCmd) { - lpmiItem->Action[i].CmdNum[j]=curCmd; + lpmiItem->Action[i].CmdNum[j] = curCmd; curCmd++; if (curCmd >= MAX_COMMANDS_PER_ITEM) { @@ -450,23 +424,14 @@ static const byte *ParseItem(const byte *lpBuf, LPMPALITEM lpmiItem) { } -/****************************************************************************\ -* -* Function: byte *ParseLocation(byte *buf, LPMPALLOCATIONN lpmlLocation) -* -* Description: Esegue il parsing da file .MPC di una locazione, riempendo -* una struttura -* -* Input: byte *buf Buffer contenente la locazione -* compilata -* LPMPALLOCATION -* lpmlLocation Pointer alla struttura che verra' -* riempita con i dati sulla locazione -* -* Return: Puntatore al buffer dopo l'item, o NULL in caso di errore -* -\****************************************************************************/ - +/** + * Parses a location from the MPC file, and inserts it's data into a structure + * + * @param lpBuf Buffer containing the compiled location. + * @param lpmiLocation Pointer to a structure that will be filled with the + * data of the location. + * @returns Pointer to the buffer after the location, or NULL on failure. + */ static const byte *ParseLocation(const byte *lpBuf, LPMPALLOCATION lpmlLocation) { lpmlLocation->nObj = (int32)READ_LE_UINT32(lpBuf); lpBuf += 4; @@ -480,39 +445,27 @@ static const byte *ParseLocation(const byte *lpBuf, LPMPALLOCATION lpmlLocation) return lpBuf; } -/*static int CompareMoments(int * a, int * b) { - if (*a<*b) - return -1; - else if (*a>*b) - return 1; - else - return 0; -}*/ - -/****************************************************************************\ -* Funzioni globali -\****************************************************************************/ /****************************************************************************\ -* -* Function: bool ParseMpc(byte *lpBuf); -* -* Description: Legge e interpreta un file MPC, e crea le strutture per le -* varie direttive nelle variabili globali -* -* Input: byte *lpBuf Immagine in memoria del file MPC, -* escluso l'header -* -* Return: true se tutto OK, false in caso di errore. -* +* Exported functions \****************************************************************************/ +/** + * @defgroup Exported functions + */ +/** + * Reads and interprets the MPC file, and create structures for various directives + * in the global variables + * + * @param lpBuf Buffer containing the MPC file data, excluding the header. + * @returns True if succeeded OK, false if failure. + */ bool ParseMpc(const byte *lpBuf) { uint16 i, j; uint16 wLen; byte *lpTemp, *lpTemp2; - /* 1. Variabili */ + /* 1. Variables */ if (lpBuf[0] != 'V' || lpBuf[1] != 'A' || lpBuf[2] != 'R' || lpBuf[3] != 'S') return false; @@ -540,7 +493,7 @@ bool ParseMpc(const byte *lpBuf) { GlobalUnlock(GLOBALS.hVars); - /* 2. Messaggi */ + /* 2. Messages */ if (lpBuf[0] != 'M' || lpBuf[1] != 'S' || lpBuf[2] != 'G' || lpBuf[3] != 'S') return false; @@ -588,7 +541,7 @@ bool ParseMpc(const byte *lpBuf) { GlobalUnlock(GLOBALS.hMsgs); #endif - /* 3. Oggetti */ + /* 3. Objects */ if (lpBuf[0] != 'O' || lpBuf[1] != 'B' || lpBuf[2] != 'J' || lpBuf[3] != 'S') return false; @@ -596,7 +549,7 @@ bool ParseMpc(const byte *lpBuf) { GLOBALS.nObjs = READ_LE_UINT16(lpBuf); lpBuf += 2; - // Controlla i dialoghi + // Check out the dialogs GLOBALS.nDialogs = 0; GLOBALS.hDialogs = GLOBALS.lpmdDialogs = NULL; if (*((const byte *)lpBuf + 2) == 6 && strncmp((const char *)lpBuf + 3, "Dialog", 6) == 0) { @@ -615,13 +568,13 @@ bool ParseMpc(const byte *lpBuf) { GlobalUnlock(GLOBALS.hDialogs); } - // Controlla gli item + // Check the items GLOBALS.nItems = 0; GLOBALS.hItems = GLOBALS.lpmiItems = NULL; if (*(lpBuf + 2) == 4 && strncmp((const char *)lpBuf + 3, "Item", 4)==0) { GLOBALS.nItems = READ_LE_UINT16(lpBuf); lpBuf += 2; - // Alloca la memoria e li legge + // Allocate memory and read them in GLOBALS.hItems = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)GLOBALS.nItems * sizeof(MPALITEM)); if (GLOBALS.hItems == NULL) return false; @@ -635,13 +588,13 @@ bool ParseMpc(const byte *lpBuf) { GlobalUnlock(GLOBALS.hItems); } - // Controlla le locazioni + // Check the locations GLOBALS.nLocations = 0; GLOBALS.hLocations = GLOBALS.lpmlLocations = NULL; if (*(lpBuf + 2) == 8 && strncmp((const char *)lpBuf + 3, "Location", 8)==0) { GLOBALS.nLocations = READ_LE_UINT16(lpBuf); lpBuf += 2; - // Alloca la memoria e li legge + // Allocate memory and read them in GLOBALS.hLocations=GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)GLOBALS.nLocations*sizeof(MPALLOCATION)); if (GLOBALS.hLocations == NULL) return false; @@ -655,13 +608,13 @@ bool ParseMpc(const byte *lpBuf) { GlobalUnlock(GLOBALS.hLocations); } - // Controlla gli script + // Check the scripts GLOBALS.nScripts = 0; GLOBALS.hScripts = GLOBALS.lpmsScripts = NULL; if (*(lpBuf + 2) == 6 && strncmp((const char *)lpBuf + 3, "Script", 6) == 0) { GLOBALS.nScripts = READ_LE_UINT16(lpBuf); lpBuf += 2; - // Alloca la memoria + // Allocate memory GLOBALS.hScripts = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)GLOBALS.nScripts * sizeof(MPALSCRIPT)); if (GLOBALS.hScripts == NULL) return false; @@ -672,7 +625,7 @@ bool ParseMpc(const byte *lpBuf) { if ((lpBuf = ParseScript(lpBuf + 7, &GLOBALS.lpmsScripts[i])) == NULL) return false; - // Ordina i vari moments dello script + // Sort the various moments of the script //qsort( //GLOBALS.lpmsScripts[i].Moment, //GLOBALS.lpmsScripts[i].nMoments, diff --git a/engines/tony/mpal/loadmpc.h b/engines/tony/mpal/loadmpc.h index 8763fbf95b..6aea3de16b 100644 --- a/engines/tony/mpal/loadmpc.h +++ b/engines/tony/mpal/loadmpc.h @@ -58,20 +58,13 @@ namespace MPAL { * Prototipi di funzione \****************************************************************************/ -/****************************************************************************\ -* -* Function: BOOL ParseMpc(LPBYTE lpBuf); -* -* Description: Legge e interpreta un file MPC, e crea le strutture per le -* varie direttive nelle variabili globali -* -* Input: LPBYTE lpBuf Immagine in memoria del file MPC, -* escluso l'header -* -* Return: TRUE se tutto OK, FALSE in caso di errore. -* -\****************************************************************************/ - +/** + * Reads and interprets the MPC file, and create structures for various directives + * in the global variables + * + * @param lpBuf Buffer containing the MPC file data, excluding the header. + * @returns True if succeeded OK, false if failure. + */ bool ParseMpc(const byte *lpBuf); |