/* ================================================================================ RPL/2 (R) version 4.1.32 Copyright (C) 1989-2020 Dr. BERTRAND Joël This file is part of RPL/2. RPL/2 is free software; you can redistribute it and/or modify it under the terms of the CeCILL V2 License as published by the french CEA, CNRS and INRIA. RPL/2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License for more details. You should have received a copy of the CeCILL License along with RPL/2. If not, write to info@cecill.info. ================================================================================ */ #include "rpl-conv.h" /* ================================================================================ Fonction 'derivation' ================================================================================ Entrées : pointeur sur une structure struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void derivation(struct_processus *s_etat_processus, struct_objet **s_expression) { /* * Faire le calcul directement sur l'expression RPN. Mettre les * pointeurs dans une pile pour pouvoir circuler dans l'autre sens. * << 2 X * >> -> << 2 X * X DER >> * -> << 2 X DER X * 2 X X DER * + >> -> << 0 X * 2 1 * + >> * -> << 2 >> * * << X 2 * 3 + COS >> -> << X 2 * 3 + COS X DER >> * -> << X 2 * 3 + SIN NEG X 2 * 3 + X DER * >> * * Prévoir la simplification des expressions faite par une évaluation * symbolique ('E'). */ integer8 derivee; logical1 derivee_fonction_disponible; logical1 drapeau; logical1 fin_boucle; static unsigned char *fonctions[] = { "ABS", "1", NULL, "FCT", "SIGN", "1", NULL, "ARG", "1", NULL, "FCT", "INV", "1", "FCT", "DUP", "1", "FCT", "CONJ", "1", "FCT", "-", "0", "INT", "2", "0", "NOM", "i", "0", "FCT", "*", "0", "FCT", "/", "0", NULL, "ACOS", "1", NULL, "INT", "1", "0", "FCT", "SWAP", "2", "FCT", "SQ", "1", "FCT", "-", "0", "FCT", "SQRT", "1", "FCT", "INV", "1", "FCT", "NEG", "1", NULL, "ACOSH", "1", NULL, "FCT", "DUP", "1", "INT", "1", "0", "FCT", "-", "0", "FCT", "SQRT", "1", "FCT", "SWAP", "1", "INT", "1", "0", "FCT", "+", "0", "FCT", "SQRT", "1", "FCT", "*", "0", "FCT", "INV", "1", NULL, "ALOG", "1", NULL, "FCT", "ALOG", "1", "INT", "10", "0", "FCT", "LN", "1", "FCT", "*", "0", NULL, "ASIN", "1", NULL, "INT", "1", "0", "FCT", "SWAP", "2", "FCT", "SQ", "1", "FCT", "-", "0", "FCT", "SQRT", "1", "FCT", "INV", "1", NULL, "ASINH", "1", NULL, "FCT", "SQ", "1", "INT", "1", "0", "FCT", "SWAP", "2", "FCT", "+", "0", "FCT", "SQRT", "1", "FCT", "INV", "1", NULL, "ATAN", "1", NULL, "INT", "1", "0", "FCT", "SWAP", "2", "FCT", "SQ", "1", "FCT", "+", "0", "FCT", "INV", "1", NULL, "ATANH", "1", NULL, "FCT", "SQ", "1", "INT", "1", "0", "FCT", "SWAP", "2", "FCT", "-", "0", "FCT", "INV", "1", NULL, "CONJ", "1", NULL, "FCT", "SWAP", "2", "FCT", "DROP", "1", "DER", "0", "0", "FCT", "CONJ", "1", "INT", "1", "0", NULL, "COS", "1", NULL, "FCT", "SIN", "1", "FCT", "NEG", "1", NULL, "COSH", "1", NULL, "FCT", "SINH", "1", NULL, "EXP", "1", NULL, "FCT", "EXP", "1", NULL, "EXPM", "1", NULL, "FCT", "EXP", "1", NULL, "IM", "1", NULL, "FCT", "SWAP", "2", "FCT", "DROP", "1", "DER", "0", "0", "FCT", "IM", "1", "INT", "1", "0", NULL, "INV", "1", NULL, "FCT", "SQ", "1", "FCT", "INV", "1", "FCT", "NEG", "1", NULL, "LN", "1", NULL, "FCT", "INV", "1", NULL, "LNP1", "1", NULL, "INT", "1", "0", "FCT", "+", "0", "FCT", "INV", "1", NULL, "LOG", "1", NULL, "INT", "10", "0", "FCT", "LN", "1", "FCT", "*", "0", "FCT", "INV", "1", NULL, "NEG", "1", NULL, "FCT", "SWAP", "2", "FCT", "DROP", "1", "DER", "0", "0", "FCT", "NEG", "1", "INT", "1", "0", NULL, "RE", "1", NULL, "FCT", "SWAP", "2", "FCT", "DROP", "1", "DER", "0", "0", "FCT", "RE", "1", "INT", "1", "0", NULL, "RELAX", "1", NULL, "FCT", "DROP", "1", "INT", "1", "0", NULL, "SIN", "1", NULL, "FCT", "COS", "1", NULL, "SINH", "1", NULL, "FCT", "COSH", "1", NULL, "SQ", "1", NULL, "INT", "2", "0", "FCT", "*", "0", NULL, "SQRT", "1", NULL, "FCT", "SQRT", "1", "INT", "2", "0", "FCT", "*", "0", "FCT", "INV", "1", NULL, "TAN", "1", NULL, "INT", "1", "0", "FCT", "SWAP", "2", "FCT", "TAN", "1", "FCT", "SQ", "1", "FCT", "+", "0", NULL, "TANH", "1", NULL, "FCT", "COSH", "1", "FCT", "SQ", "1", "FCT", "INV", "1", NULL, "XROOT", "2", NULL, "FCT", "INV", "1", "FCT", "**", "0", "DER", "0", "0", NULL, "=" , "0", NULL, "FCT", "SWAP", "2", "FCT", "DROP", "1", "FCT", "SWAP", "2", "DER", "0", "0", "FCT", "SWAP", "2", "DER", "0", "0", "FCT", "=", "0", "INT", "1", "0", NULL, NULL }; struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_suivant; struct_objet *s_copie; struct_objet *s_expression_courante; unsigned char *tampon; unsigned char *variable; unsigned long i; unsigned long position_courante; unsigned long type_operation; if ((s_copie = copie_objet(s_etat_processus, *s_expression, 'O')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } liberation(s_etat_processus, *s_expression); *s_expression = s_copie; s_expression_courante = *s_expression; do { /* * Recherche de la première occurrence de la fonction DER */ l_element_courant = (struct_liste_chainee *) (*s_expression_courante).objet; position_courante = 0; drapeau = d_faux; while((l_element_courant != NULL) && (drapeau == d_faux)) { if ((*(*l_element_courant).donnee).type == FCT) { if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DER") == 0) { drapeau = d_vrai; } } l_element_courant = (*l_element_courant).suivant; if (drapeau == d_faux) { position_courante++; } } l_element_courant = (struct_liste_chainee *) (*s_expression_courante).objet; for(i = 0; i < (position_courante - 2); i++, l_element_courant = (*l_element_courant).suivant); variable = (*((struct_nom *) (*(*(*l_element_courant).suivant) .donnee).objet)).nom; /* * Recherche du type d'objet à dériver */ if (((*(*l_element_courant).donnee).type == INT) || ((*(*l_element_courant).donnee).type == REL) || ((*(*l_element_courant).donnee).type == CPL)) { l_element_suivant = (*(*(*l_element_courant).suivant) .suivant).suivant; liberation(s_etat_processus, (*l_element_courant).donnee); liberation(s_etat_processus, (*(*l_element_courant).suivant).donnee); liberation(s_etat_processus, (*(*(*l_element_courant).suivant).suivant).donnee); free((*(*l_element_courant).suivant).suivant); free((*l_element_courant).suivant); (*l_element_courant).suivant = l_element_suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, INT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*(*l_element_courant).donnee).objet)) = 0; } else if ((*(*l_element_courant).donnee).type == NOM) { l_element_suivant = (*(*(*l_element_courant).suivant) .suivant).suivant; if (strcmp((*((struct_nom *) (*(*l_element_courant).donnee).objet)) .nom, variable) == 0) { derivee = 1; } else { derivee = 0; } liberation(s_etat_processus, (*l_element_courant).donnee); liberation(s_etat_processus, (*(*l_element_courant).suivant).donnee); liberation(s_etat_processus, (*(*(*l_element_courant).suivant).suivant).donnee); free((*(*l_element_courant).suivant).suivant); free((*l_element_courant).suivant); (*l_element_courant).suivant = l_element_suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, INT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*(*l_element_courant).donnee).objet)) = derivee; } else if ((*(*l_element_courant).donnee).type == FCT) { if ((strcmp((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "+") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction, "-") == 0)) { if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "+") == 0) { // Opération à dériver : '+' type_operation = 0; } else { // Opération à dériver : '-' type_operation = 1; } /* * Transormer << + X DER >> en << SWAP X DER SWAP X DER + >> * ou << - X DER >> en << SWAP X DER SWAP X DER - >> */ // Transformation du '+' en SWAP l_element_suivant = (*l_element_courant).suivant; free((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction); if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "SWAP"); (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).fonction = instruction_swap; // Ajout de la variable de dérivation if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, NOM)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom = malloc((strlen(variable) + 1) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom, variable); (*((struct_nom *) (*(*l_element_courant).donnee).objet)) .symbole = d_vrai; // Ajout de la fonction DER if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DER"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 2; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_der; // Ajout de la fonction SWAP if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "SWAP"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_swap; // Ajout de la variable de dérivation if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, NOM)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom = malloc((strlen(variable) + 1) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom, variable); (*((struct_nom *) (*(*l_element_courant).donnee).objet)) .symbole = d_vrai; // Ajout de la fonction DER if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DER"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 2; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_der; (*l_element_courant).suivant = (*l_element_suivant).suivant; liberation(s_etat_processus, (*l_element_suivant).donnee); free(l_element_suivant); // Ajout de l'opérateur l_element_courant = (*l_element_courant).suivant; free((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction); if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, (type_operation == 0) ? "+" : "-"); (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).fonction = (type_operation == 0) ? instruction_plus : instruction_moins; } else if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "*") == 0) { /* * Transormer << * X DER >> en * << DUP2 X DER * ROT X DER ROT * + >> */ // Transformation du '*' en DUP2 l_element_suivant = (*l_element_courant).suivant; free((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction); if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DUP2"); (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).fonction = instruction_dup2; // Ajout de la variable de dérivation if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, NOM)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom = malloc((strlen(variable) + 1) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom, variable); (*((struct_nom *) (*(*l_element_courant).donnee).objet)) .symbole = d_vrai; // Ajout de la fonction DER if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DER"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 2; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_der; // Ajout de la fonction '*' if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "*"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_multiplication; // Ajout de la fonction ROT if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "ROT"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_rot; // Ajout de la variable de dérivation if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, NOM)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom = malloc((strlen(variable) + 1) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom, variable); (*((struct_nom *) (*(*l_element_courant).donnee).objet)) .symbole = d_vrai; // Ajout de la fonction DER if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DER"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 2; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_der; // Ajout de la fonction ROT if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "ROT"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_rot; // Ajout de la fonction '*' if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "*"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_multiplication; // Ajout de la fonction '+' (*l_element_courant).suivant = (*l_element_suivant).suivant; liberation(s_etat_processus, (*l_element_suivant).donnee); free(l_element_suivant); l_element_courant = (*l_element_courant).suivant; free((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction); if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "+"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_plus; } else if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "/") == 0) { /* * Transormer << / X DER >> en * << DUP2 DUP SQ ROT ROT X DER * SWAP / ROT X DER ROT / * SWAP - >> */ // Transformation du '/' en DUP2 l_element_suivant = (*l_element_courant).suivant; free((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction); if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DUP2"); (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).fonction = instruction_dup2; // Ajout de la fonction DUP if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DUP"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_dup; // Ajout de la fonction SQ if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "SQ"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_sq; // Ajout de la fonction ROT if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "ROT"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_rot; // Ajout de la fonction ROT if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "ROT"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_rot; // Ajout de la variable de dérivation if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, NOM)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom = malloc((strlen(variable) + 1) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom, variable); (*((struct_nom *) (*(*l_element_courant).donnee).objet)) .symbole = d_vrai; // Ajout de la fonction DER if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DER"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 2; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_der; // Ajout de la fonction '*' if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "*"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_multiplication; // Ajout de la fonction SWAP if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "SWAP"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_swap; // Ajout de la fonction '/' if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "/"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_division; // Ajout de la fonction ROT if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "ROT"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_rot; // Ajout de la variable de dérivation if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, NOM)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom = malloc((strlen(variable) + 1) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom, variable); (*((struct_nom *) (*(*l_element_courant).donnee).objet)) .symbole = d_vrai; // Ajout de la fonction DER if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DER"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 2; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_der; // Ajout de la fonction ROT if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "ROT"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_rot; // Ajout de la fonction '/' if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "/"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_division; // Ajout de la fonction SWAP if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "SWAP"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_swap; // Ajout de la fonction '-' (*l_element_courant).suivant = (*l_element_suivant).suivant; liberation(s_etat_processus, (*l_element_suivant).donnee); free(l_element_suivant); l_element_courant = (*l_element_courant).suivant; free((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction); if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "-"); (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).fonction = instruction_moins; } else if ((strcmp((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "^") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction , "**") == 0)) { /* * Transormer << ** X DER >> en * << OVER X DER ROT ROT DUP 1 - ROT SWAP ** * * >> */ // Transformation du '**' en OVER l_element_suivant = (*l_element_courant).suivant; free((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction); if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "OVER"); (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).fonction = instruction_over; // Ajout de la variable de dérivation if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, NOM)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom = malloc((strlen(variable) + 1) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom, variable); (*((struct_nom *) (*(*l_element_courant).donnee).objet)) .symbole = d_vrai; // Ajout de la fonction DER if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DER"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 2; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_der; // Ajout de la fonction ROT if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "ROT"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_rot; // Ajout de la fonction ROT if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "ROT"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_rot; // Ajout de la fonction DUP if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DUP"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_dup; // Ajout de 1 sur la pile if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, INT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*(*l_element_courant).donnee).objet)) = 1; // Ajout de la fonction '-' if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "-"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_moins; // Ajout de la fonction ROT if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "ROT"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_rot; // Ajout de la fonction SWAP if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "SWAP"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_swap; // Ajout de la fonction '**' if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "**"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_puissance; // Ajout de la fonction '*' if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "*"); (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_multiplication; // Ajout de la fonction '*' (*l_element_courant).suivant = (*l_element_suivant).suivant; liberation(s_etat_processus, (*l_element_suivant).donnee); free(l_element_suivant); l_element_courant = (*l_element_courant).suivant; free((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction); if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "*"); (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).fonction = instruction_multiplication; } /* * Traitement des fonctions */ else { derivee_fonction_disponible = d_faux; tampon = (*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction; derivee_fonction_disponible = d_faux; fin_boucle = d_faux; i = 0; do { if (fonctions[i] == NULL) { /* * On saute les expressions dérivées, donc * on cherche le prochain NULL. */ while(fonctions[++i] != NULL); if (fonctions[++i] == NULL) { fin_boucle = d_vrai; } } else if (strcmp(fonctions[i], tampon) == 0) { /* * Vérification du nombre d'arguments de la fonction */ if ((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nombre_arguments == atol(fonctions[i + 1])) { i += 2; derivee_fonction_disponible = d_vrai; fin_boucle = d_vrai; while(fonctions[i] != NULL) { i++; } } } else { /* * Saut de la fonction et du nombre d'arguments */ i += 2; } } while(fin_boucle == d_faux); if (derivee_fonction_disponible == d_faux) { /* * Remplacement de 'fct' X DER par * 'Derfct(arg, X)' */ tampon = (*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction; // Transformation du nom de la fonction // en variable de dérivation l_element_suivant = (*l_element_courant).suivant; free((*(*l_element_courant).donnee).objet); (*(*l_element_courant).donnee).type = NOM; if (((*(*l_element_courant).donnee).objet = malloc( sizeof(struct_nom))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom = malloc((strlen(variable) + 1) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom, variable); (*((struct_nom *) (*(*l_element_courant).donnee).objet)) .symbole = d_vrai; (*l_element_courant).suivant = (*l_element_suivant).suivant; liberation(s_etat_processus, (*l_element_suivant).donnee); free(l_element_suivant); l_element_courant = (*l_element_courant).suivant; free((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction); if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc((strlen(tampon) + 4) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcat(strcpy((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction, "Der"), tampon); if ((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments == 0) { (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments = 3; } else { (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments += 1; } free(tampon); } else { /* * Transormer << FCT X DER >> en * << DUP X DER SWAP DerFCT * >> */ // Transformation de la fonction à dériver en DUP l_element_suivant = (*l_element_courant).suivant; free((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction); if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DUP"); (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).fonction = instruction_dup; // Ajout de la variable de dérivation if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, NOM)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom = malloc((strlen(variable) + 1) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_nom *) (*(*l_element_courant).donnee) .objet)).nom, variable); (*((struct_nom *) (*(*l_element_courant).donnee).objet)) .symbole = d_vrai; // Ajout de la fonction DER if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DER"); (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments = 2; (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).fonction = instruction_der; // Ajout de la fonction SWAP if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "SWAP"); (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments = -1; (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).fonction = instruction_swap; // Ajout de la fonction dérivée i++; do { if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (strcmp(fonctions[i], "FCT") == 0) { if (((*l_element_courant).donnee = allocation( s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction = malloc( (strlen(fonctions[i + 1]) + 1) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction, fonctions[i + 1]); (*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nombre_arguments = atoi(fonctions[i + 2]); (*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).fonction = analyse_instruction(s_etat_processus, fonctions[i + 1]); } else if (strcmp(fonctions[i], "INT") == 0) { if (((*l_element_courant).donnee = allocation( s_etat_processus, INT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*(*l_element_courant) .donnee).objet)) = atoi(fonctions[i + 1]); } else if (strcmp(fonctions[i], "NOM") == 0) { if (((*l_element_courant).donnee = allocation( s_etat_processus, NOM)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_nom *) (*(*l_element_courant) .donnee).objet)).nom = malloc( strlen((fonctions[i + 1]) + 1) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_nom *) (*(*l_element_courant) .donnee).objet)).nom, fonctions[i + 1]); (*((struct_nom *) (*(*l_element_courant) .donnee).objet)).symbole = d_vrai; } else if (strcmp(fonctions[i], "DER") == 0) { // Ajout de la variable de dérivation if (((*l_element_courant).donnee = allocation( s_etat_processus, NOM)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_nom *) (*(*l_element_courant) .donnee).objet)).nom = malloc((strlen(variable) + 1) * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_nom *) (*(*l_element_courant) .donnee).objet)).nom, variable); (*((struct_nom *) (*(*l_element_courant).donnee) .objet)).symbole = d_vrai; // Ajout de la fonction DER if (((*l_element_courant).suivant = malloc( sizeof(struct_liste_chainee))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DER"); (*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nombre_arguments = 2; (*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).fonction = instruction_der; } i += 3; } while(fonctions[i] != NULL); // Ajout de la fonction '*' (*l_element_courant).suivant = (*l_element_suivant).suivant; liberation(s_etat_processus, (*l_element_suivant).donnee); free(l_element_suivant); l_element_courant = (*l_element_courant).suivant; free((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction); if (((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_expression) = s_expression_courante; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "*"); (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).fonction = instruction_multiplication; } } } (*s_etat_processus).traitement_symbolique = 'Y'; if (evaluation(s_etat_processus, s_expression_courante, 'E') == d_erreur) { (*s_expression) = s_expression_courante; (*s_etat_processus).traitement_symbolique = 'N'; return; } (*s_etat_processus).traitement_symbolique = 'N'; liberation(s_etat_processus, s_expression_courante); if ((*s_etat_processus).var_volatile_requete_arret == 0) { if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_expression_courante) == d_erreur) { (*s_expression) = NULL; (*s_etat_processus).erreur_systeme = d_es_pile_operationnelle_vide; return; } /* * Arrêt lorsqu'il n'y a plus de fonction 'DER' dans l'expression * courante. */ if (((*s_expression_courante).type == ALG) || ((*s_expression_courante).type == RPN)) { l_element_courant = (struct_liste_chainee *) (*s_expression_courante).objet; drapeau = d_faux; while((l_element_courant != NULL) && (drapeau == d_faux)) { if ((*(*l_element_courant).donnee).type == FCT) { if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "DER") == 0) { drapeau = d_vrai; } } l_element_courant = (*l_element_courant).suivant; } } else { drapeau = d_faux; } } else { s_expression_courante = NULL; } } while((drapeau == d_vrai) && ((*s_etat_processus) .var_volatile_requete_arret == 0)); (*s_expression) = s_expression_courante; return; } // vim: ts=4