TONY: Converting comments to English and formatting

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);