diff options
Diffstat (limited to 'lib/pile.c')
| -rw-r--r-- | lib/pile.c | 759 |
1 files changed, 398 insertions, 361 deletions
@@ -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")); } |