/* ================================================================================ RPL/2 (R) version 4.1.13 Copyright (C) 1989-2013 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 'pick' ================================================================================ Entrées : structure processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_pick(struct_processus *s_etat_processus) { struct_liste_chainee *l_liste; struct_objet *s_objet; struct_objet *s_nouvel_objet; integer8 i; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n PICK "); if ((*s_etat_processus).langue == 'F') { printf("(duplication d'un objet)\n\n"); } else { printf("(duplication of a object)\n\n"); } printf(" n: %s, %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s,\n" " %s, %s\n", d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, d_SQL, d_SLB, d_PRC, d_MTX); printf(" ...\n"); printf(" 2: %s, %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s,\n" " %s, %s\n", d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, d_SQL, d_SLB, d_PRC, d_MTX); printf(" 1: %s\n", d_INT); printf("-> n: %s, %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s,\n" " %s, %s\n", d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, d_SQL, d_SLB, d_PRC, d_MTX); printf(" ...\n"); printf(" 1: %s, %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s, %s,\n" " %s, %s, %s, %s,\n" " %s, %s\n", d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, d_SQL, d_SLB, d_PRC, d_MTX); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 1) == d_erreur) { return; } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet).type != INT) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } if ((*((integer8 *) (*s_objet).objet)) <= 0) { /* -- Opération absurde autorisée sur le calculateur HP-28S ----------------------- */ liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } if ((*((integer8 *) (*s_objet).objet)) > (*s_etat_processus) .hauteur_pile_operationnelle) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } l_liste = (*s_etat_processus).l_base_pile; for(i = 1; i < (*((integer8 *) (*s_objet).objet)); i++) { l_liste = (*l_liste).suivant; } s_nouvel_objet = copie_objet(s_etat_processus, (*l_liste).donnee, 'P'); if (s_nouvel_objet == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_nouvel_objet) == d_erreur) { return; } liberation(s_etat_processus, s_objet); return; } /* ================================================================================ Fonction '+' ================================================================================ Entrées : structure processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_plus(struct_processus *s_etat_processus) { integer8 tampon; logical1 depassement; logical1 drapeau; struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_precedent; struct_objet *s_copie_argument_1; struct_objet *s_copie_argument_2; struct_objet *s_objet_argument_1; struct_objet *s_objet_argument_2; struct_objet *s_objet_resultat; integer8 i; integer8 j; integer8 nombre_elements; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n + "); if ((*s_etat_processus).langue == 'F') { printf("(addition)\n\n"); } else { printf("(addition)\n\n"); } printf(" 2: %s, %s, %s\n", d_INT, d_REL, d_CPL); printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL); printf("-> 1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL); printf(" 2: %s, %s, %s\n", d_VIN, d_VRL, d_VCX); printf(" 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX); printf("-> 1: %s, %s, %s\n\n", d_VIN, d_VRL, d_VCX); printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX); printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX); printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX); printf(" 2: %s, %s\n", d_BIN, d_INT); printf(" 1: %s, %s\n", d_BIN, d_INT); printf("-> 1: %s\n\n", d_BIN); printf(" 2: %s\n", d_CHN); printf(" 1: %s\n", d_CHN); printf("-> 1: %s\n\n", d_CHN); printf(" 2: %s\n", d_LST); printf(" 1: %s\n", d_LST); printf("-> 1: %s\n\n", d_LST); printf(" 2: %s, %s, %s, %s, %s, %s\n", d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN); printf(" 1: %s, %s, %s, %s, %s, %s\n", d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN); printf("-> 1: %s, %s\n", d_ALG, d_RPN); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = 0; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 2) == d_erreur) { return; } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_argument_1) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_argument_2) == d_erreur) { liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } /* -------------------------------------------------------------------------------- Addition de deux entiers -------------------------------------------------------------------------------- */ if (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == INT)) { if (depassement_addition((integer8 *) (*s_objet_argument_1).objet, (integer8 *) (*s_objet_argument_2).objet, &tampon) == d_absence_erreur) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*s_objet_resultat).objet)) = tampon; } else { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((real8 *) (*s_objet_resultat).objet)) = ((real8) (*((integer8 *) (*s_objet_argument_1).objet))) + ((real8) (*((integer8 *) (*s_objet_argument_2).objet))); } } /* -------------------------------------------------------------------------------- Addition d'un entier et d'un réel -------------------------------------------------------------------------------- */ else if ((((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == REL)) || (((*s_objet_argument_1).type == REL) && ((*s_objet_argument_2).type == INT))) { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == INT) { (*((real8 *) (*s_objet_resultat).objet)) = ((real8) (*((integer8 *) (*s_objet_argument_1).objet))) + (*((real8 *) (*s_objet_argument_2).objet)); } else { (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) (*s_objet_argument_1).objet)) + ((real8) (*((integer8 *) (*s_objet_argument_2).objet))); } } /* -------------------------------------------------------------------------------- Addition d'un entier et d'un complexe -------------------------------------------------------------------------------- */ else if ((((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == CPL)) || (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == INT))) { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == INT) { f77additionci_((struct_complexe16 *) (*s_objet_argument_2).objet, (integer8 *) (*s_objet_argument_1).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } else { f77additionci_((struct_complexe16 *) (*s_objet_argument_1).objet, (integer8 *) (*s_objet_argument_2).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } } /* -------------------------------------------------------------------------------- Addition de deux réels -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == REL) && ((*s_objet_argument_2).type == REL)) { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) (*s_objet_argument_1).objet)) + (*((real8 *) (*s_objet_argument_2).objet)); } /* -------------------------------------------------------------------------------- Addition d'un réel et d'un complexe -------------------------------------------------------------------------------- */ else if ((((*s_objet_argument_1).type == REL) && ((*s_objet_argument_2).type == CPL)) || (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == REL))) { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == REL) { f77additioncr_((struct_complexe16 *) (*s_objet_argument_2).objet, (real8 *) (*s_objet_argument_1).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } else { f77additioncr_((struct_complexe16 *) (*s_objet_argument_1).objet, (real8 *) (*s_objet_argument_2).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } } /* -------------------------------------------------------------------------------- Addition de deux complexes -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == CPL)) { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77additioncc_((struct_complexe16 *) (*s_objet_argument_2).objet, (struct_complexe16 *) (*s_objet_argument_1).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } /* -------------------------------------------------------------------------------- Addition de deux vecteurs -------------------------------------------------------------------------------- */ /* * Entier / Entier */ else if (((*s_objet_argument_1).type == VIN) && ((*s_objet_argument_2).type == VIN)) { if ((*(((struct_vecteur *) (*s_objet_argument_1).objet))).taille != (*(((struct_vecteur *) (*s_objet_argument_2).objet))).taille) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, VIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille) * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } depassement = d_faux; for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille; i++) { if (depassement_addition(&(((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]), &(((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau) [i]), &(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])) == d_erreur) { depassement = d_vrai; } } if (depassement == d_vrai) { free((*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau); if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*s_objet_resultat).type = VRL; (*((struct_vecteur *) (*s_objet_resultat).objet)).type = 'R'; for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille; i++) { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = (real8) (((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)) .tableau)[i]) + (real8) (((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)) .tableau)[i]); } } } /* * Entier / Réel */ else if ((((*s_objet_argument_1).type == VIN) && ((*s_objet_argument_2).type == VRL)) || (((*s_objet_argument_1).type == VRL) && ((*s_objet_argument_2).type == VIN))) { if ((*(((struct_vecteur *) (*s_objet_argument_1).objet))).taille != (*(((struct_vecteur *) (*s_objet_argument_2).objet))).taille) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille; i++) { if ((*s_objet_argument_1).type == VIN) { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = ((real8) ((integer8 *) (*((struct_vecteur *)(*s_objet_argument_1).objet)) .tableau)[i]) + ((real8 *) (*((struct_vecteur *) (*s_objet_argument_2) .objet)).tableau)[i]; } else { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = ((real8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i] + ((real8) ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]); } } } /* * Réel / Réel */ else if (((*s_objet_argument_1).type == VRL) && ((*s_objet_argument_2).type == VRL)) { if ((*(((struct_vecteur *) (*s_objet_argument_1).objet))).taille != (*(((struct_vecteur *) (*s_objet_argument_2).objet))).taille) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille; i++) { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = ((real8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i] + ((real8 *) (*((struct_vecteur *) (*s_objet_argument_2) .objet)).tableau)[i]; } } /* * Entier / Complexe */ else if ((((*s_objet_argument_1).type == VIN) && ((*s_objet_argument_2).type == VCX)) || (((*s_objet_argument_1).type == VCX) && ((*s_objet_argument_2).type == VIN))) { if ((*(((struct_vecteur *) (*s_objet_argument_1).objet))).taille != (*(((struct_vecteur *) (*s_objet_argument_2).objet))).taille) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille; i++) { if ((*s_objet_argument_1).type == VIN) { f77additionci_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]), &(((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } else { f77additionci_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]), &(((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } } } /* * Réel / Complexe */ else if ((((*s_objet_argument_1).type == VRL) && ((*s_objet_argument_2).type == VCX)) || (((*s_objet_argument_1).type == VCX) && ((*s_objet_argument_2).type == VRL))) { if ((*(((struct_vecteur *) (*s_objet_argument_1).objet))).taille != (*(((struct_vecteur *) (*s_objet_argument_2).objet))).taille) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille; i++) { if ((*s_objet_argument_1).type == VRL) { f77additioncr_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]), &(((real8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } else { f77additioncr_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]), &(((real8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } } } /* * Complexe / Complexe */ else if (((*s_objet_argument_1).type == VCX) && ((*s_objet_argument_2).type == VCX)) { if ((*(((struct_vecteur *) (*s_objet_argument_1).objet))).taille != (*(((struct_vecteur *) (*s_objet_argument_2).objet))).taille) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat) .objet))).taille; i++) { f77additioncc_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } } /* -------------------------------------------------------------------------------- Addition de deux matrices -------------------------------------------------------------------------------- */ /* * Entier / Entier */ else if (((*s_objet_argument_1).type == MIN) && ((*s_objet_argument_2).type == MIN)) { if (((*(((struct_matrice *) (*s_objet_argument_1).objet))) .nombre_lignes != (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes) || ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_colonnes != (*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes)) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, MIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes) * sizeof(integer8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } depassement = d_faux; for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes; i++) { if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i] = malloc(((size_t) (*(( (struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes) * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes; j++) { if (depassement_addition(&(((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]), &(((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]), &(((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])) == d_erreur) { depassement = d_vrai; } } } if (depassement == d_vrai) { (*s_objet_resultat).type = MRL; (*((struct_matrice *) (*s_objet_resultat).objet)).type = 'R'; for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes; i++) { free(((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i]); if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i] = malloc(((size_t) (*(( (struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet))).nombre_colonnes; j++) { (((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j]) = (real8) (((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]) + (real8) (((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]); } } } } /* * Entier / Réel */ else if ((((*s_objet_argument_1).type == MIN) && ((*s_objet_argument_2).type == MRL)) || (((*s_objet_argument_1).type == MRL) && ((*s_objet_argument_2).type == MIN))) { if (((*(((struct_matrice *) (*s_objet_argument_1).objet))) .nombre_lignes != (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes) || ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_colonnes != (*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes)) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes) * sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes; i++) { if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i] = malloc(((size_t) (*(( (struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes; j++) { if ((*s_objet_argument_1).type == MIN) { ((real8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i][j] = ((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)) .tableau)[i][j]) + ((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]; } else { ((real8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i][j] = ((real8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)) .tableau)[i][j] + ((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2) .objet)).tableau)[i][j]); } } } } /* * Réel / Réel */ else if (((*s_objet_argument_1).type == MRL) && ((*s_objet_argument_2).type == MRL)) { if (((*(((struct_matrice *) (*s_objet_argument_1).objet))) .nombre_lignes != (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes) || ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_colonnes != (*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes)) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes) * sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes; i++) { if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i] = malloc(((size_t) (*(( (struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes; j++) { ((real8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i][j] = ((real8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)) .tableau)[i][j] + ((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]; } } } /* * Entier / Complexe */ else if ((((*s_objet_argument_1).type == MIN) && ((*s_objet_argument_2).type == MCX)) || (((*s_objet_argument_1).type == MCX) && ((*s_objet_argument_2).type == MIN))) { if (((*(((struct_matrice *) (*s_objet_argument_1).objet))) .nombre_lignes != (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes) || ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_colonnes != (*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes)) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes; i++) { if ((((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i] = malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes; j++) { if ((*s_objet_argument_1).type == MIN) { f77additionci_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]), &(((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } else { f77additionci_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]), &(((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } } } } /* * Réel / Complexe */ else if ((((*s_objet_argument_1).type == MRL) && ((*s_objet_argument_2).type == MCX)) || (((*s_objet_argument_1).type == MCX) && ((*s_objet_argument_2).type == MRL))) { if (((*(((struct_matrice *) (*s_objet_argument_1).objet))) .nombre_lignes != (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes) || ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_colonnes != (*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes)) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes; i++) { if ((((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i] = malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes; j++) { if ((*s_objet_argument_1).type == MRL) { f77additioncr_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]), &(((real8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } else { f77additioncr_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]), &(((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } } } } /* * Complexe / Complexe */ else if (((*s_objet_argument_1).type == MCX) && ((*s_objet_argument_2).type == MCX)) { if (((*(((struct_matrice *) (*s_objet_argument_1).objet))) .nombre_lignes != (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes) || ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_colonnes != (*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes)) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_1).objet)) .nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes; i++) { if ((((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i] = malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet))) .nombre_colonnes; j++) { f77additioncc_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } } } /* -------------------------------------------------------------------------------- Addition mettant en oeuvre des binaires -------------------------------------------------------------------------------- */ /* * Binaire / Binaire */ else if (((*s_objet_argument_1).type == BIN) && ((*s_objet_argument_2).type == BIN)) { if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((logical8 *) (*s_objet_resultat).objet)) = (*((logical8 *) (*s_objet_argument_1).objet)) + (*((logical8 *) (*s_objet_argument_2).objet)); } /* * Binaire / Entier */ else if ((((*s_objet_argument_1).type == BIN) && ((*s_objet_argument_2).type == INT)) || (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == BIN))) { if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == BIN) { (*((logical8 *) (*s_objet_resultat).objet)) = (*((logical8 *) (*s_objet_argument_1).objet)) + ((logical8) (*((integer8 *) (*s_objet_argument_2) .objet))); } else { (*((logical8 *) (*s_objet_resultat).objet)) = ((logical8) (*((integer8 *) (*s_objet_argument_1).objet))) + (*((logical8 *) (*s_objet_argument_2).objet)); } } /* -------------------------------------------------------------------------------- Addition mettant en oeuvre un nom ou une expression algébrique -------------------------------------------------------------------------------- */ /* * Nom ou valeur numérique / Nom ou valeur numérique */ else if ((((*s_objet_argument_1).type == NOM) && (((*s_objet_argument_2).type == NOM) || ((*s_objet_argument_2).type == INT) || ((*s_objet_argument_2).type == REL) || ((*s_objet_argument_2).type == CPL))) || (((*s_objet_argument_2).type == NOM) && (((*s_objet_argument_1).type == INT) || ((*s_objet_argument_1).type == REL) || ((*s_objet_argument_1).type == CPL)))) { drapeau = d_vrai; if ((*s_objet_argument_1).type == NOM) { if ((*s_objet_argument_2).type == INT) { if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0) { drapeau = d_faux; s_objet_resultat = s_objet_argument_1; s_objet_argument_1 = NULL; } } else if ((*s_objet_argument_2).type == REL) { if ((*((real8 *) (*s_objet_argument_2).objet)) == 0) { drapeau = d_faux; s_objet_resultat = s_objet_argument_1; s_objet_argument_1 = NULL; } } else if ((*s_objet_argument_2).type == CPL) { if (((*((complex16 *) (*s_objet_argument_2).objet)) .partie_reelle == 0) && ((*((complex16 *) (*s_objet_argument_2).objet)).partie_imaginaire == 0)) { drapeau = d_faux; s_objet_resultat = s_objet_argument_1; s_objet_argument_1 = NULL; } } } else if ((*s_objet_argument_2).type == NOM) { if ((*s_objet_argument_1).type == INT) { if ((*((integer8 *) (*s_objet_argument_1).objet)) == 0) { drapeau = d_faux; s_objet_resultat = s_objet_argument_2; s_objet_argument_2 = NULL; } } else if ((*s_objet_argument_1).type == REL) { if ((*((real8 *) (*s_objet_argument_1).objet)) == 0) { drapeau = d_faux; s_objet_resultat = s_objet_argument_2; s_objet_argument_2 = NULL; } } else if ((*s_objet_argument_1).type == CPL) { if (((*((complex16 *) (*s_objet_argument_1).objet)) .partie_reelle == 0) && ((*((complex16 *) (*s_objet_argument_1).objet)).partie_imaginaire == 0)) { drapeau = d_faux; s_objet_resultat = s_objet_argument_2; s_objet_argument_2 = NULL; } } } if (drapeau == d_vrai) { if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*s_objet_resultat).objet; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_vers_niveau_superieur; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "<<"); if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; (*l_element_courant).donnee = s_objet_argument_2; if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; (*l_element_courant).donnee = s_objet_argument_1; if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*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_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_plus; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "+"); if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*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_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_vers_niveau_inferieur; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, ">>"); (*l_element_courant).suivant = NULL; s_objet_argument_1 = NULL; s_objet_argument_2 = NULL; } } /* * Nom ou valeur numérique / Expression */ else if ((((*s_objet_argument_1).type == ALG) || ((*s_objet_argument_1).type == RPN)) && (((*s_objet_argument_2).type == NOM) || ((*s_objet_argument_2).type == INT) || ((*s_objet_argument_2).type == REL) || ((*s_objet_argument_2).type == CPL))) { drapeau = d_vrai; nombre_elements = 0; l_element_courant = (struct_liste_chainee *) (*s_objet_argument_1).objet; while(l_element_courant != NULL) { nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (nombre_elements == 2) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } if ((*s_objet_argument_2).type == INT) { if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0) { drapeau = d_faux; s_objet_resultat = s_objet_argument_1; s_objet_argument_1 = NULL; } } else if ((*s_objet_argument_2).type == REL) { if ((*((real8 *) (*s_objet_argument_2).objet)) == 0) { drapeau = d_faux; s_objet_resultat = s_objet_argument_1; s_objet_argument_1 = NULL; } } else if ((*s_objet_argument_2).type == CPL) { if (((*((complex16 *) (*s_objet_argument_2).objet)) .partie_reelle == 0) && ((*((complex16 *) (*s_objet_argument_2).objet)).partie_imaginaire == 0)) { drapeau = d_faux; s_objet_resultat = s_objet_argument_1; s_objet_argument_1 = NULL; } } if (drapeau == d_vrai) { if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument_1, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet; l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*l_element_precedent).suivant).donnee = s_objet_argument_2; (*(*l_element_precedent).suivant).suivant = l_element_courant; while((*l_element_courant).suivant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*(*l_element_precedent).suivant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).nombre_arguments = 0; (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).fonction = instruction_plus; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction, "+"); (*(*l_element_precedent).suivant).suivant = l_element_courant; s_objet_argument_2 = NULL; } } /* * Expression / Nom ou valeur numérique */ else if ((((*s_objet_argument_1).type == NOM) || ((*s_objet_argument_1).type == INT) || ((*s_objet_argument_1).type == REL) || ((*s_objet_argument_1).type == CPL)) && (((*s_objet_argument_2).type == ALG) || ((*s_objet_argument_2).type == RPN))) { drapeau = d_vrai; nombre_elements = 0; l_element_courant = (struct_liste_chainee *) (*s_objet_argument_2).objet; while(l_element_courant != NULL) { nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (nombre_elements == 2) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } if ((*s_objet_argument_1).type == INT) { if ((*((integer8 *) (*s_objet_argument_1).objet)) == 0) { drapeau = d_faux; s_objet_resultat = s_objet_argument_2; s_objet_argument_2 = NULL; } } else if ((*s_objet_argument_1).type == REL) { if ((*((real8 *) (*s_objet_argument_1).objet)) == 0) { drapeau = d_faux; s_objet_resultat = s_objet_argument_2; s_objet_argument_2 = NULL; } } else if ((*s_objet_argument_1).type == CPL) { if (((*((complex16 *) (*s_objet_argument_1).objet)) .partie_reelle == 0) && ((*((complex16 *) (*s_objet_argument_1).objet)).partie_imaginaire == 0)) { drapeau = d_faux; s_objet_resultat = s_objet_argument_2; s_objet_argument_2 = NULL; } } if (drapeau == d_vrai) { if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument_2, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet; l_element_precedent = l_element_courant; while((*l_element_courant).suivant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*l_element_precedent).suivant).donnee = s_objet_argument_1; l_element_precedent = (*l_element_precedent).suivant; if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*(*l_element_precedent).suivant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).nombre_arguments = 0; (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).fonction = instruction_plus; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction, "+"); (*(*l_element_precedent).suivant).suivant = l_element_courant; s_objet_argument_1 = NULL; } } /* * Expression / Expression */ else if ((((*s_objet_argument_1).type == ALG) && ((*s_objet_argument_2).type == ALG)) || (((*s_objet_argument_1).type == RPN) && ((*s_objet_argument_2).type == RPN))) { nombre_elements = 0; l_element_courant = (struct_liste_chainee *) (*s_objet_argument_1).objet; while(l_element_courant != NULL) { nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (nombre_elements == 2) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } nombre_elements = 0; l_element_courant = (struct_liste_chainee *) (*s_objet_argument_2).objet; while(l_element_courant != NULL) { nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (nombre_elements == 2) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } if ((s_copie_argument_1 = copie_objet(s_etat_processus, s_objet_argument_1, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((s_copie_argument_2 = copie_objet(s_etat_processus, s_objet_argument_2, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (struct_liste_chainee *) (*s_copie_argument_1).objet; (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *) (*s_copie_argument_1).objet)).suivant; liberation(s_etat_processus, (*l_element_courant).donnee); free(l_element_courant); l_element_courant = (struct_liste_chainee *) (*s_copie_argument_2).objet; l_element_precedent = l_element_courant; s_objet_resultat = s_copie_argument_2; while((*l_element_courant).suivant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } liberation(s_etat_processus, (*l_element_courant).donnee); free(l_element_courant); (*l_element_precedent).suivant = (struct_liste_chainee *) (*s_copie_argument_1).objet; free(s_copie_argument_1); l_element_courant = (*l_element_precedent).suivant; while((*l_element_courant).suivant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*l_element_precedent).suivant).suivant = l_element_courant; l_element_courant = (*l_element_precedent).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_plus; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "+"); } /* -------------------------------------------------------------------------------- Concaténation de deux chaînes -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == CHN) && ((*s_objet_argument_2).type == CHN)) { if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*s_objet_resultat).objet = malloc((strlen((unsigned char *) (*s_objet_argument_2).objet) + strlen((unsigned char *) (*s_objet_argument_1).objet) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } sprintf((unsigned char *) (*s_objet_resultat).objet, "%s%s", (unsigned char *) (*s_objet_argument_2).objet, (unsigned char *) (*s_objet_argument_1).objet); } /* -------------------------------------------------------------------------------- Concatenation de deux listes -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == LST) && ((*s_objet_argument_2).type == LST)) { if ((s_copie_argument_1 = copie_objet(s_etat_processus, s_objet_argument_1, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((s_copie_argument_2 = copie_objet(s_etat_processus, s_objet_argument_2, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } s_objet_resultat = s_copie_argument_2; l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet; l_element_precedent = l_element_courant; while(l_element_courant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } if (l_element_precedent != NULL) { (*l_element_precedent).suivant = (struct_liste_chainee *) (*s_copie_argument_1).objet; } else { liberation(s_etat_processus, s_copie_argument_2); if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*s_objet_resultat).objet = (*s_copie_argument_1).objet; } free(s_copie_argument_1); } /* -------------------------------------------------------------------------------- Addition impossible -------------------------------------------------------------------------------- */ else { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { return; } return; } /* ================================================================================ Fonction '^' ================================================================================ Entrées : structure processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_puissance(struct_processus *s_etat_processus) { real8 argument; real8 exposant; integer8 tampon; logical1 drapeau; struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_precedent; struct_objet *s_copie_argument_1; struct_objet *s_copie_argument_2; struct_objet *s_objet_argument_1; struct_objet *s_objet_argument_2; struct_objet *s_objet_resultat; integer8 nombre_elements; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n ** [^] "); if ((*s_etat_processus).langue == 'F') { printf("(puissance)\n\n"); } else { printf("(power)\n\n"); } printf(" 2: %s, %s, %s\n", d_INT, d_REL, d_CPL); printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL); printf("-> 1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL); printf(" 2: %s, %s, %s, %s, %s, %s\n", d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN); printf(" 1: %s, %s, %s, %s, %s, %s\n", d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN); printf("-> 1: %s, %s\n", d_ALG, d_RPN); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = 0; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 2) == d_erreur) { return; } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_argument_1) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_argument_2) == d_erreur) { liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } /* -------------------------------------------------------------------------------- Puissance de deux entiers -------------------------------------------------------------------------------- */ if (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == INT)) { if ((*((integer8 *) (*s_objet_argument_1).objet)) > 0) { /* * Exposant positif */ if (depassement_puissance((integer8 *) (*s_objet_argument_2).objet, (integer8 *) (*s_objet_argument_1).objet, &tampon) == d_absence_erreur) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*s_objet_resultat).objet)) = tampon; } else { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } argument = (real8) (*((integer8 *) (*s_objet_argument_2).objet)); exposant = (real8) (*((integer8 *) (*s_objet_argument_1).objet)); f77puissancerr_(&argument, &exposant, &((*((real8 *) (*s_objet_resultat).objet)))); } } else if ((*((integer8 *) (*s_objet_argument_1).objet)) < 0) { /* * Exposant négatif */ if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } exposant = (real8) (*((integer8 *) (*s_objet_argument_1).objet)); f77puissanceir_(&((*((integer8 *) (*s_objet_argument_2).objet))), &exposant, &((*((real8 *) (*s_objet_resultat).objet)))); } else { /* * Exposant nul */ if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((integer8 *) (*s_objet_resultat).objet)) = 1; } } /* -------------------------------------------------------------------------------- Puissance d'un entier par un réel -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == REL) && ((*s_objet_argument_2).type == INT)) { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77puissanceir_(&((*((integer8 *) (*s_objet_argument_2).objet))), &((*((real8 *) (*s_objet_argument_1).objet))), &((*((real8 *) (*s_objet_resultat).objet)))); } /* -------------------------------------------------------------------------------- Puissance d'un entier par un complexe -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == INT)) { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77puissanceic_(&((*((integer8 *) (*s_objet_argument_2).objet))), &((*((struct_complexe16 *) (*s_objet_argument_1).objet))), &((*((struct_complexe16 *) (*s_objet_resultat).objet)))); } /* -------------------------------------------------------------------------------- Puissance d'un réel par un entier -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == REL)) { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((integer8 *) (*s_objet_argument_1).objet)) >> (8 * sizeof(integer4))) == 0) { f77puissanceri_(&((*((real8 *) (*s_objet_argument_2).objet))), &((*((integer8 *) (*s_objet_argument_1).objet))), &((*((real8 *) (*s_objet_resultat).objet)))); } else { exposant = (real8) (*((integer8 *) (*s_objet_argument_1).objet)); f77puissancerr_(&((*((real8 *) (*s_objet_argument_2).objet))), &exposant, &((*((real8 *) (*s_objet_resultat).objet)))); } } /* -------------------------------------------------------------------------------- Puissance d'un réel par un réel -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == REL) && ((*s_objet_argument_2).type == REL)) { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77puissancerr_(&((*((real8 *) (*s_objet_argument_2).objet))), &((*((real8 *) (*s_objet_argument_1).objet))), &((*((real8 *) (*s_objet_resultat).objet)))); } /* -------------------------------------------------------------------------------- Puissance d'un réel par un complexe -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == REL)) { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77puissancerc_(&((*((real8 *) (*s_objet_argument_2).objet))), &((*((struct_complexe16 *) (*s_objet_argument_1).objet))), &((*((struct_complexe16 *) (*s_objet_resultat).objet)))); } /* -------------------------------------------------------------------------------- Puissance d'un complexe par un entier -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == CPL)) { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((integer8 *) (*s_objet_argument_1).objet)) >> (8 * sizeof(integer4))) == 0) { f77puissanceci_(&((*((struct_complexe16 *) (*s_objet_argument_2) .objet))), &((*((integer8 *) (*s_objet_argument_1).objet))), &((*((struct_complexe16 *) (*s_objet_resultat).objet)))); } else { exposant = (real8) (*((integer8 *) (*s_objet_argument_1).objet)); f77puissancecr_(&((*((complex16 *) (*s_objet_argument_2).objet))), &exposant, &((*((complex16 *) (*s_objet_resultat).objet)))); } } /* -------------------------------------------------------------------------------- Puissance d'un complexe par un réel -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == REL) && ((*s_objet_argument_2).type == CPL)) { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77puissancecr_(&((*((struct_complexe16 *) (*s_objet_argument_2) .objet))), &((*((real8 *) (*s_objet_argument_1).objet))), &((*((struct_complexe16 *) (*s_objet_resultat).objet)))); } /* -------------------------------------------------------------------------------- Puissance d'un complexe par un complexe -------------------------------------------------------------------------------- */ else if (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == CPL)) { if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } f77puissancecc_(&((*((struct_complexe16 *) (*s_objet_argument_2).objet))), &((*((struct_complexe16 *) (*s_objet_argument_1).objet))), &((*((struct_complexe16 *) (*s_objet_resultat).objet)))); } /* -------------------------------------------------------------------------------- Puissance mettant en oeuvre un nom ou une expression algébrique -------------------------------------------------------------------------------- */ /* * Nom ou valeur numérique / Nom ou valeur numérique */ else if ((((*s_objet_argument_1).type == NOM) && (((*s_objet_argument_2).type == NOM) || ((*s_objet_argument_2).type == INT) || ((*s_objet_argument_2).type == REL) || ((*s_objet_argument_2).type == CPL))) || (((*s_objet_argument_2).type == NOM) && (((*s_objet_argument_1).type == INT) || ((*s_objet_argument_1).type == REL) || ((*s_objet_argument_1).type == CPL)))) { drapeau = d_vrai; if ((*s_objet_argument_2).type == NOM) { if ((*s_objet_argument_1).type == INT) { if ((*((integer8 *) (*s_objet_argument_1).objet)) == 1) { drapeau = d_faux; s_objet_resultat = s_objet_argument_2; s_objet_argument_2 = NULL; } } else if ((*s_objet_argument_1).type == REL) { if ((*((real8 *) (*s_objet_argument_1).objet)) == 1) { drapeau = d_faux; s_objet_resultat = s_objet_argument_2; s_objet_argument_2 = NULL; } } else if ((*s_objet_argument_1).type == CPL) { if (((*((complex16 *) (*s_objet_argument_1).objet)) .partie_reelle == 1) && ((*((complex16 *) (*s_objet_argument_1).objet)).partie_imaginaire == 0)) { drapeau = d_faux; s_objet_resultat = s_objet_argument_2; s_objet_argument_2 = NULL; } } } if (drapeau == d_vrai) { if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*s_objet_resultat).objet; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_vers_niveau_superieur; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "<<"); if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; (*l_element_courant).donnee = s_objet_argument_2; if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; (*l_element_courant).donnee = s_objet_argument_1; if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*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_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_puissance; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "^"); if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*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_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_vers_niveau_inferieur; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, ">>"); (*l_element_courant).suivant = NULL; s_objet_argument_1 = NULL; s_objet_argument_2 = NULL; } } /* * Nom ou valeur numérique / Expression */ else if ((((*s_objet_argument_1).type == ALG) || ((*s_objet_argument_1).type == RPN)) && (((*s_objet_argument_2).type == NOM) || ((*s_objet_argument_2).type == INT) || ((*s_objet_argument_2).type == REL) || ((*s_objet_argument_2).type == CPL))) { nombre_elements = 0; l_element_courant = (struct_liste_chainee *) (*s_objet_argument_1).objet; while(l_element_courant != NULL) { nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (nombre_elements == 2) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument_1, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet; l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*l_element_precedent).suivant).donnee = s_objet_argument_2; (*(*l_element_precedent).suivant).suivant = l_element_courant; while((*l_element_courant).suivant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*(*l_element_precedent).suivant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).nombre_arguments = 0; (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).fonction = instruction_puissance; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction, "^"); (*(*l_element_precedent).suivant).suivant = l_element_courant; s_objet_argument_2 = NULL; } /* * Expression / Nom ou valeur numérique */ else if ((((*s_objet_argument_1).type == NOM) || ((*s_objet_argument_1).type == INT) || ((*s_objet_argument_1).type == REL) || ((*s_objet_argument_1).type == CPL)) && (((*s_objet_argument_2).type == ALG) || ((*s_objet_argument_2).type == RPN))) { drapeau = d_vrai; nombre_elements = 0; l_element_courant = (struct_liste_chainee *) (*s_objet_argument_2).objet; while(l_element_courant != NULL) { nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (nombre_elements == 2) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } if ((*s_objet_argument_1).type == INT) { if ((*((integer8 *) (*s_objet_argument_1).objet)) == 1) { drapeau = d_faux; s_objet_resultat = s_objet_argument_2; s_objet_argument_2 = NULL; } } else if ((*s_objet_argument_1).type == REL) { if ((*((real8 *) (*s_objet_argument_1).objet)) == 1) { drapeau = d_faux; s_objet_resultat = s_objet_argument_2; s_objet_argument_2 = NULL; } } else if ((*s_objet_argument_1).type == CPL) { if (((*((complex16 *) (*s_objet_argument_1).objet)) .partie_reelle == 1) && ((*((complex16 *) (*s_objet_argument_1).objet)).partie_imaginaire == 0)) { drapeau = d_faux; s_objet_resultat = s_objet_argument_2; s_objet_argument_2 = NULL; } } if (drapeau == d_vrai) { if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument_2, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet; l_element_precedent = l_element_courant; while((*l_element_courant).suivant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*l_element_precedent).suivant).donnee = s_objet_argument_1; l_element_precedent = (*l_element_precedent).suivant; if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*(*l_element_precedent).suivant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).nombre_arguments = 0; (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).fonction = instruction_puissance; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction, "^"); (*(*l_element_precedent).suivant).suivant = l_element_courant; s_objet_argument_1 = NULL; } } /* * Expression / Expression */ else if ((((*s_objet_argument_1).type == ALG) && ((*s_objet_argument_2).type == ALG)) || (((*s_objet_argument_1).type == RPN) && ((*s_objet_argument_2).type == RPN))) { nombre_elements = 0; l_element_courant = (struct_liste_chainee *) (*s_objet_argument_1).objet; while(l_element_courant != NULL) { nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (nombre_elements == 2) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } nombre_elements = 0; l_element_courant = (struct_liste_chainee *) (*s_objet_argument_2).objet; while(l_element_courant != NULL) { nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (nombre_elements == 2) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } if ((s_copie_argument_1 = copie_objet(s_etat_processus, s_objet_argument_1, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((s_copie_argument_2 = copie_objet(s_etat_processus, s_objet_argument_2, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (struct_liste_chainee *) (*s_copie_argument_1).objet; (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *) (*s_copie_argument_1).objet)).suivant; liberation(s_etat_processus, (*l_element_courant).donnee); free(l_element_courant); l_element_courant = (struct_liste_chainee *) (*s_copie_argument_2).objet; l_element_precedent = l_element_courant; s_objet_resultat = s_copie_argument_2; while((*l_element_courant).suivant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } liberation(s_etat_processus, (*l_element_courant).donnee); free(l_element_courant); (*l_element_precedent).suivant = (struct_liste_chainee *) (*s_copie_argument_1).objet; free(s_copie_argument_1); l_element_courant = (*l_element_precedent).suivant; while((*l_element_courant).suivant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*l_element_precedent).suivant).suivant = l_element_courant; l_element_courant = (*l_element_precedent).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_puissance; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "^"); } /* -------------------------------------------------------------------------------- Puissance impossible -------------------------------------------------------------------------------- */ else { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { return; } return; } /* ================================================================================ Fonction 'purge' ================================================================================ Entrées : structure processus ------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_purge(struct_processus *s_etat_processus) { struct_liste_chainee *l_element_courant; struct_objet *s_objet; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n PURGE "); if ((*s_etat_processus).langue == 'F') { printf("(effacement d'une variable globale)\n\n"); } else { printf("(purge a global variable)\n\n"); } printf(" 1: %s, %s\n", d_NOM, d_LST); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 1) == d_erreur) { return; } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if ((*s_objet).type == NOM) { if (recherche_variable(s_etat_processus, ((*((struct_nom *) (*s_objet).objet)).nom)) == d_faux) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_systeme = d_es; (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; return; } if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_variable_partagee; return; } if (retrait_variable(s_etat_processus, (*((struct_nom *) (*s_objet).objet)).nom, 'G') == d_erreur) { return; } } else if ((*s_objet).type == LST) { l_element_courant = (struct_liste_chainee *) (*s_objet).objet; while(l_element_courant != NULL) { if ((*(*l_element_courant).donnee).type != NOM) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_nom_invalide; return; } if (recherche_variable(s_etat_processus, (*((struct_nom *) (*(*l_element_courant).donnee).objet)).nom) == d_faux) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_systeme = d_es; (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; return; } if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL) { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_variable_partagee; return; } if (retrait_variable(s_etat_processus, (*((struct_nom *) (*(*l_element_courant).donnee).objet)).nom, 'G') == d_erreur) { return; } l_element_courant = (*l_element_courant).suivant; } } else { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } liberation(s_etat_processus, s_objet); return; } /* ================================================================================ Fonction 'pi' ================================================================================ Entrées : pointeur sur une struct_processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_pi(struct_processus *s_etat_processus) { struct_objet *s_objet; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n PI "); if ((*s_etat_processus).langue == 'F') { printf("(constante PI)\n\n"); } else { printf("(PI constant)\n\n"); } printf("-> 1: %s, %s\n", d_REL, d_NOM); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).constante_symbolique = 'Y'; (*s_etat_processus).nombre_arguments = -1; return; } /* Indicateur 35 armé => évaluation symbolique */ if (test_cfsf(s_etat_processus, 35) == d_vrai) { if ((s_objet = allocation(s_etat_processus, NOM)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*((struct_nom *) (*s_objet).objet)).nom = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_nom *) (*s_objet).objet)).nom, "PI"); (*((struct_nom *) (*s_objet).objet)).symbole = d_faux; } else { if ((s_objet = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((real8 *) (*s_objet).objet)) = 4 * atan((real8) 1); } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet) == d_erreur) { return; } return; } /* ================================================================================ Fonction '%t' ================================================================================ Entrées : -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_pourcent_t(struct_processus *s_etat_processus) { struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_precedent; struct_objet *s_copie_argument_1; struct_objet *s_copie_argument_2; struct_objet *s_objet_argument_1; struct_objet *s_objet_argument_2; struct_objet *s_objet_resultat; integer8 nombre_elements; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n %%T "); if ((*s_etat_processus).langue == 'F') { printf("(pourcentage du total)\n\n"); } else { printf("(percentage wrt total)\n\n"); } printf(" 2: %s, %s\n", d_INT, d_REL); printf(" 1: %s, %s\n", d_INT, d_REL); printf("-> 1: %s\n\n", d_REL); printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL); printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL); printf("-> 1: %s\n\n", d_ALG); printf(" 2: %s, %s, %s, %s\n", d_RPN, d_NOM, d_INT, d_REL); printf(" 1: %s, %s, %s, %s\n", d_RPN, d_NOM, d_INT, d_REL); printf("-> 1: %s\n", d_RPN); return; } else if ((*s_etat_processus).test_instruction == 'Y') { (*s_etat_processus).nombre_arguments = -1; return; } if (test_cfsf(s_etat_processus, 31) == d_vrai) { if (empilement_pile_last(s_etat_processus, 2) == d_erreur) { return; } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_argument_1) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_argument_2) == d_erreur) { liberation(s_etat_processus, s_objet_argument_1); (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } /* -------------------------------------------------------------------------------- %T portant sur des valeurs numériques -------------------------------------------------------------------------------- */ if ((((*s_objet_argument_1).type == INT) || ((*s_objet_argument_1).type == REL)) && (((*s_objet_argument_2).type == INT) || ((*s_objet_argument_2).type == REL))) { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == INT) { if ((*s_objet_argument_2).type == INT) { (*((real8 *) (*s_objet_resultat).objet)) = 100 * (((real8) (*((integer8 *) (*s_objet_argument_1) .objet))) / ((real8) (*((integer8 *) (*s_objet_argument_2).objet)))); } else { (*((real8 *) (*s_objet_resultat).objet)) = 100 * (((real8) (*((integer8 *) (*s_objet_argument_1) .objet))) / (*((real8 *) (*s_objet_argument_2).objet))); } } else { if ((*s_objet_argument_2).type == INT) { (*((real8 *) (*s_objet_resultat).objet)) = 100 * ((*((real8 *) (*s_objet_argument_1) .objet)) / ((real8) (*((integer8 *) (*s_objet_argument_2).objet)))); } else { (*((real8 *) (*s_objet_resultat).objet)) = 100 * ((*((real8 *) (*s_objet_argument_1).objet)) / (*((real8 *) (*s_objet_argument_2).objet))); } } } /* -------------------------------------------------------------------------------- %T entre des arguments complexes -------------------------------------------------------------------------------- */ /* * Nom ou valeur numérique / Nom ou valeur numérique */ else if ((((*s_objet_argument_1).type == NOM) && (((*s_objet_argument_2).type == NOM) || ((*s_objet_argument_2).type == INT) || ((*s_objet_argument_2).type == REL))) || (((*s_objet_argument_2).type == NOM) && (((*s_objet_argument_1).type == INT) || ((*s_objet_argument_1).type == REL)))) { if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*s_objet_resultat).objet; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_vers_niveau_superieur; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "<<"); if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; (*l_element_courant).donnee = s_objet_argument_2; if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (*l_element_courant).suivant; (*l_element_courant).donnee = s_objet_argument_1; if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*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_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 2; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_pourcent_t; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "%T"); if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*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_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_vers_niveau_inferieur; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, ">>"); (*l_element_courant).suivant = NULL; s_objet_argument_1 = NULL; s_objet_argument_2 = NULL; } /* * Nom ou valeur numérique / Expression */ else if (((((*s_objet_argument_1).type == ALG) || ((*s_objet_argument_1).type == RPN))) && (((*s_objet_argument_2).type == NOM) || ((*s_objet_argument_2).type == INT) || ((*s_objet_argument_2).type == REL))) { nombre_elements = 0; l_element_courant = (struct_liste_chainee *) (*s_objet_argument_1).objet; while(l_element_courant != NULL) { nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (nombre_elements == 2) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument_1, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet; l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*l_element_precedent).suivant).donnee = s_objet_argument_2; (*(*l_element_precedent).suivant).suivant = l_element_courant; while((*l_element_courant).suivant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*(*l_element_precedent).suivant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).nombre_arguments = 2; (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).fonction = instruction_pourcent_t; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction, "%T"); (*(*l_element_precedent).suivant).suivant = l_element_courant; s_objet_argument_2 = NULL; } /* * Expression / Nom ou valeur numérique */ else if ((((*s_objet_argument_1).type == NOM) || ((*s_objet_argument_1).type == INT) || ((*s_objet_argument_1).type == REL)) && ((((*s_objet_argument_2).type == ALG) || ((*s_objet_argument_2).type == RPN)))) { nombre_elements = 0; l_element_courant = (struct_liste_chainee *) (*s_objet_argument_2).objet; while(l_element_courant != NULL) { nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (nombre_elements == 2) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } if ((s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument_2, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet; l_element_precedent = l_element_courant; while((*l_element_courant).suivant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*l_element_precedent).suivant).donnee = s_objet_argument_1; l_element_precedent = (*l_element_precedent).suivant; if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if (((*(*l_element_precedent).suivant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).nombre_arguments = 2; (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).fonction = instruction_pourcent_t; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction, "%T"); (*(*l_element_precedent).suivant).suivant = l_element_courant; s_objet_argument_1 = NULL; } /* * Expression / Expression */ else if ((((*s_objet_argument_1).type == ALG) && ((*s_objet_argument_2).type == ALG)) || (((*s_objet_argument_1).type == RPN) && ((*s_objet_argument_2).type == RPN))) { nombre_elements = 0; l_element_courant = (struct_liste_chainee *) (*s_objet_argument_1).objet; while(l_element_courant != NULL) { nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (nombre_elements == 2) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } nombre_elements = 0; l_element_courant = (struct_liste_chainee *) (*s_objet_argument_2).objet; while(l_element_courant != NULL) { nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (nombre_elements == 2) { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_argument_invalide; return; } if ((s_copie_argument_1 = copie_objet(s_etat_processus, s_objet_argument_1, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((s_copie_argument_2 = copie_objet(s_etat_processus, s_objet_argument_2, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (struct_liste_chainee *) (*s_copie_argument_1).objet; (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *) (*s_copie_argument_1).objet)).suivant; liberation(s_etat_processus, (*l_element_courant).donnee); free(l_element_courant); l_element_courant = (struct_liste_chainee *) (*s_copie_argument_2).objet; l_element_precedent = l_element_courant; s_objet_resultat = s_copie_argument_2; while((*l_element_courant).suivant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } liberation(s_etat_processus, (*l_element_courant).donnee); free(l_element_courant); (*l_element_precedent).suivant = (struct_liste_chainee *) (*s_copie_argument_1).objet; free(s_copie_argument_1); l_element_courant = (*l_element_precedent).suivant; while((*l_element_courant).suivant != NULL) { l_element_precedent = l_element_courant; l_element_courant = (*l_element_courant).suivant; } if (((*l_element_precedent).suivant = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*(*l_element_precedent).suivant).suivant = l_element_courant; l_element_courant = (*l_element_precedent).suivant; if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 2; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_pourcent_t; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "%T"); } /* -------------------------------------------------------------------------------- Arguments incorrects -------------------------------------------------------------------------------- */ else { liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; return; } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) { return; } liberation(s_etat_processus, s_objet_argument_1); liberation(s_etat_processus, s_objet_argument_2); return; } // vim: ts=4