/* ================================================================================ RPL/2 (R) version 4.1.12 Copyright (C) 1989-2012 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 '-' ================================================================================ Entrées : structure processus -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_moins(struct_processus *s_etat_processus) { integer8 tampon; integer8 tampon_2; logical1 depassement; logical1 drapeau; logical1 drapeau_neg; 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; unsigned long i; unsigned long j; unsigned long 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("(soustraction)\n\n"); } else { printf("(substraction)\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, %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; } /* -------------------------------------------------------------------------------- Soustraction de deux entiers -------------------------------------------------------------------------------- */ if (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == INT)) { tampon_2 = -(*((integer8 *) (*s_objet_argument_1).objet)); if (depassement_addition(&tampon_2, (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))); } } /* -------------------------------------------------------------------------------- Soustraction 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 *) (*s_objet_argument_2).objet)) - (*((integer8 *) (*s_objet_argument_1).objet)); } else { (*((real8 *) (*s_objet_resultat).objet)) = (*((integer8 *) (*s_objet_argument_2).objet)) - (*((real8 *) (*s_objet_argument_1).objet)); } } /* -------------------------------------------------------------------------------- Soustraction 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) { f77soustractionci_((struct_complexe16 *) (*s_objet_argument_2) .objet, (integer8 *) (*s_objet_argument_1).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } else { f77soustractionic_((integer8 *) (*s_objet_argument_2).objet, (struct_complexe16 *) (*s_objet_argument_1).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } } /* -------------------------------------------------------------------------------- Soustraction 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_2).objet)) - (*((real8 *) (*s_objet_argument_1).objet)); } /* -------------------------------------------------------------------------------- Soustraction 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) { f77soustractioncr_((struct_complexe16 *) (*s_objet_argument_2).objet, (real8 *) (*s_objet_argument_1).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } else { f77soustractionrc_((real8 *) (*s_objet_argument_2).objet, (struct_complexe16 *) (*s_objet_argument_1).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } } /* -------------------------------------------------------------------------------- Soustraction 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; } f77soustractioncc_((struct_complexe16 *) (*s_objet_argument_2).objet, (struct_complexe16 *) (*s_objet_argument_1).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } /* -------------------------------------------------------------------------------- Soustraction de deux vecteurs -------------------------------------------------------------------------------- */ /* * Entier / Entier */ else if (((*s_objet_argument_1).type == VIN) && ((*s_objet_argument_2).type == VIN)) { if ((s_objet_resultat = allocation(s_etat_processus, VIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 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((*(((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++) { tampon = -((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1) .objet)).tableau)[i]; if (depassement_addition(&(((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]), &tampon, &(((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((*(((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_2).objet)) .tableau)[i]) - (real8) (((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1) .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 ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 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((*(((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 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i] - ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]; } else { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i] - ((real8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]; } } } /* * Réel / Réel */ else if (((*s_objet_argument_1).type == VRL) && ((*s_objet_argument_2).type == VRL)) { if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 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((*(((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_2).objet)).tableau)[i] - ((real8 *) (*((struct_vecteur *) (*s_objet_argument_1) .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 ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 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((*(((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) { f77soustractionci_(&(((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 { f77soustractionic_(&(((integer8 *) (*((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])); } } } /* * 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 ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 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((*(((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) { f77soustractioncr_(&(((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 { f77soustractionrc_(&(((real8 *) (*((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])); } } } /* * Complexe / Complexe */ else if (((*s_objet_argument_1).type == VCX) && ((*s_objet_argument_2).type == VCX)) { if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 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((*(((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++) { f77soustractioncc_(&(((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])); } } /* -------------------------------------------------------------------------------- Soustraction de deux matrices -------------------------------------------------------------------------------- */ /* * Entier / Entier */ else if (((*s_objet_argument_1).type == MIN) && ((*s_objet_argument_2).type == MIN)) { if ((s_objet_resultat = allocation(s_etat_processus, MIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 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((*(((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((*(( (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++) { tampon = -((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]; if (depassement_addition(&(((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]), &tampon, &(((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((*(( (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_2).objet)) .tableau)[i][j]) - ((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).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 ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 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((*(((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((*(( (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 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][j] - ((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)) .tableau)[i][j]; } else { ((real8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i][j] = ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2) .objet)).tableau)[i][j] - ((real8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)) .tableau)[i][j]; } } } } /* * Réel / Réel */ else if (((*s_objet_argument_1).type == MRL) && ((*s_objet_argument_2).type == MRL)) { if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 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((*(((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((*(( (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_2).objet)) .tableau)[i][j] - ((real8 **) (*((struct_matrice *) (*s_objet_argument_1).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 ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 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((*(((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((*(( (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) { f77soustractionci_(&(((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 { f77soustractionic_(&(((integer8 **) (*((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])); } } } } /* * 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 ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 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((*(((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((*(( (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) { f77soustractioncr_(&(((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 { f77soustractionrc_(&(((real8 **) (*((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])); } } } } /* * Complexe / Complexe */ else if (((*s_objet_argument_1).type == MCX) && ((*s_objet_argument_2).type == MCX)) { if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } 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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 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((*(((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((*(( (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++) { f77soustractioncc_(&(((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])); } } } /* -------------------------------------------------------------------------------- Soustraction 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_2).objet)) - (*((logical8 *) (*s_objet_argument_1).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)) = (*((integer8 *) (*s_objet_argument_2).objet)) - (*((logical8 *) (*s_objet_argument_1).objet)); } else { (*((logical8 *) (*s_objet_resultat).objet)) = (*((logical8 *) (*s_objet_argument_2).objet)) - (*((integer8 *) (*s_objet_argument_1).objet)); } } /* -------------------------------------------------------------------------------- Soustraction 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; drapeau_neg = d_faux; 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; } } } else if ((*s_objet_argument_1).type == NOM) { if ((*s_objet_argument_2).type == INT) { if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0) { drapeau_neg = d_vrai; } } else if ((*s_objet_argument_2).type == REL) { if ((*((real8 *) (*s_objet_argument_2).objet)) == 0) { drapeau_neg = d_vrai; } } 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_neg = d_vrai; } } } 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 (drapeau_neg == d_faux) { 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; } else { liberation(s_etat_processus, 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; } if (drapeau_neg == d_faux) { (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 0; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_moins; 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, "-"); } else { (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments = 1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_neg; if (((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) .objet)).nom_fonction, "NEG"); } 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_neg = d_faux; 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_neg = d_vrai; } } else if ((*s_objet_argument_2).type == REL) { if ((*((real8 *) (*s_objet_argument_2).objet)) == 0) { drapeau_neg = d_vrai; } } 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_neg = 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 (drapeau_neg == d_faux) { 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; } else { liberation(s_etat_processus, s_objet_argument_2); } 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; } if (drapeau_neg == d_faux) { (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).nombre_arguments = 0; (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).fonction = instruction_moins; 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, "-"); } else { (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).nombre_arguments = 1; (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).fonction = instruction_neg; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc(4 * 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, "NEG"); } (*(*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_moins; 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_moins; 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, "-"); } /* -------------------------------------------------------------------------------- Soustraction 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_multiplication(struct_processus *s_etat_processus) { integer8 cumul; integer8 tampon; logical1 depassement; logical1 drapeau; logical1 erreur_memoire; 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; unsigned long i; unsigned long j; unsigned long k; unsigned long nombre_elements; void *accumulateur; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n * "); if ((*s_etat_processus).langue == 'F') { printf("(multiplication)\n\n"); } else { printf("(multiplication)\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_INT, d_REL, d_CPL); printf("-> 1: %s, %s, %s\n\n", d_VIN, d_VRL, d_VCX); printf(" 2: %s, %s, %s\n", d_INT, d_REL, d_CPL); 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_INT, d_REL, d_CPL); printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX); printf(" 2: %s, %s, %s\n", d_INT, d_REL, d_CPL); 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, %s\n", d_MIN, d_MRL, d_MCX); 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, %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; } /* -------------------------------------------------------------------------------- Multiplication de deux entiers -------------------------------------------------------------------------------- */ if (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == INT)) { if (depassement_multiplication((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_2).objet))) * ((real8) (*((integer8 *) (*s_objet_argument_1).objet))); } } /* -------------------------------------------------------------------------------- Multiplication 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 *) (*s_objet_argument_2).objet)) * (*((integer8 *) (*s_objet_argument_1).objet)); } else { (*((real8 *) (*s_objet_resultat).objet)) = (*((integer8 *) (*s_objet_argument_2).objet)) * (*((real8 *) (*s_objet_argument_1).objet)); } } /* -------------------------------------------------------------------------------- Multiplication 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) { f77multiplicationci_((struct_complexe16 *) (*s_objet_argument_2) .objet, (integer8 *) (*s_objet_argument_1).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } else { f77multiplicationci_((struct_complexe16 *) (*s_objet_argument_1) .objet, (integer8 *) (*s_objet_argument_2).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } } /* -------------------------------------------------------------------------------- Multiplication 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_2).objet)) * (*((real8 *) (*s_objet_argument_1).objet)); } /* -------------------------------------------------------------------------------- Multiplication 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) { f77multiplicationcr_((struct_complexe16 *) (*s_objet_argument_2).objet, (real8 *) (*s_objet_argument_1).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } else { f77multiplicationcr_((struct_complexe16 *) (*s_objet_argument_1) .objet, (real8 *) (*s_objet_argument_2).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } } /* -------------------------------------------------------------------------------- Multiplication 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; } f77multiplicationcc_((struct_complexe16 *) (*s_objet_argument_2).objet, (struct_complexe16 *) (*s_objet_argument_1).objet, (struct_complexe16 *) (*s_objet_resultat).objet); } /* -------------------------------------------------------------------------------- Multiplication d'un vecteur par un scalaire -------------------------------------------------------------------------------- */ /* * Vecteur d'entiers / Entier */ else if ((((*s_objet_argument_1).type == VIN) && ((*s_objet_argument_2).type == INT)) || (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == VIN))) { if ((s_objet_resultat = allocation(s_etat_processus, VIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == VIN) { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; } else { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((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 ((*s_objet_argument_1).type == VIN) { if (depassement_multiplication((integer8 *) (*s_objet_argument_2).objet, &(((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)) .tableau)[i]), &(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])) == d_erreur) { depassement = d_vrai; } } else { if (depassement_multiplication((integer8 *) (*s_objet_argument_1).objet, &(((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) { (*s_objet_resultat).type = VRL; (*((struct_vecteur *) (*s_objet_resultat).objet)).type = 'R'; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((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 *) (*s_objet_argument_2).objet))) * ((real8) ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]); } else { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = ((real8) (*((integer8 *) (*s_objet_argument_1).objet))) * ((real8) ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]); } } } } /* * Vecteur de réels / Entier */ else if ((((*s_objet_argument_1).type == VRL) && ((*s_objet_argument_2).type == INT)) || (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == VRL))) { if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == VRL) { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; } else { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((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 == VRL) { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = (*((integer8 *) (*s_objet_argument_2) .objet)) * ((real8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]; } else { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = (*((integer8 *) (*s_objet_argument_1) .objet)) * ((real8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]; } } } /* * Vecteur de complexes / Entier */ else if ((((*s_objet_argument_1).type == VCX) && ((*s_objet_argument_2).type == INT)) || (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == VCX))) { if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == VCX) { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; } else { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((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 == VCX) { f77multiplicationci_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]), &((*((integer8 *) (*s_objet_argument_2).objet))), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } else { f77multiplicationci_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]), &((*((integer8 *) (*s_objet_argument_1).objet))), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } } } /* * Vecteur d'entiers / Réel */ else if ((((*s_objet_argument_1).type == VIN) && ((*s_objet_argument_2).type == REL)) || (((*s_objet_argument_1).type == REL) && ((*s_objet_argument_2).type == VIN))) { if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == VIN) { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; } else { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((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 *) (*s_objet_argument_2) .objet)) * ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]; } else { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = (*((real8 *) (*s_objet_argument_1) .objet)) * ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]; } } } /* * Vecteur de réels / Réel */ else if ((((*s_objet_argument_1).type == VRL) && ((*s_objet_argument_2).type == REL)) || (((*s_objet_argument_1).type == REL) && ((*s_objet_argument_2).type == VRL))) { if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == VRL) { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; } else { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((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 == VRL) { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = (*((real8 *) (*s_objet_argument_2) .objet)) * ((real8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]; } else { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = (*((real8 *) (*s_objet_argument_1) .objet)) * ((real8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]; } } } /* * Vecteur de complexes / Réel */ else if ((((*s_objet_argument_1).type == VCX) && ((*s_objet_argument_2).type == REL)) || (((*s_objet_argument_1).type == REL) && ((*s_objet_argument_2).type == VCX))) { if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == VCX) { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; } else { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((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 == VCX) { f77multiplicationcr_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]), &((*((real8 *) (*s_objet_argument_2).objet))), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } else { f77multiplicationcr_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]), &((*((real8 *) (*s_objet_argument_1).objet))), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } } } /* * Vecteur d'entiers / Complexe */ else if ((((*s_objet_argument_1).type == VIN) && ((*s_objet_argument_2).type == CPL)) || (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == VIN))) { if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == VIN) { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; } else { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((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) { f77multiplicationci_(&((*((struct_complexe16 *) (*s_objet_argument_2).objet))), &(((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } else { f77multiplicationci_(&((*((struct_complexe16 *) (*s_objet_argument_1).objet))), &(((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } } } /* * Vecteur de réels / Complexe */ else if ((((*s_objet_argument_1).type == VRL) && ((*s_objet_argument_2).type == CPL)) || (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == VRL))) { if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == VRL) { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; } else { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((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) { f77multiplicationcr_(&((*((struct_complexe16 *) (*s_objet_argument_2).objet))), &(((real8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } else { f77multiplicationcr_(&((*((struct_complexe16 *) (*s_objet_argument_1).objet))), &(((real8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } } } /* * Vecteur de complexes / Complexe */ else if ((((*s_objet_argument_1).type == VCX) && ((*s_objet_argument_2).type == CPL)) || (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == VCX))) { if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == VCX) { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille; } else { (*((struct_vecteur *) (*s_objet_resultat).objet)).taille = (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((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 == VCX) { f77multiplicationcc_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]), &((*((struct_complexe16 *) (*s_objet_argument_2).objet))), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } else { f77multiplicationcc_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]), &((*((struct_complexe16 *) (*s_objet_argument_1).objet))), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])); } } } /* -------------------------------------------------------------------------------- Multiplication d'une matrice par un scalaire -------------------------------------------------------------------------------- */ /* * Matrice d'entiers / Entier */ else if ((((*s_objet_argument_1).type == MIN) && ((*s_objet_argument_2).type == INT)) || (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == MIN))) { if ((s_objet_resultat = allocation(s_etat_processus, MIN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == MIN) { (*((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; } else { (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_colonnes; } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*(((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 (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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 ((*s_objet_argument_1).type == MIN) { if (depassement_multiplication((integer8 *) (*s_objet_argument_2).objet, &(((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)) .tableau)[i][j]), &(((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)) .tableau)[i][j])) == d_erreur) { depassement = d_vrai; } } else { if (depassement_multiplication((integer8 *) (*s_objet_argument_1).objet, &(((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 (((*((struct_matrice *) (*s_objet_resultat).objet)) .tableau[i] = malloc((*(((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 *) (*s_objet_argument_2) .objet))) * ((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)) .tableau)[i][j]); } else { ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = ((real8) (*((integer8 *) (*s_objet_argument_1) .objet))) * ((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][j]); } } } } } /* * Matrice de réels / Entier */ else if ((((*s_objet_argument_1).type == MRL) && ((*s_objet_argument_2).type == INT)) || (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == MRL))) { if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == MRL) { (*((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; } else { (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_colonnes; } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*(((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 (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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 == MRL) { ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = (*((integer8 *) (*s_objet_argument_2) .objet)) * ((real8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]; } else { ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = (*((integer8 *) (*s_objet_argument_1) .objet)) * ((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]; } } } } /* * Matrice de complexes / Entier */ else if ((((*s_objet_argument_1).type == MCX) && ((*s_objet_argument_2).type == INT)) || (((*s_objet_argument_1).type == INT) && ((*s_objet_argument_2).type == MCX))) { if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == MCX) { (*((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; } else { (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_colonnes; } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*(((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_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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 == MCX) { f77multiplicationci_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_1).objet)) .tableau)[i][j]), &((*((integer8 *) (*s_objet_argument_2).objet))), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } else { f77multiplicationci_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][j]), &((*((integer8 *) (*s_objet_argument_1).objet))), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } } } } /* * Matrice d'entiers / Réel */ else if ((((*s_objet_argument_1).type == MIN) && ((*s_objet_argument_2).type == REL)) || (((*s_objet_argument_1).type == REL) && ((*s_objet_argument_2).type == MIN))) { if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == MIN) { (*((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; } else { (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_colonnes; } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*(((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 (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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 *) (*s_objet_argument_2) .objet)) * ((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]; } else { ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = (*((real8 *) (*s_objet_argument_1) .objet)) * ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]; } } } } /* * Matrice de réels / Réel */ else if ((((*s_objet_argument_1).type == MRL) && ((*s_objet_argument_2).type == REL)) || (((*s_objet_argument_1).type == REL) && ((*s_objet_argument_2).type == MRL))) { if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == MRL) { (*((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; } else { (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_colonnes; } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*(((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 (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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 == MRL) { ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = (*((real8 *) (*s_objet_argument_2) .objet)) * ((real8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]; } else { ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = (*((real8 *) (*s_objet_argument_1) .objet)) * ((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]; } } } } /* * Matrice de complexes / Réel */ else if ((((*s_objet_argument_1).type == MCX) && ((*s_objet_argument_2).type == REL)) || (((*s_objet_argument_1).type == REL) && ((*s_objet_argument_2).type == MCX))) { if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == MCX) { (*((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; } else { (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_colonnes; } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*(((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_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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 == MCX) { f77multiplicationcr_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_1).objet)) .tableau)[i][j]), &((*((real8 *) (*s_objet_argument_2).objet))), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } else { f77multiplicationcr_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][j]), &((*((real8 *) (*s_objet_argument_1).objet))), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } } } } /* * Matrice d'entiers / Complexe */ else if ((((*s_objet_argument_1).type == MIN) && ((*s_objet_argument_2).type == CPL)) || (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == MIN))) { if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == MIN) { (*((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; } else { (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_colonnes; } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*(((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_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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) { f77multiplicationci_(&((*((struct_complexe16 *) (*s_objet_argument_2).objet))), &(((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } else { f77multiplicationci_(&((*((struct_complexe16 *) (*s_objet_argument_1).objet))), &(((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } } } } /* * Matrice de réels / Complexe */ else if ((((*s_objet_argument_1).type == MRL) && ((*s_objet_argument_2).type == CPL)) || (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == MRL))) { if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == MRL) { (*((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; } else { (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_colonnes; } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*(((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_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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) { f77multiplicationcr_(&((*((struct_complexe16 *) (*s_objet_argument_2).objet))), &(((real8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } else { f77multiplicationcr_(&((*((struct_complexe16 *) (*s_objet_argument_1).objet))), &(((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } } } } /* * Matrice de complexes / Complexe */ else if ((((*s_objet_argument_1).type == MCX) && ((*s_objet_argument_2).type == CPL)) || (((*s_objet_argument_1).type == CPL) && ((*s_objet_argument_2).type == MCX))) { if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((*s_objet_argument_1).type == MCX) { (*((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; } else { (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)) .nombre_colonnes; } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*(((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_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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 == MCX) { f77multiplicationcc_(&((*((struct_complexe16 *) (*s_objet_argument_2).objet))), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[i][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } else { f77multiplicationcc_(&((*((struct_complexe16 *) (*s_objet_argument_1).objet))), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])); } } } } /* -------------------------------------------------------------------------------- Multiplication d'une matrice par un vecteur (résultat : vecteur) -------------------------------------------------------------------------------- */ /* * Matrice d'entiers / Vecteur d'entiers */ else if (((*s_objet_argument_2).type == MIN) && ((*s_objet_argument_1).type == VIN)) { 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_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille != (*((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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_argument_2) .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_argument_2) .objet))).nombre_lignes; i++) { ((integer8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = 0; for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { if (depassement_multiplication(&(((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][k]), &(((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[k]), &tampon) == d_erreur) { depassement = d_vrai; } if (depassement_addition(&(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i]), &tampon, &cumul) == d_erreur) { depassement = d_vrai; } ((integer8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = cumul; } } if (depassement == d_vrai) { (*s_objet_resultat).type = VRL; (*((struct_vecteur *) (*s_objet_resultat).objet)).type = 'R'; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; i++) { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = 0; for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = ((real8) ((integer8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i]) + ((real8) (((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][k]) * ((real8) ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)) .tableau)[k])); } } } } /* * Matrice d'entiers / Vecteur de réels */ else if (((*s_objet_argument_2).type == MIN) && ((*s_objet_argument_1).type == VRL)) { 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_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille != (*((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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; i++) { for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { ((real8 *) accumulateur)[k] = (((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][k] * ((real8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[k]); } ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = sommation_vecteur_reel(accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } free(accumulateur); } /* * Matrice d'entiers / Vecteur de complexes */ else if (((*s_objet_argument_2).type == MIN) && ((*s_objet_argument_1).type == VCX)) { 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_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille != (*((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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; i++) { for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { f77multiplicationci_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)) .tableau)[k]), &(((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][k]), &(((complex16 *) accumulateur)[k])); } ((complex16 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = sommation_vecteur_complexe(accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } free(accumulateur); } /* * Matrice de réels / Vecteur d'entiers */ else if (((*s_objet_argument_2).type == MRL) && ((*s_objet_argument_1).type == VIN)) { 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_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille != (*((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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; i++) { for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { ((real8 *) accumulateur)[k] = (((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][k] * ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[k]); } ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = sommation_vecteur_reel(accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } free(accumulateur); } /* * Matrice de réels / Vecteur de réels */ else if (((*s_objet_argument_2).type == MRL) && ((*s_objet_argument_1).type == VRL)) { 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_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille != (*((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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; i++) { for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { ((real8 *) accumulateur)[k] = (((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][k] * ((real8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[k]); } ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) .tableau)[i] = sommation_vecteur_reel(accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } free(accumulateur); } /* * Matrice de réels / Vecteur de complexes */ else if (((*s_objet_argument_2).type == MRL) && ((*s_objet_argument_1).type == VCX)) { 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_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille != (*((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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; i++) { for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { f77multiplicationcr_(&(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)) .tableau)[k]), &(((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][k]), &(((complex16 *) accumulateur)[k])); } ((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat) .objet)).tableau)[i] = sommation_vecteur_complexe( accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } free(accumulateur); } /* * Matrice de complexes / Vecteur d'entiers */ else if (((*s_objet_argument_2).type == MCX) && ((*s_objet_argument_1).type == VIN)) { 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_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille != (*((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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; i++) { for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { f77multiplicationci_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][k]), &(((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)) .tableau)[k]), &(((complex16 *) accumulateur)[k])); } ((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat) .objet)).tableau)[i] = sommation_vecteur_complexe( accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } free(accumulateur); } /* * Matrice de complexes / Vecteur de réels */ else if (((*s_objet_argument_2).type == MCX) && ((*s_objet_argument_1).type == VRL)) { 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_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille != (*((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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; i++) { for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { f77multiplicationcr_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][k]), &(((real8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)) .tableau)[k]), &(((complex16 *) accumulateur)[k])); } ((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat) .objet)).tableau)[i] = sommation_vecteur_complexe( accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } free(accumulateur); } /* * Matrice de complexes / Vecteur de complexes */ else if (((*s_objet_argument_2).type == MCX) && ((*s_objet_argument_1).type == VCX)) { 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_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille != (*((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); liberation(s_etat_processus, s_objet_resultat); (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; return; } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_lignes; i++) { for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { f77multiplicationcc_(&(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][k]), &(((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)) .tableau)[k]), &(((complex16 *) accumulateur)[k])); } ((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat) .objet)).tableau)[i] = sommation_vecteur_complexe( accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } free(accumulateur); } /* -------------------------------------------------------------------------------- Multiplication d'une matrice par une autre matrice -------------------------------------------------------------------------------- */ /* * Matrice d'entiers / Matrice d'entiers */ else if (((*s_objet_argument_2).type == MIN) && ((*s_objet_argument_1).type == MIN)) { if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes != (*((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_2) .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((*(((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 (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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++) { ((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = 0; for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { if (depassement_multiplication(&(((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) .tableau)[i][k]), &(((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)) .tableau)[k][j]), &tampon) == d_erreur) { depassement = d_vrai; } if (depassement_addition(&(((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)) .tableau)[i][j]), &tampon, &cumul) == d_erreur) { depassement = d_vrai; } ((integer8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i][j] = cumul; } } } if (depassement == d_vrai) { (*s_objet_resultat).type = MRL; (*((struct_matrice *) (*s_objet_resultat).objet)).type = 'R'; if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * 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++) { free(((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i]); if (((*((struct_matrice *) (*s_objet_resultat).objet)) .tableau[i] = malloc((*(((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] = 0; for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { ((real8 *) accumulateur)[k] = ((real8) (((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][k]) * ((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[k][j])); } ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = sommation_vecteur_reel(accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } } free(accumulateur); } } /* * Matrice d'entiers / Matrice de réels */ else if ((((*s_objet_argument_2).type == MIN) && ((*s_objet_argument_1).type == MRL)) || (((*s_objet_argument_2).type == MRL) && ((*s_objet_argument_1).type == MIN))) { if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes != (*((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_2) .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((*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes * sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * 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 (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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++) { for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { if ((*s_objet_argument_1).type == MRL) { ((real8 *) accumulateur)[k] = (((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][k] * ((real8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[k][j]); } else { ((real8 *) accumulateur)[k] = (((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][k] * ((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[k][j]); } } ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = sommation_vecteur_reel(accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } } free(accumulateur); } /* * Matrice d'entiers / Matrice de complexes */ else if ((((*s_objet_argument_2).type == MIN) && ((*s_objet_argument_1).type == MCX)) || (((*s_objet_argument_2).type == MCX) && ((*s_objet_argument_1).type == MIN))) { if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes != (*((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_2) .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((*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * sizeof(complex16))) == 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_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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++) { for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { if ((*s_objet_argument_1).type == MCX) { f77multiplicationci_(&(((struct_complexe16 **) (*((struct_matrice *)(*s_objet_argument_1) .objet)).tableau)[k][j]), &(((integer8 **) (*((struct_matrice *) (*s_objet_argument_2) .objet)).tableau)[i][k]), &(((complex16 *) accumulateur)[k])); } else { f77multiplicationci_(&(((struct_complexe16 **) (*((struct_matrice *)(*s_objet_argument_2) .objet)).tableau)[i][k]), &(((integer8 **) (*((struct_matrice *) (*s_objet_argument_1) .objet)).tableau)[k][j]), &(((complex16 *) accumulateur)[k])); } } ((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = sommation_vecteur_complexe(accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } } free(accumulateur); } /* * Matrice de réels / Matrice de réels */ else if (((*s_objet_argument_2).type == MRL) && ((*s_objet_argument_1).type == MRL)) { if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes != (*((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_2) .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((*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes * sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * 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 (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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++) { for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { ((real8 *) accumulateur)[k] = (((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][k] * ((real8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[k][j]); } ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = sommation_vecteur_reel(accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } } free(accumulateur); } /* * Matrice de réels / Matrice de complexes */ else if ((((*s_objet_argument_2).type == MRL) && ((*s_objet_argument_1).type == MCX)) || (((*s_objet_argument_2).type == MCX) && ((*s_objet_argument_1).type == MRL))) { if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes != (*((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_2) .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((*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * sizeof(complex16))) == 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_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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++) { for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { if ((*s_objet_argument_1).type == MCX) { f77multiplicationcr_(&(((struct_complexe16 **) (*((struct_matrice *)(*s_objet_argument_1) .objet)).tableau)[k][j]), &(((real8 **) (*((struct_matrice *) (*s_objet_argument_2) .objet)).tableau)[i][k]), &(((complex16 *) accumulateur)[k])); } else { f77multiplicationcr_(&(((struct_complexe16 **) (*((struct_matrice *)(*s_objet_argument_2) .objet)).tableau)[i][k]), &(((real8 **) (*((struct_matrice *) (*s_objet_argument_1) .objet)).tableau)[k][j]), &(((complex16 *) accumulateur)[k])); } } ((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = sommation_vecteur_complexe(accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } } free(accumulateur); } /* * Matrice de complexes / Matrice de complexes */ else if (((*s_objet_argument_2).type == MCX) && ((*s_objet_argument_1).type == MCX)) { if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes != (*((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_2) .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((*(((struct_matrice *) (*s_objet_resultat) .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } if ((accumulateur = malloc((*(((struct_matrice *) (*s_objet_argument_2).objet))).nombre_colonnes * sizeof(complex16))) == 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_matrice *) (*s_objet_resultat).objet)).tableau[i] = malloc((*(((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++) { ((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] .partie_reelle = 0; ((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] .partie_imaginaire = 0; for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { f77multiplicationcc_(&(((struct_complexe16 **) (*((struct_matrice *)(*s_objet_argument_1) .objet)).tableau)[k][j]), &(((struct_complexe16 **) (*((struct_matrice *) (*s_objet_argument_2) .objet)).tableau)[i][k]), &(((complex16 *) accumulateur)[k])); } ((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = sommation_vecteur_complexe(accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2).objet))) .nombre_colonnes), &erreur_memoire); if (erreur_memoire == d_vrai) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } } } free(accumulateur); } /* -------------------------------------------------------------------------------- Multiplication 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_2).objet)) * (*((logical8 *) (*s_objet_argument_1).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)) = (*((integer8 *) (*s_objet_argument_2).objet)) * (*((logical8 *) (*s_objet_argument_1).objet)); } else { (*((logical8 *) (*s_objet_resultat).objet)) = (*((logical8 *) (*s_objet_argument_2).objet)) * (*((integer8 *) (*s_objet_argument_1).objet)); } } /* -------------------------------------------------------------------------------- Multiplication 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; 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)) = 0; } else if ((*((integer8 *) (*s_objet_argument_2).objet)) == 1) { drapeau = d_faux; s_objet_resultat = s_objet_argument_1; s_objet_argument_1 = NULL; } } else if ((*s_objet_argument_2).type == REL) { if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0) { drapeau = d_faux; 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)) = 0; } else if ((*((real8 *) (*s_objet_argument_2).objet)) == 1) { 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; if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((complex16 *) (*s_objet_resultat).objet)) .partie_reelle = 0; (*((complex16 *) (*s_objet_resultat).objet)) .partie_imaginaire = 0; } else if (((*((complex16 *) (*s_objet_argument_2).objet)) .partie_reelle == 1) && ((*((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; 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)) = 0; } else 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 ((*((integer8 *) (*s_objet_argument_1).objet)) == 0) { drapeau = d_faux; 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)) = 0; } else 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 == 0) && ((*((complex16 *) (*s_objet_argument_1).objet)).partie_imaginaire == 0)) { drapeau = d_faux; if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((complex16 *) (*s_objet_resultat).objet)) .partie_reelle = 0; (*((complex16 *) (*s_objet_resultat).objet)) .partie_imaginaire = 0; } else 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_multiplication; 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; 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)) = 0; } else if ((*((integer8 *) (*s_objet_argument_2).objet)) == 1) { drapeau = d_faux; s_objet_resultat = s_objet_argument_1; s_objet_argument_1 = NULL; } } else if ((*s_objet_argument_2).type == REL) { if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0) { drapeau = d_faux; 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)) = 0; } else if ((*((real8 *) (*s_objet_argument_2).objet)) == 1) { 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; if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((complex16 *) (*s_objet_resultat).objet)) .partie_reelle = 0; (*((complex16 *) (*s_objet_resultat).objet)) .partie_imaginaire = 0; } else if (((*((complex16 *) (*s_objet_argument_2).objet)) .partie_reelle == 1) && ((*((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_multiplication; 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; 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)) = 0; } else 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 ((*((integer8 *) (*s_objet_argument_1).objet)) == 0) { drapeau = d_faux; 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)) = 0; } else 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 == 0) && ((*((complex16 *) (*s_objet_argument_1).objet)).partie_imaginaire == 0)) { drapeau = d_faux; if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } (*((complex16 *) (*s_objet_resultat).objet)) .partie_reelle = 0; (*((complex16 *) (*s_objet_resultat).objet)) .partie_imaginaire = 0; } else 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_multiplication; 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_multiplication; 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, "*"); } /* -------------------------------------------------------------------------------- Multiplication 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 'mant' ================================================================================ Entrées : -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_mant(struct_processus *s_etat_processus) { real8 base_reelle; real8 reduction_reelle; integer8 base_entiere; integer8 exposant; integer8 reduction_entiere; struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_precedent; struct_objet *s_copie_argument; struct_objet *s_objet_argument; struct_objet *s_objet_resultat; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n MANT "); if ((*s_etat_processus).langue == 'F') { printf("(mantisse)\n\n"); } else { printf("(mantissa)\n\n"); } printf(" 1: %s, %s\n", d_INT, d_REL); printf("-> 1: %s\n\n", d_REL); printf(" 1: %s, %s\n", d_NOM, d_ALG); printf("-> 1: %s\n\n", d_ALG); printf(" 1: %s\n", d_RPN); 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, 1) == d_erreur) { return; } } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_objet_argument) == d_erreur) { (*s_etat_processus).erreur_execution = d_ex_manque_argument; return; } /* -------------------------------------------------------------------------------- Mantisse d'un entier -------------------------------------------------------------------------------- */ if ((*s_objet_argument).type == INT) { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } exposant = (integer8) floor(log10((*((integer8 *) (*s_objet_argument).objet)))); base_entiere = 10; f77puissanceii_(&base_entiere, &exposant, &reduction_entiere); (*((real8 *) (*s_objet_resultat).objet)) = ((real8) (*((integer8 *) (*s_objet_argument).objet))) / reduction_entiere; } /* -------------------------------------------------------------------------------- Mantisse d'un réel -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == REL) { if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } exposant = (integer8) floor(log10((*((real8 *) (*s_objet_argument).objet)))); base_reelle = 10; f77puissanceri_(&base_reelle, &exposant, &reduction_reelle); (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) (*s_objet_argument).objet)) / reduction_reelle; } /* -------------------------------------------------------------------------------- Mantisse d'un nom -------------------------------------------------------------------------------- */ else if ((*s_objet_argument).type == NOM) { 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; 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 = 1; (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .fonction = instruction_mant; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "MANT"); 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 = NULL; } /* -------------------------------------------------------------------------------- Mantisse d'une expression -------------------------------------------------------------------------------- */ else if (((*s_objet_argument).type == ALG) || ((*s_objet_argument).type == RPN)) { if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument, 'N')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } l_element_courant = (struct_liste_chainee *) (*s_copie_argument).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; } 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 = 1; (*((struct_fonction *) (*(*(*l_element_precedent).suivant) .donnee).objet)).fonction = instruction_mant; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc(5 * 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, "MANT"); (*(*l_element_precedent).suivant).suivant = l_element_courant; s_objet_resultat = s_copie_argument; } /* -------------------------------------------------------------------------------- Fonction mantisse impossible à réaliser -------------------------------------------------------------------------------- */ else { liberation(s_etat_processus, s_objet_argument); (*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); return; } /* ================================================================================ Fonction 'mod' ================================================================================ Entrées : -------------------------------------------------------------------------------- Sorties : -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ void instruction_mod(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; unsigned long i; unsigned long j; unsigned long nombre_elements; (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') { printf("\n MOD "); if ((*s_etat_processus).langue == 'F') { printf("(modulo)\n\n"); } else { printf("(modulo)\n\n"); } printf(" 2: %s, %s\n", d_INT, d_REL); printf(" 1: %s, %s\n", d_INT, d_REL); printf("-> 1: %s, %s\n\n", d_INT, d_REL); 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 = 2; 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; } /* -------------------------------------------------------------------------------- MOD 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_argument_1).type == INT) { if ((*s_objet_argument_2).type == INT) { 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)) = (*((integer8 *) (*s_objet_argument_2).objet)) - ((*((integer8 *) (*s_objet_argument_1).objet)) * floor(((real8) (*((integer8 *) (*s_objet_argument_2) .objet))) / ((real8) (*((integer8 *) (*s_objet_argument_1).objet))))); } 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 *) (*s_objet_argument_2).objet)) - ((*((integer8 *) (*s_objet_argument_1).objet)) * floor((*((real8 *) (*s_objet_argument_2) .objet)) / ((real8) (*((integer8 *) (*s_objet_argument_1).objet))))); } } else { if ((*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; } (*((real8 *) (*s_objet_resultat).objet)) = (*((integer8 *) (*s_objet_argument_2).objet)) - ((*((real8 *) (*s_objet_argument_1).objet)) * floor(((real8) (*((integer8 *) (*s_objet_argument_2) .objet))) / (*((real8 *) (*s_objet_argument_1).objet)))); } 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 *) (*s_objet_argument_2).objet)) - ((*((real8 *) (*s_objet_argument_1).objet)) * floor((*((real8 *) (*s_objet_argument_2) .objet)) / (*((real8 *) (*s_objet_argument_1).objet)))); } } } /* -------------------------------------------------------------------------------- MOD portant sur des vecteurs -------------------------------------------------------------------------------- */ else if ((((*s_objet_argument_1).type == INT) || ((*s_objet_argument_1).type == REL)) && (((*s_objet_argument_2).type == VIN) || ((*s_objet_argument_2).type == VRL))) { if ((*s_objet_argument_1).type == INT) { if ((*s_objet_argument_2).type == VIN) { 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_2).objet)) .taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*((struct_vecteur *) (*s_objet_resultat).objet)) .taille * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } for(i = 0; i < (*((struct_vecteur *) (*s_objet_resultat).objet)) .taille; i++) { ((integer8 *) (*((struct_vecteur *) (*s_objet_resultat) .objet)).tableau)[i] = ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)) .tableau)[i] - ((*((integer8 *) (*s_objet_argument_1).objet)) * floor(((real8) ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]) / ((real8) (*((integer8 *) (*s_objet_argument_1) .objet))))); } } else { 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_2).objet)) .taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*((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_2).objet)) .tableau)[i] - ((*((integer8 *) (*s_objet_argument_1).objet)) * floor( ((real8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i] / ((real8) (*((integer8 *) (*s_objet_argument_1) .objet))))); } } } else { if ((*s_objet_argument_2).type == VIN) { 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_2).objet)) .taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*((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] = ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)) .tableau)[i] - ((*((real8 *) (*s_objet_argument_1).objet)) * floor(((real8) ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]) / (*((real8 *) (*s_objet_argument_1) .objet)))); } } else { 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_2).objet)) .taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = malloc((*((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_2).objet)) .tableau)[i] - ((*((real8 *) (*s_objet_argument_1).objet)) * floor( ((real8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i] / (*((real8 *) (*s_objet_argument_1) .objet)))); } } } } /* -------------------------------------------------------------------------------- MOD portant sur des matrices -------------------------------------------------------------------------------- */ else if ((((*s_objet_argument_1).type == INT) || ((*s_objet_argument_1).type == REL)) && (((*s_objet_argument_2).type == MIN) || ((*s_objet_argument_2).type == MRL))) { if ((*s_objet_argument_1).type == INT) { if ((*s_objet_argument_2).type == MIN) { 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_2).objet)).nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)) .nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*((struct_matrice *) (*s_objet_resultat).objet)) .nombre_lignes * sizeof(integer8 *))) == 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 ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i] = malloc((*((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++) { ((integer8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i][j] = ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2) .objet)).tableau)[i][j] - ((*((integer8 *) (*s_objet_argument_1).objet)) * floor(((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]) / ((real8) (*((integer8 *) (*s_objet_argument_1) .objet))))); } } } else { 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_2).objet)).nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)) .nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*((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((*((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_2) .objet)).tableau)[i][j] - ((*((integer8 *) (*s_objet_argument_1).objet)) * floor( ((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j] / ((real8) (*((integer8 *) (*s_objet_argument_1) .objet))))); } } } } else { if ((*s_objet_argument_2).type == MIN) { 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_2).objet)).nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)) .nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*((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((*((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] = ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2) .objet)).tableau)[i][j] - ((*((real8 *) (*s_objet_argument_1).objet)) * floor(((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]) / (*((real8 *) (*s_objet_argument_1) .objet)))); } } } else { 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_2).objet)).nombre_lignes; (*((struct_matrice *) (*s_objet_resultat).objet)) .nombre_colonnes = (*((struct_matrice *) (*s_objet_argument_2).objet)).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = malloc((*((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((*((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_2) .objet)).tableau)[i][j] - ((*((real8 *) (*s_objet_argument_1).objet)) * floor( ((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j] / (*((real8 *) (*s_objet_argument_1) .objet)))); } } } } } /* -------------------------------------------------------------------------------- MOD 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_mod; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "MOD"); 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_mod; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc(4 * 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, "MOD"); (*(*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_mod; if (((*((struct_fonction *) (*(*(*l_element_precedent) .suivant).donnee).objet)).nom_fonction = malloc(4 * 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, "MOD"); (*(*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_mod; if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "MOD"); } /* -------------------------------------------------------------------------------- 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