From 6e5f6775d16e9730ccf1edbecf14da52d0ef134a Mon Sep 17 00:00:00 2001
From: Pixel <Pixel>
Date: Thu, 3 May 2001 00:20:43 +0000
Subject: Indentation

---
 lib/pile.c | 759 ++++++++++++++++++++++++++++++++-----------------------------
 1 file changed, 398 insertions(+), 361 deletions(-)

(limited to 'lib/pile.c')

diff --git a/lib/pile.c b/lib/pile.c
index 2920139..6298b92 100644
--- a/lib/pile.c
+++ b/lib/pile.c
@@ -18,461 +18,498 @@ pile_elem result_pile[PILE_MAX];
 unsigned int pile_ptr = 0;
 unsigned int result_pile_ptr = 0;
 
-/* Fonctions basiques sur la pile d'opérandes. Elle seront appelées par le parser. */
+/*
+ * Fonctions basiques sur la pile d'operandes. Elle seront appelees par le parser. 
+ */
 
-/* La fonction push_pile est générique. Le parser lui transmet une chaîne de caractères, et cette
-fonction va tenter de la convertir en ce qui lui semble le mieux pour empiler */
+/*
+ * La fonction push_pile est generique. Le parser lui transmet une chaine de caracteres, et cette
+ * fonction va tenter de la convertir en ce qui lui semble le mieux pour empiler 
+ */
 void push_pile(char *st)
 {
-	int valid1, valid2, valid3;
-	char valid4 = 0;
-	int i_number;
-	rationnel r_number;
-	polynome poly;
-	char buf[128];
-
-	sprintf(buf, _("Calling push_pile(%s)"), st);
-	pushcontext(buf);
-	i_number = char_to_number(st, &valid1);
-	r_number = char_to_rat(st, &valid2);
-	valid3 = is_mute(st);
-	poly = (polynome) NomVarToVar(st, variables, &valid4);
-	if (valid1) {		/* il s'agit d'un entier */
-		pushcontext(_("it's an integer"));
-		push_pile_poly(ply_constr(rat_constr(i_number, 1), 0));
-		popcontext();
-	} else if (valid2) {	/* il s'agit d'un flottant */
-		pushcontext(_("it's a float"));
-		push_pile_poly(ply_constr(r_number, 0));
-		popcontext();
-	} else if (valid3) {	/* il s'agit de x */
-		pushcontext(_("it's X"));
-		push_pile_poly(ply_constr(rat_constr(1, 1), 1));
-		popcontext();
-	} else if (valid4) {	/* il s'agit d'une variable */
-		pushcontext(_("it's a variable"));
-		push_pile_poly(ply_copy(poly));
-		popcontext();
-	} else {		/* il s'agit d'un nom */
-		pushcontext(_("it's a name"));
-		if (*st == '\'') {
-			st++;
-			st[strlen(st) - 1] = 0;
-		}
-		push_pile_string(Estrdup(st));
-		popcontext();
+    int valid1, valid2, valid3;
+    char valid4 = 0;
+    int i_number;
+    rationnel r_number;
+    polynome poly;
+    char buf[128];
+
+    sprintf(buf, _("Calling push_pile(%s)"), st);
+    pushcontext(buf);
+    i_number = char_to_number(st, &valid1);
+    r_number = char_to_rat(st, &valid2);
+    valid3 = is_mute(st);
+    poly = (polynome) NomVarToVar(st, variables, &valid4);
+    if (valid1) {		/*
+				 * il s'agit d'un entier 
+				 */
+	pushcontext(_("it's an integer"));
+	push_pile_poly(ply_constr(rat_constr(i_number, 1), 0));
+	popcontext();
+    } else if (valid2) {	/*
+				 * il s'agit d'un flottant 
+				 */
+	pushcontext(_("it's a float"));
+	push_pile_poly(ply_constr(r_number, 0));
+	popcontext();
+    } else if (valid3) {	/*
+				 * il s'agit de x 
+				 */
+	pushcontext(_("it's X"));
+	push_pile_poly(ply_constr(rat_constr(1, 1), 1));
+	popcontext();
+    } else if (valid4) {	/*
+				 * il s'agit d'une variable 
+				 */
+	pushcontext(_("it's a variable"));
+	push_pile_poly(ply_copy(poly));
+	popcontext();
+    } else {			/*
+				 * il s'agit d'un nom 
+				 */
+	pushcontext(_("it's a name"));
+	if (*st == '\'') {
+	    st++;
+	    st[strlen(st) - 1] = 0;
 	}
+	push_pile_string(Estrdup(st));
 	popcontext();
+    }
+    popcontext();
 #ifdef DEBUG
-	fprintf(stderr, "exiting push_pile\n");
+    fprintf(stderr, "exiting push_pile\n");
 #endif
 }
 
-/* Fonctions "atomiques" appelées par push_pile() */
+/*
+ * Fonctions "atomiques" appelees par push_pile() 
+ */
 
 void push_pile_poly(polynome poly)
 {
-	if (pile_ptr != PILE_MAX) {
-		pile[pile_ptr].type = T_POLY;
-		pile[pile_ptr].poly = poly;
-		pile_ptr++;
-	} else {
-		exception(2, _("push_pile_poly: Stack Overflow"));
-	}
+    if (pile_ptr != PILE_MAX) {
+	pile[pile_ptr].type = T_POLY;
+	pile[pile_ptr].poly = poly;
+	pile_ptr++;
+    } else {
+	exception(2, _("push_pile_poly: Stack Overflow"));
+    }
 }
 
 void push_pile_int(int val)
 {
 
-	if (pile_ptr != PILE_MAX) {
-		pile[pile_ptr].type = T_INT;
-		pile[pile_ptr].val = val;
-		pile_ptr++;
-	} else {
-		exception(2, _("push_pile_int: Stack Overflow"));
-	}
-
+    if (pile_ptr != PILE_MAX) {
+	pile[pile_ptr].type = T_INT;
+	pile[pile_ptr].val = val;
+	pile_ptr++;
+    } else {
+	exception(2, _("push_pile_int: Stack Overflow"));
+    }
 
 }
 
 void push_pile_string(char *st)
 {
-	if (pile_ptr != PILE_MAX) {
-		pile[pile_ptr].type = T_STRING;
-		pile[pile_ptr].label = Estrdup(st);
-		pile_ptr++;
-	} else {
-		exception(2, _("push_pile_string: Stack Overflow"));
-	}
-
+    if (pile_ptr != PILE_MAX) {
+	pile[pile_ptr].type = T_STRING;
+	pile[pile_ptr].label = Estrdup(st);
+	pile_ptr++;
+    } else {
+	exception(2, _("push_pile_string: Stack Overflow"));
+    }
 
 }
 
-/* Dépilement */
+/*
+ * Depilement 
+ */
 
 pile_elem pop_pile(unsigned int count)
 {
-	char buf[50];
-
-	if (((int) (pile_ptr) - (int) count) >= 0) {
-		pile_ptr -= count;
-	} else {
-		sprintf(buf, _("pop_pile: Can't pop %u elements"), count);
-		exception(2, buf);
-	}
-	return pile[pile_ptr];
+    char buf[50];
+
+    if (((int) (pile_ptr) - (int) count) >= 0) {
+	pile_ptr -= count;
+    } else {
+	sprintf(buf, _("pop_pile: Can't pop %u elements"), count);
+	exception(2, buf);
+    }
+    return pile[pile_ptr];
 }
 
-/* Vidage (appelée en cas d'erreur) */
+/*
+ * Vidage (appelee en cas d'erreur) 
+ */
 
 void flush_pile(void)
 {
-	int i;
-
-	if (pile_ptr) {
-		for (i = 0; i <= pile_ptr - 1; i++) {
-			switch (pile[i].type) {
-			case T_INT:
-				break;
-			case T_STRING:
-				free(pile[i].label);
-				break;
-			case T_POLY:
-				ply_destruct(pile[i].poly);
-				break;
-			}
-		}
+    int i;
+
+    if (pile_ptr) {
+	for (i = 0; i <= pile_ptr - 1; i++) {
+	    switch (pile[i].type) {
+	    case T_INT:
+		break;
+	    case T_STRING:
+		free(pile[i].label);
+		break;
+	    case T_POLY:
+		ply_destruct(pile[i].poly);
+		break;
+	    }
 	}
-	pile_ptr=0;
+    }
+    pile_ptr = 0;
 }
 
-
-
-/* Fonctions basiques sur la pile de resultats. Grâce à cette pile résultat, nous pouvons passer un résultat
-à l'interface, dès que le parser aura terminé son travail. */
+/*
+ * Fonctions basiques sur la pile de resultats. Grace a cette pile resultat, nous pouvons passer un 
+ * resultat a l'interface, des que le parser aura termine son travail. 
+ */
 
 void move_to_resultat_pile(void)
-{	pile_elem temp;
-	char valid;
-	polynome t;
-
-	pushcontext(_("move_to_resultat_pile()"));
-	if (pile_ptr) {
-		temp=pop_pile(1);
-		if (result_pile_ptr!=PILE_MAX) {
-			if (temp.type==T_POLY) {
-				result_pile[result_pile_ptr]=temp;
-				result_pile_ptr++;
-				t = NomVarToVar("ANS", variables, &valid);
-				if (valid) {
-					ply_destruct(t);
-					SupprimerDansTab(&variables, "ANS");
-				}
-				InsererVarDansTab(&variables, CreerElement("ANS", (void *) (ply_copy(temp.poly))));
-			} else {
-				exception(1, _("move_to_resultat_pile: invalid argument type"));
-			}
-		} else {
-			exception(2, _("move_to_resultat_pile: Stack Overflow"));
+{
+    pile_elem temp;
+    char valid;
+    polynome t;
+
+    pushcontext(_("move_to_resultat_pile()"));
+    if (pile_ptr) {
+	temp = pop_pile(1);
+	if (result_pile_ptr != PILE_MAX) {
+	    if (temp.type == T_POLY) {
+		result_pile[result_pile_ptr] = temp;
+		result_pile_ptr++;
+		t = NomVarToVar("ANS", variables, &valid);
+		if (valid) {
+		    ply_destruct(t);
+		    SupprimerDansTab(&variables, "ANS");
 		}
+		InsererVarDansTab(&variables, CreerElement("ANS", (void *) (ply_copy(temp.poly))));
+	    } else {
+		exception(1, _("move_to_resultat_pile: invalid argument type"));
+	    }
+	} else {
+	    exception(2, _("move_to_resultat_pile: Stack Overflow"));
 	}
-	popcontext();
+    }
+    popcontext();
 }
 
-char * pop_resultat(void)
-{	static char result[BUFSIZ];
-
-	pushcontext(_("pop_resultat()"));
-	if (result_pile_ptr) {
-		result_pile_ptr--;
-		sprintf(result,"%s", ply_affichage(result_pile[result_pile_ptr].poly));
-	} else {
-		exception(2, _("move_to_resultat_pile: empty stack"));
-	}
-	popcontext();
-	return result;
+char *pop_resultat(void)
+{
+    static char result[BUFSIZ];
+
+    pushcontext(_("pop_resultat()"));
+    if (result_pile_ptr) {
+	result_pile_ptr--;
+	sprintf(result, "%s", ply_affichage(result_pile[result_pile_ptr].poly));
+    } else {
+	exception(2, _("move_to_resultat_pile: empty stack"));
+    }
+    popcontext();
+    return result;
 }
 
 polynome return_last(int *valid)
 {
-	if (!result_pile_ptr) {
-		*valid=0;
-		return NULL;
-	} else {
-		*valid=1;
-		return result_pile[result_pile_ptr--].poly;
-	}	
+    if (!result_pile_ptr) {
+	*valid = 0;
+	return NULL;
+    } else {
+	*valid = 1;
+	return result_pile[result_pile_ptr--].poly;
+    }
 
 }
-	
-int has_resultat(void) {
-	return (result_pile_ptr ? 1 : 0);
+
+int has_resultat(void)
+{
+    return (result_pile_ptr ? 1 : 0);
 }
 
-/* Fonctions avancées sur la pile d'opérandes. Nous allons surtout manipuler les opérandes de la pile, à l'aide
-des opérateurs que le parser nous enverra. */
+/*
+ * Fonctions avancees sur la pile d'operandes. Nous allons surtout manipuler les operandes de la
+ * pile, a l'aide des operateurs que le parser nous enverra. 
+ */
 
 char *affichage_level_1(void)
 {
-	char *result = NULL;
-
-	if (pile_ptr) {
-		switch (pile[pile_ptr - 1].type) {
-		case T_POLY:
-			result = ply_affichage(pile[pile_ptr - 1].poly);
-			break;
-		case T_STRING:
-			result = pile[pile_ptr - 1].label;
-			break;
-		case T_INT:
-			result = (char *) Emalloc(11 * sizeof(char));
-			sprintf(result, "%10d", pile[pile_ptr - 1].val);
-			break;
-		}
+    char *result = NULL;
+
+    if (pile_ptr) {
+	switch (pile[pile_ptr - 1].type) {
+	case T_POLY:
+	    result = ply_affichage(pile[pile_ptr - 1].poly);
+	    break;
+	case T_STRING:
+	    result = pile[pile_ptr - 1].label;
+	    break;
+	case T_INT:
+	    result = (char *) Emalloc(11 * sizeof(char));
+
+	    sprintf(result, "%10d", pile[pile_ptr - 1].val);
+	    break;
 	}
-	return result;
+    }
+    return result;
 }
 
 int is_mute(char *st)
 {
 
-	return !(strcmp(st, mute));
+    return !(strcmp(st, mute));
 }
 
-/* Cette fonction est appelée par le parser, et est donc un énorme switch qui va tester l'opérateur passé en paramètre */
+/*
+ * Cette fonction est appelee par le parser, et est donc un enorme switch qui va tester l'operateur 
+ * passe en parametre 
+ */
 void act_pile(int func)
 {
-	pile_elem operande1, operande2;
-	pile_elem operande[3];
-	char buf[50];
-	char valid;
-	int i, err=0;
-
-	sprintf(buf, _("Calling act_pile(%i)"), func);
-	pushcontext(buf);
+    pile_elem operande1, operande2;
+    pile_elem operande[3];
+    char buf[50];
+    char valid;
+    int i, err = 0;
+
+    sprintf(buf, _("Calling act_pile(%i)"), func);
+    pushcontext(buf);
 #ifdef DEBUG
-	affichage_pile();
+    affichage_pile();
 #endif
-	switch (func) {
-	case OP_PLUS:
+    switch (func) {
+    case OP_PLUS:
 #ifdef DEBUG
-		printf("----- OP_PLUS\n");
+	printf("----- OP_PLUS\n");
 #endif
-		operande1 = pop_pile(1);
-		operande2 = pop_pile(1);
-		if ((operande1.type == T_POLY) && (operande2.type == T_POLY)) {
-			push_pile_poly(ply_addition(operande1.poly, operande2.poly));
-			if (operande1.poly)
-				ply_destruct(operande1.poly);
-			if (operande2.poly)
-				ply_destruct(operande2.poly);
-		} else {
-			exception(1, _("act_pile: OP_PLUS invalid arguments"));
-		}
-		break;
-	case OP_MOINS:
+	operande1 = pop_pile(1);
+	operande2 = pop_pile(1);
+	if ((operande1.type == T_POLY) && (operande2.type == T_POLY)) {
+	    push_pile_poly(ply_addition(operande1.poly, operande2.poly));
+	    if (operande1.poly)
+		ply_destruct(operande1.poly);
+	    if (operande2.poly)
+		ply_destruct(operande2.poly);
+	} else {
+	    exception(1, _("act_pile: OP_PLUS invalid arguments"));
+	}
+	break;
+    case OP_MOINS:
 #ifdef DEBUG
-		printf("----- OP_MOINS\n");
+	printf("----- OP_MOINS\n");
 #endif
-		operande2 = pop_pile(1);
-		operande1 = pop_pile(1);
-		if ((operande1.type == T_POLY) && (operande2.type == T_POLY)) {
-			push_pile_poly(ply_soustraction(operande1.poly, operande2.poly));
-			if (operande1.poly)
-				ply_destruct(operande1.poly);
-			if (operande2.poly)
-				ply_destruct(operande2.poly);
-		} else {
-			exception(1, _("act_pile: OP_MOINS invalid arguments"));
-		}
-		break;
-	case OP_MUL:
+	operande2 = pop_pile(1);
+	operande1 = pop_pile(1);
+	if ((operande1.type == T_POLY) && (operande2.type == T_POLY)) {
+	    push_pile_poly(ply_soustraction(operande1.poly, operande2.poly));
+	    if (operande1.poly)
+		ply_destruct(operande1.poly);
+	    if (operande2.poly)
+		ply_destruct(operande2.poly);
+	} else {
+	    exception(1, _("act_pile: OP_MOINS invalid arguments"));
+	}
+	break;
+    case OP_MUL:
 #ifdef DEBUG
-		printf("----- OP_MUL\n");
+	printf("----- OP_MUL\n");
 #endif
-		operande1 = pop_pile(1);
-		operande2 = pop_pile(1);
-		if ((operande1.type == T_POLY) && (operande2.type == T_POLY)) {
-			push_pile_poly(ply_multiplication(operande1.poly, operande2.poly));
-			if (operande1.poly)
-				ply_destruct(operande1.poly);
-			if (operande2.poly)
-				ply_destruct(operande2.poly);
-		} else {
-			exception(1, _("act_pile: OP_MUL invalid arguments"));
-		}
-		break;
-	case OP_DIV:
+	operande1 = pop_pile(1);
+	operande2 = pop_pile(1);
+	if ((operande1.type == T_POLY) && (operande2.type == T_POLY)) {
+	    push_pile_poly(ply_multiplication(operande1.poly, operande2.poly));
+	    if (operande1.poly)
+		ply_destruct(operande1.poly);
+	    if (operande2.poly)
+		ply_destruct(operande2.poly);
+	} else {
+	    exception(1, _("act_pile: OP_MUL invalid arguments"));
+	}
+	break;
+    case OP_DIV:
 #ifdef DEBUG
-		printf("----- OP_DIV\n");
+	printf("----- OP_DIV\n");
 #endif
-		operande2 = pop_pile(1);
-		operande1 = pop_pile(1);
-		if ((operande1.type == T_POLY) && (operande2.type == T_POLY)) {
-			push_pile_poly(ply_division(operande1.poly, operande2.poly));
-			if (operande1.poly)
-				ply_destruct(operande1.poly);
-			if (operande2.poly)
-				ply_destruct(operande2.poly);
-		} else {
-			exception(1, _("act_pile: OP_DIV invalid arguments"));
-		}
-		break;
-	case OP_MOD:
+	operande2 = pop_pile(1);
+	operande1 = pop_pile(1);
+	if ((operande1.type == T_POLY) && (operande2.type == T_POLY)) {
+	    push_pile_poly(ply_division(operande1.poly, operande2.poly));
+	    if (operande1.poly)
+		ply_destruct(operande1.poly);
+	    if (operande2.poly)
+		ply_destruct(operande2.poly);
+	} else {
+	    exception(1, _("act_pile: OP_DIV invalid arguments"));
+	}
+	break;
+    case OP_MOD:
 #ifdef DEBUG
-		printf("----- OP_MOD\n");
+	printf("----- OP_MOD\n");
 #endif
-		operande2 = pop_pile(1);
-		operande1 = pop_pile(1);
-		if ((operande1.type == T_POLY) && (operande2.type == T_POLY)) {
-			push_pile_poly(ply_modulo(operande1.poly, operande2.poly));
-			if (operande1.poly)
-				ply_destruct(operande1.poly);
-			if (operande2.poly)
-				ply_destruct(operande2.poly);
-		} else {
-			exception(1, _("act_pile: OP_MOD invalid arguments"));
-		}
-		break;
-	case OP_EXP:
+	operande2 = pop_pile(1);
+	operande1 = pop_pile(1);
+	if ((operande1.type == T_POLY) && (operande2.type == T_POLY)) {
+	    push_pile_poly(ply_modulo(operande1.poly, operande2.poly));
+	    if (operande1.poly)
+		ply_destruct(operande1.poly);
+	    if (operande2.poly)
+		ply_destruct(operande2.poly);
+	} else {
+	    exception(1, _("act_pile: OP_MOD invalid arguments"));
+	}
+	break;
+    case OP_EXP:
 #ifdef DEBUG
-		printf("----- OP_EXP\n");
+	printf("----- OP_EXP\n");
 #endif
-		operande1 = pop_pile(1);
-		operande2 = pop_pile(1);
-		if ((operande1.type == T_POLY) && (operande2.type == T_POLY)) {
-			if (operande1.poly) {
-				if ((operande1.poly->coef.denom == 1)
-				    && (operande1.poly->coef.num >= 0)) {
-					push_pile_poly(ply_exposant(operande2.poly, operande1.poly->coef.num));
-					if (operande2.poly)
-						ply_destruct(operande2.poly);
-					ply_destruct(operande1.poly);
-				} else {
-					exception(1, _("act_pile: OP_EXP invalid power"));
-				}
-			} else {
-				push_pile_poly(ply_constr(rat_constr(1,1),0));
-				if (operande2.poly)
-					ply_destruct(operande2.poly);		
-			}
+	operande1 = pop_pile(1);
+	operande2 = pop_pile(1);
+	if ((operande1.type == T_POLY) && (operande2.type == T_POLY)) {
+	    if (operande1.poly) {
+		if ((operande1.poly->coef.denom == 1)
+		    && (operande1.poly->coef.num >= 0)) {
+		    push_pile_poly(ply_exposant(operande2.poly, operande1.poly->coef.num));
+		    if (operande2.poly)
+			ply_destruct(operande2.poly);
+		    ply_destruct(operande1.poly);
 		} else {
-			exception(1, _("act_pile: OP_EXP invalid arguments"));
+		    exception(1, _("act_pile: OP_EXP invalid power"));
 		}
-		break;
-	case OP_ASSIGN:
+	    } else {
+		push_pile_poly(ply_constr(rat_constr(1, 1), 0));
+		if (operande2.poly)
+		    ply_destruct(operande2.poly);
+	    }
+	} else {
+	    exception(1, _("act_pile: OP_EXP invalid arguments"));
+	}
+	break;
+    case OP_ASSIGN:
 #ifdef DEBUG
-		printf("----- OP_ASSIGN\n");
+	printf("----- OP_ASSIGN\n");
 #endif
-		operande1 = pop_pile(1);
-		operande2 = pop_pile(1);
-		if ((operande1.type == T_POLY) && (operande2.type == T_STRING)) {
-			if (operande2.label) {
-				NomVarToVar(operande2.label, variables, &valid);
-				if (valid)
-					SupprimerDansTab(&variables,operande2.label);
-				InsererVarDansTab(&variables, CreerElement(operande2.label, (void *) operande1.poly));
-				push_pile(operande2.label);
-				free(operande2.label);
-			} else {
-				exception(1, _("act_pile: OP_ASSIGN empty string"));
-			}
-		} else {
-			exception(1, _("act_pile: OP_ASSIGN invalid arguments"));
-		}
-		break;
-	case OP_PLUS_UNARY:
+	operande1 = pop_pile(1);
+	operande2 = pop_pile(1);
+	if ((operande1.type == T_POLY) && (operande2.type == T_STRING)) {
+	    if (operande2.label) {
+		NomVarToVar(operande2.label, variables, &valid);
+		if (valid)
+		    SupprimerDansTab(&variables, operande2.label);
+		InsererVarDansTab(&variables,
+				  CreerElement(operande2.label, (void *) operande1.poly));
+		push_pile(operande2.label);
+		free(operande2.label);
+	    } else {
+		exception(1, _("act_pile: OP_ASSIGN empty string"));
+	    }
+	} else {
+	    exception(1, _("act_pile: OP_ASSIGN invalid arguments"));
+	}
+	break;
+    case OP_PLUS_UNARY:
 #ifdef DEBUG
-		printf("----- OP_PLUS_UNARY\n");
+	printf("----- OP_PLUS_UNARY\n");
 #endif
-		break;
-	case OP_MOINS_UNARY:
+	break;
+    case OP_MOINS_UNARY:
 #ifdef DEBUG
-		printf("----- OP_MOINS_UNARY\n");
+	printf("----- OP_MOINS_UNARY\n");
 #endif
-		operande1 = pop_pile(1);
-		if (operande1.type == T_POLY) {
-			push_pile_poly(ply_soustraction(ply_constr(rat_constr_zero(), 0), operande1.poly));
-			if (operande1.poly)
-				ply_destruct(operande1.poly);
-		} else {
-			exception(1, _("act_pile: OP_MOINS_UNARY invalid argument"));
-		}
-		break;
-	case OP_FUNC_CALL:
+	operande1 = pop_pile(1);
+	if (operande1.type == T_POLY) {
+	    push_pile_poly(ply_soustraction(ply_constr(rat_constr_zero(), 0), operande1.poly));
+	    if (operande1.poly)
+		ply_destruct(operande1.poly);
+	} else {
+	    exception(1, _("act_pile: OP_MOINS_UNARY invalid argument"));
+	}
+	break;
+    case OP_FUNC_CALL:
 #ifdef DEBUG
-		printf("----- OP_FUNC_CALL\n");
+	printf("----- OP_FUNC_CALL\n");
 #endif
-		for (i=0;i<3;i++)
-			operande[i].poly=NULL;
-		operande1 = pop_pile(1);
-		if (operande1.type == T_INT) {
-			for(i=0;i<operande1.val;i++) {
-				operande[i] = pop_pile(1);	
-				if (operande[i].type != T_POLY)
-					err=1;
-			}
-			if (err==1) {
-				exception(1,_("act_pile: OP_FUNC_CALL incorrect argument type"));
-				return;
-			}
-			operande2=pop_pile(1); /* on recupere le polynome a evaluer ou le nom de la fonction a executer */
-			switch (operande2.type) {
-			case T_INT:
-				exception(2,_("act_pile: OP_FUNC_CALL invalid operand type"));
-				break;
-			case T_POLY:
-				if (operande2.poly) {
-					if (operande1.val != 1) {
-						exception(1, _("act_pile: OP_FUNC_CALL need only one argument for a polynom evaluation"));
-					}
-					if (operande[0].poly->degre == 0) {
-						push_pile_poly(ply_constr(ply_valuation(operande2.poly, operande[0].poly->coef), 0));
-						if (operande[0].poly)
-							ply_destruct(operande[0].poly);
-						ply_destruct(operande2.poly);
-					} else {
-						exception(1, _("act_pile: OP_FUNC_CALL incorrect value for 2nd arg"));
-					}
-				} else {
-					exception(1, _("act_pile: OP_FUNC_CALL arg2 is an empty polynom"));
-				}
-				break;
-			case T_STRING:		
-				appel_fonction(operande2.label,operande1.val,operande[0].poly, operande[1].poly, operande[2].poly);
-				break;
-			}				
-			
+	for (i = 0; i < 3; i++)
+	    operande[i].poly = NULL;
+	operande1 = pop_pile(1);
+	if (operande1.type == T_INT) {
+	    for (i = 0; i < operande1.val; i++) {
+		operande[i] = pop_pile(1);
+		if (operande[i].type != T_POLY)
+		    err = 1;
+	    }
+	    if (err == 1) {
+		exception(1, _("act_pile: OP_FUNC_CALL incorrect argument type"));
+		return;
+	    }
+	    operande2 = pop_pile(1);	/*
+					 * on recupere le polynome a evaluer ou le nom de la
+					 * fonction a executer 
+					 */
+	    switch (operande2.type) {
+	    case T_INT:
+		exception(2, _("act_pile: OP_FUNC_CALL invalid operand type"));
+		break;
+	    case T_POLY:
+		if (operande2.poly) {
+		    if (operande1.val != 1) {
+			exception(1,
+				  _
+				  ("act_pile: OP_FUNC_CALL need only one argument for a polynom evaluation"));
+		    }
+		    if (operande[0].poly->degre == 0) {
+			push_pile_poly(ply_constr
+				       (ply_valuation(operande2.poly, operande[0].poly->coef), 0));
+			if (operande[0].poly)
+			    ply_destruct(operande[0].poly);
+			ply_destruct(operande2.poly);
+		    } else {
+			exception(1, _("act_pile: OP_FUNC_CALL incorrect value for 2nd arg"));
+		    }
 		} else {
-			exception(1, _("act_pile: OP_FUNC_CALL incorrect argument number"));
+		    exception(1, _("act_pile: OP_FUNC_CALL arg2 is an empty polynom"));
 		}
 		break;
-	default:
-		exception(1, _("act_pile: Unknown operator"));
+	    case T_STRING:
+		appel_fonction(operande2.label, operande1.val, operande[0].poly, operande[1].poly,
+			       operande[2].poly);
+		break;
+	    }
+
+	} else {
+	    exception(1, _("act_pile: OP_FUNC_CALL incorrect argument number"));
 	}
-	popcontext();
+	break;
+    default:
+	exception(1, _("act_pile: Unknown operator"));
+    }
+    popcontext();
 }
 
-/* Fonction de déboguage uniquement */
+/*
+ * Fonction de deboguage uniquement 
+ */
 void affichage_pile(void)
 {
-	int i;
-
-	printf(_("\t-- Printing Stack\n"));
-	if (pile_ptr) {
-		for (i = 0; i <= pile_ptr - 1; i++) {
-			switch (pile[i].type) {
-			case T_INT:
-				printf("\t\t%d:I: %d\n", i, pile[i].val);
-				break;
-			case T_STRING:
-				printf("\t\t%d:S: %s\n", i, pile[i].label);
-				break;
-			case T_POLY:
-				printf("\t\t%d:P: %s\n", i, ply_affichage(pile[i].poly));
-				break;
-			}
-		}
+    int i;
+
+    printf(_("\t-- Printing Stack\n"));
+    if (pile_ptr) {
+	for (i = 0; i <= pile_ptr - 1; i++) {
+	    switch (pile[i].type) {
+	    case T_INT:
+		printf("\t\t%d:I: %d\n", i, pile[i].val);
+		break;
+	    case T_STRING:
+		printf("\t\t%d:S: %s\n", i, pile[i].label);
+		break;
+	    case T_POLY:
+		printf("\t\t%d:P: %s\n", i, ply_affichage(pile[i].poly));
+		break;
+	    }
 	}
-	printf(_("\t-- End Printing Stack\n"));
+    }
+    printf(_("\t-- End Printing Stack\n"));
 }
-- 
cgit v1.2.3