path: root/lib/pile.c

/*
 *
 * Gestion de la pile des operandes
 *
 */
#include <stdlib.h>
#include "pile.h"
#include "exceptions.h"
#include "numbers.h"
#include "main.h"
#include "parser.h"
#include "scalaires.h"
#include "config.h"
#include "fonctions.h"

pile_elem pile[PILE_MAX];
pile_elem result_pile[PILE_MAX];
unsigned int pile_ptr = 0;
unsigned int result_pile_ptr = 0;

/*
 * Fonctions basiques sur la pile d'operandes. Elle seront appelees par le parser. 
 */

/*
 * 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();
    }
    popcontext();
#ifdef DEBUG
    fprintf(stderr, "exiting push_pile\n");
#endif
}

/*
 * 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"));
    }
}

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

}

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

}

/*
 * 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];
}

/*
 * 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;
	    }
	}
    }
    pile_ptr = 0;
}

/*
 * 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"));
	}
    }
    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;
}

polynome return_last(int *valid)
{
    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);
}

/*
 * 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;
	}
    }
    return result;
}

int is_mute(char *st)
{

    return !(strcmp(st, mute));
}

/*
 * 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);
#ifdef DEBUG
    affichage_pile();
#endif
    switch (func) {
    case OP_PLUS:
#ifdef DEBUG
	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:
#ifdef DEBUG
	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:
#ifdef DEBUG
	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:
#ifdef DEBUG
	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:
#ifdef DEBUG
	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:
#ifdef DEBUG
	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);
	    }
	} else {
	    exception(1, _("act_pile: OP_EXP invalid arguments"));
	}
	break;
    case OP_ASSIGN:
#ifdef DEBUG
	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:
#ifdef DEBUG
	printf("----- OP_PLUS_UNARY\n");
#endif
	break;
    case OP_MOINS_UNARY:
#ifdef DEBUG
	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:
#ifdef DEBUG
	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) {
			if (operande[0].poly->degre == 0) {
			    push_pile_poly(ply_constr
				    	   (ply_valuation(operande2.poly, operande[0].poly->coef), 0));
			    ply_destruct(operande[0].poly);
			    ply_destruct(operande2.poly);
			} else {
			    exception(1, _("act_pile: OP_FUNC_CALL incorrect value for 2nd arg"));
			}
		    } else {
			push_pile_poly(ply_constr(ply_valuation(operande2.poly, rat_constr_zero()), 0));
			ply_destruct(operande2.poly);
		    }
		} 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;
	    }

	} else {
	    exception(1, _("act_pile: OP_FUNC_CALL incorrect argument number"));
	}
	break;
    default:
	exception(1, _("act_pile: Unknown operator"));
    }
    popcontext();
}

/*
 * 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;
	    }
	}
    }
    printf(_("\t-- End Printing Stack\n"));
}