--- rpl/src/instructions_m1.c 2013/02/27 17:11:42 1.41 +++ rpl/src/instructions_m1.c 2014/01/26 18:21:32 1.48 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.13 - Copyright (C) 1989-2013 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.17 + Copyright (C) 1989-2014 Dr. BERTRAND Joël This file is part of RPL/2. @@ -39,7 +39,6 @@ void instruction_moins(struct_processus *s_etat_processus) { integer8 tampon; - integer8 tampon_2; logical1 depassement; logical1 drapeau; @@ -54,9 +53,9 @@ instruction_moins(struct_processus *s_et struct_objet *s_objet_argument_2; struct_objet *s_objet_resultat; - unsigned long i; - unsigned long j; - unsigned long nombre_elements; + integer8 i; + integer8 j; + integer8 nombre_elements; (*s_etat_processus).erreur_execution = d_ex; @@ -136,10 +135,8 @@ instruction_moins(struct_processus *s_et 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) == + if (depassement_soustraction((integer8 *) (*s_objet_argument_2).objet, + (integer8 *) (*s_objet_argument_1).objet, &tampon) == d_absence_erreur) { if ((s_objet_resultat = allocation(s_etat_processus, INT)) @@ -161,8 +158,8 @@ instruction_moins(struct_processus *s_et } (*((real8 *) (*s_objet_resultat).objet)) = ((real8) - (-(*((integer8 *) (*s_objet_argument_1).objet)))) - + ((real8) (*((integer8 *) (*s_objet_argument_2).objet))); + (*((integer8 *) (*s_objet_argument_2).objet))) + - ((real8) (*((integer8 *) (*s_objet_argument_1).objet))); } } @@ -187,13 +184,13 @@ instruction_moins(struct_processus *s_et if ((*s_objet_argument_1).type == INT) { (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) - (*s_objet_argument_2).objet)) - (*((integer8 *) - (*s_objet_argument_1).objet)); + (*s_objet_argument_2).objet)) - ((real8) (*((integer8 *) + (*s_objet_argument_1).objet))); } else { - (*((real8 *) (*s_objet_resultat).objet)) = (*((integer8 *) - (*s_objet_argument_2).objet)) - (*((real8 *) + (*((real8 *) (*s_objet_resultat).objet)) = ((real8) (*((integer8 *) + (*s_objet_argument_2).objet))) - (*((real8 *) (*s_objet_argument_1).objet)); } } @@ -339,8 +336,8 @@ instruction_moins(struct_processus *s_et (*((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) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -351,11 +348,10 @@ instruction_moins(struct_processus *s_et 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, + if (depassement_soustraction(&(((integer8 *) (*((struct_vecteur *) + (*s_objet_argument_2).objet)).tableau)[i]), + &(((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1) + .objet)).tableau)[i]), &(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)).tableau)[i])) == d_erreur) { @@ -368,8 +364,8 @@ instruction_moins(struct_processus *s_et 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) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -422,8 +418,8 @@ instruction_moins(struct_processus *s_et (*((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) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -437,15 +433,15 @@ instruction_moins(struct_processus *s_et ((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]; + - ((real8) ((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 *) + .tableau)[i] = ((real8) ((integer8 *) + (*((struct_vecteur *) (*s_objet_argument_2).objet)) + .tableau)[i]) - ((real8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[i]; } } @@ -480,8 +476,8 @@ instruction_moins(struct_processus *s_et (*((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) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -529,8 +525,8 @@ instruction_moins(struct_processus *s_et (*((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) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -592,8 +588,8 @@ instruction_moins(struct_processus *s_et (*((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) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -653,8 +649,8 @@ instruction_moins(struct_processus *s_et (*((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) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -714,8 +710,8 @@ instruction_moins(struct_processus *s_et .nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(integer8 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(integer8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -727,9 +723,9 @@ instruction_moins(struct_processus *s_et .objet))).nombre_lignes; i++) { if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat) - .objet)).tableau)[i] = malloc((*(( + .objet)).tableau)[i] = malloc(((size_t) (*(( (struct_matrice *) (*s_objet_resultat).objet))) - .nombre_colonnes * sizeof(integer8))) == NULL) + .nombre_colonnes) * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -738,11 +734,10 @@ instruction_moins(struct_processus *s_et 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, + if (depassement_soustraction(&(((integer8 **) + (*((struct_matrice *) (*s_objet_argument_2).objet)) + .tableau)[i][j]), &(((integer8 **) (*((struct_matrice *) + (*s_objet_argument_1).objet)).tableau)[i][j]), &(((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j])) == d_erreur) @@ -764,9 +759,9 @@ instruction_moins(struct_processus *s_et (*s_objet_resultat).objet)).tableau)[i]); if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat) - .objet)).tableau)[i] = malloc((*(( + .objet)).tableau)[i] = malloc(((size_t) (*(( (struct_matrice *) (*s_objet_resultat).objet))) - .nombre_colonnes * sizeof(real8))) == NULL) + .nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -826,8 +821,8 @@ instruction_moins(struct_processus *s_et .nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(real8 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -837,9 +832,9 @@ instruction_moins(struct_processus *s_et .objet))).nombre_lignes; i++) { if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat) - .objet)).tableau)[i] = malloc((*(( + .objet)).tableau)[i] = malloc(((size_t) (*(( (struct_matrice *) (*s_objet_resultat).objet))) - .nombre_colonnes * sizeof(real8))) == NULL) + .nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -853,16 +848,16 @@ instruction_moins(struct_processus *s_et ((real8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i][j] = ((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) - .tableau)[i][j] - ((integer8 **) + .tableau)[i][j] - ((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)) - .tableau)[i][j]; + .tableau)[i][j]); } else { ((real8 **) (*((struct_matrice *) (*s_objet_resultat) - .objet)).tableau)[i][j] = ((integer8 **) + .objet)).tableau)[i][j] = ((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2) - .objet)).tableau)[i][j] - ((real8 **) + .objet)).tableau)[i][j]) - ((real8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)) .tableau)[i][j]; } @@ -907,8 +902,8 @@ instruction_moins(struct_processus *s_et .nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(real8 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -918,9 +913,9 @@ instruction_moins(struct_processus *s_et .objet))).nombre_lignes; i++) { if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat) - .objet)).tableau)[i] = malloc((*(( + .objet)).tableau)[i] = malloc(((size_t) (*(( (struct_matrice *) (*s_objet_resultat).objet))) - .nombre_colonnes * sizeof(real8))) == NULL) + .nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -977,8 +972,9 @@ instruction_moins(struct_processus *s_et .nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -988,9 +984,10 @@ instruction_moins(struct_processus *s_et .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_objet_resultat).objet)).tableau)[i] = malloc( + ((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(struct_complexe16))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -1061,8 +1058,9 @@ instruction_moins(struct_processus *s_et .nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -1072,9 +1070,9 @@ instruction_moins(struct_processus *s_et .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_objet_resultat).objet)).tableau)[i] = malloc(((size_t) + (*(((struct_matrice *) (*s_objet_resultat).objet))) + .nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -1143,8 +1141,9 @@ instruction_moins(struct_processus *s_et .nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -1154,9 +1153,9 @@ instruction_moins(struct_processus *s_et .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_objet_resultat).objet)).tableau)[i] = malloc(((size_t) + (*(((struct_matrice *) (*s_objet_resultat).objet))) + .nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -1219,14 +1218,15 @@ instruction_moins(struct_processus *s_et if ((*s_objet_argument_1).type == BIN) { (*((logical8 *) (*s_objet_resultat).objet)) = - (*((integer8 *) (*s_objet_argument_2).objet)) + ((logical8) (*((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)); + - ((logical8) (*((integer8 *) (*s_objet_argument_1) + .objet))); } } @@ -1938,10 +1938,10 @@ instruction_multiplication(struct_proces struct_objet *s_objet_argument_2; struct_objet *s_objet_resultat; - unsigned long i; - unsigned long j; - unsigned long k; - unsigned long nombre_elements; + integer8 i; + integer8 j; + integer8 k; + integer8 nombre_elements; void *accumulateur; @@ -2088,13 +2088,13 @@ instruction_multiplication(struct_proces if ((*s_objet_argument_1).type == INT) { (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) - (*s_objet_argument_2).objet)) * (*((integer8 *) - (*s_objet_argument_1).objet)); + (*s_objet_argument_2).objet)) * ((real8) (*((integer8 *) + (*s_objet_argument_1).objet))); } else { - (*((real8 *) (*s_objet_resultat).objet)) = (*((integer8 *) - (*s_objet_argument_2).objet)) * (*((real8 *) + (*((real8 *) (*s_objet_resultat).objet)) = ((real8) (*((integer8 *) + (*s_objet_argument_2).objet))) * (*((real8 *) (*s_objet_argument_1).objet)); } } @@ -2239,8 +2239,8 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_vecteur *) (*s_objet_resultat) - .objet))).taille * sizeof(integer8))) == NULL) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2281,8 +2281,8 @@ instruction_multiplication(struct_proces (*((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) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2339,8 +2339,8 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_vecteur *) (*s_objet_resultat) - .objet))).taille * sizeof(real8))) == NULL) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2352,16 +2352,18 @@ instruction_multiplication(struct_proces 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]; + .tableau)[i] = ((real8) (*((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]; + .tableau)[i] = ((real8) (*((integer8 *) + (*s_objet_argument_1).objet))) * ((real8 *) + (*((struct_vecteur *) (*s_objet_argument_2).objet)) + .tableau)[i]; } } } @@ -2394,8 +2396,8 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_vecteur *) (*s_objet_resultat) - .objet))).taille * sizeof(struct_complexe16))) == NULL) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2453,8 +2455,8 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_vecteur *) (*s_objet_resultat) - .objet))).taille * sizeof(real8))) == NULL) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2467,15 +2469,15 @@ instruction_multiplication(struct_proces { ((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]; + .objet)) * ((real8) ((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]; + .objet)) * ((real8) ((integer8 *) (*((struct_vecteur *) + (*s_objet_argument_2).objet)).tableau)[i]); } } } @@ -2508,8 +2510,8 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_vecteur *) (*s_objet_resultat) - .objet))).taille * sizeof(real8))) == NULL) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2563,8 +2565,8 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_vecteur *) (*s_objet_resultat) - .objet))).taille * sizeof(struct_complexe16))) == NULL) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2622,8 +2624,8 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_vecteur *) (*s_objet_resultat) - .objet))).taille * sizeof(struct_complexe16))) == NULL) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2681,8 +2683,8 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_vecteur *) (*s_objet_resultat) - .objet))).taille * sizeof(struct_complexe16))) == NULL) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2740,8 +2742,8 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_vecteur *) (*s_objet_resultat) - .objet))).taille * sizeof(struct_complexe16))) == NULL) + malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat) + .objet))).taille) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2814,8 +2816,8 @@ instruction_multiplication(struct_proces } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(integer8 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(integer8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2827,8 +2829,8 @@ instruction_multiplication(struct_proces .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) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2876,8 +2878,8 @@ instruction_multiplication(struct_proces (*s_objet_resultat).objet)).tableau)[i]); if (((*((struct_matrice *) (*s_objet_resultat).objet)) - .tableau[i] = malloc((*(((struct_matrice *) - (*s_objet_resultat).objet))).nombre_colonnes * + .tableau[i] = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_resultat).objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = @@ -2947,8 +2949,8 @@ instruction_multiplication(struct_proces } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(real8 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2958,8 +2960,8 @@ instruction_multiplication(struct_proces .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) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -2972,16 +2974,16 @@ instruction_multiplication(struct_proces { ((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i][j] = - (*((integer8 *) (*s_objet_argument_2) - .objet)) * ((real8 **) (*((struct_matrice *) + ((real8) (*((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 *) + ((real8) (*((integer8 *) (*s_objet_argument_1) + .objet))) * ((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]; } } @@ -3024,8 +3026,9 @@ instruction_multiplication(struct_proces } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -3035,8 +3038,8 @@ instruction_multiplication(struct_proces .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))) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3104,8 +3107,8 @@ instruction_multiplication(struct_proces } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(real8 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -3115,8 +3118,8 @@ instruction_multiplication(struct_proces .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) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -3130,16 +3133,16 @@ instruction_multiplication(struct_proces ((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]; + .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 *) (*s_objet_argument_1) - .objet)) * ((integer8 **) (*((struct_matrice *) - (*s_objet_argument_2).objet)).tableau)[i][j]; + .objet)) * ((real8) ((integer8 **) (*((struct_matrice *) + (*s_objet_argument_2).objet)).tableau)[i][j]); } } } @@ -3181,8 +3184,8 @@ instruction_multiplication(struct_proces } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(real8 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -3192,8 +3195,8 @@ instruction_multiplication(struct_proces .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) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -3258,8 +3261,9 @@ instruction_multiplication(struct_proces } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -3269,8 +3273,8 @@ instruction_multiplication(struct_proces .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))) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3338,8 +3342,9 @@ instruction_multiplication(struct_proces } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -3349,8 +3354,8 @@ instruction_multiplication(struct_proces .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))) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3418,8 +3423,9 @@ instruction_multiplication(struct_proces } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -3429,8 +3435,8 @@ instruction_multiplication(struct_proces .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))) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3498,8 +3504,9 @@ instruction_multiplication(struct_proces } if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -3509,8 +3516,8 @@ instruction_multiplication(struct_proces .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))) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3578,8 +3585,8 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_argument_2) - .objet))).nombre_lignes * sizeof(integer8))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_argument_2) + .objet))).nombre_lignes) * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -3623,8 +3630,9 @@ instruction_multiplication(struct_proces (*((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) + malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_lignes) * + sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -3683,15 +3691,15 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_argument_2) - .objet))).nombre_lignes * sizeof(real8))) == NULL) + malloc(((size_t) (*(((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 * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3704,10 +3712,10 @@ instruction_multiplication(struct_proces for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { - ((real8 *) accumulateur)[k] = (((integer8 **) + ((real8 *) accumulateur)[k] = ((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)) - .tableau)[i][k] * ((real8 *) (*((struct_vecteur *) - (*s_objet_argument_1).objet)).tableau)[k]); + .tableau)[i][k]) * ((real8 *) (*((struct_vecteur *) + (*s_objet_argument_1).objet)).tableau)[k]; } ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet)) @@ -3756,15 +3764,15 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_argument_2) - .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL) + malloc(((size_t) (*(((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 * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3830,15 +3838,15 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_argument_2) - .objet))).nombre_lignes * sizeof(real8))) == NULL) + malloc(((size_t) (*(((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 * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3851,9 +3859,9 @@ instruction_multiplication(struct_proces for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2) .objet))).nombre_colonnes; k++) { - ((real8 *) accumulateur)[k] = (((real8 **) (*((struct_matrice *) + ((real8 *) accumulateur)[k] = ((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][k] * - ((integer8 *) (*((struct_vecteur *) + ((real8) ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[k]); } @@ -3903,15 +3911,15 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_argument_2) - .objet))).nombre_lignes * sizeof(real8))) == NULL) + malloc(((size_t) (*(((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 * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3976,15 +3984,15 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_argument_2) - .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL) + malloc(((size_t) (*(((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 * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4050,15 +4058,15 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_argument_2) - .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL) + malloc(((size_t) (*(((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 * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4124,15 +4132,15 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_argument_2) - .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL) + malloc(((size_t) (*(((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 * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4198,15 +4206,15 @@ instruction_multiplication(struct_proces } if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_argument_2) - .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL) + malloc(((size_t) (*(((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 * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4279,8 +4287,8 @@ instruction_multiplication(struct_proces .objet))).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(integer8 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(integer8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -4292,8 +4300,8 @@ instruction_multiplication(struct_proces .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) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -4335,8 +4343,8 @@ instruction_multiplication(struct_proces (*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 * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4350,8 +4358,8 @@ instruction_multiplication(struct_proces (*s_objet_resultat).objet)).tableau)[i]); if (((*((struct_matrice *) (*s_objet_resultat).objet)) - .tableau[i] = malloc((*(((struct_matrice *) - (*s_objet_resultat).objet))).nombre_colonnes * + .tableau[i] = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_resultat).objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = @@ -4429,15 +4437,15 @@ instruction_multiplication(struct_proces .objet))).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(real8 *))) == NULL) + malloc(((size_t) (*(((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 * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4448,8 +4456,8 @@ instruction_multiplication(struct_proces .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) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -4464,17 +4472,17 @@ instruction_multiplication(struct_proces if ((*s_objet_argument_1).type == MRL) { ((real8 *) accumulateur)[k] = - (((integer8 **) (*((struct_matrice *) - (*s_objet_argument_2).objet)).tableau)[i][k] * + ((real8) ((integer8 **) (*((struct_matrice *) + (*s_objet_argument_2).objet)).tableau)[i][k]) * ((real8 **) (*((struct_matrice *) - (*s_objet_argument_1).objet)).tableau)[k][j]); + (*s_objet_argument_1).objet)).tableau)[k][j]; } else { ((real8 *) accumulateur)[k] = - (((real8 **) (*((struct_matrice *) + ((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][k] * - ((integer8 **) (*((struct_matrice *) + ((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_1).objet)).tableau)[k][j]); } } @@ -4532,15 +4540,16 @@ instruction_multiplication(struct_proces .objet))).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } - if ((accumulateur = malloc((*(((struct_matrice *) - (*s_objet_argument_2).objet))).nombre_colonnes * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4551,8 +4560,8 @@ instruction_multiplication(struct_proces .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))) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4636,15 +4645,15 @@ instruction_multiplication(struct_proces .objet))).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(real8 *))) == NULL) + malloc(((size_t) (*(((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 * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4655,8 +4664,8 @@ instruction_multiplication(struct_proces .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) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -4728,15 +4737,16 @@ instruction_multiplication(struct_proces .objet))).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } - if ((accumulateur = malloc((*(((struct_matrice *) - (*s_objet_argument_2).objet))).nombre_colonnes * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4747,8 +4757,8 @@ instruction_multiplication(struct_proces .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))) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4832,15 +4842,16 @@ instruction_multiplication(struct_proces .objet))).nombre_colonnes; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*(((struct_matrice *) (*s_objet_resultat) - .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_lignes) * sizeof(struct_complexe16 *))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } - if ((accumulateur = malloc((*(((struct_matrice *) - (*s_objet_argument_2).objet))).nombre_colonnes * + if ((accumulateur = malloc(((size_t) (*(((struct_matrice *) + (*s_objet_argument_2).objet))).nombre_colonnes) * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4851,8 +4862,8 @@ instruction_multiplication(struct_proces .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))) + malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat) + .objet))).nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -4941,14 +4952,15 @@ instruction_multiplication(struct_proces if ((*s_objet_argument_1).type == BIN) { (*((logical8 *) (*s_objet_resultat).objet)) = - (*((integer8 *) (*s_objet_argument_2).objet)) + ((logical8) (*((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)); + * ((logical8) (*((integer8 *) (*s_objet_argument_1) + .objet))); } } @@ -5867,7 +5879,7 @@ instruction_mant(struct_processus *s_eta return; } - exposant = (integer8) floor(log10((*((integer8 *) + exposant = (integer8) floor(log10((real8) (*((integer8 *) (*s_objet_argument).objet)))); base_entiere = 10; @@ -5875,7 +5887,7 @@ instruction_mant(struct_processus *s_eta (*((real8 *) (*s_objet_resultat).objet)) = ((real8) (*((integer8 *) (*s_objet_argument).objet))) / - reduction_entiere; + ((real8) reduction_entiere); } /* @@ -6134,9 +6146,9 @@ instruction_mod(struct_processus *s_etat struct_objet *s_objet_argument_2; struct_objet *s_objet_resultat; - unsigned long i; - unsigned long j; - unsigned long nombre_elements; + integer8 i; + integer8 j; + integer8 nombre_elements; (*s_etat_processus).erreur_execution = d_ex; @@ -6221,9 +6233,9 @@ instruction_mod(struct_processus *s_etat (*((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))))); + ((integer8) floor(((real8) (*((integer8 *) + (*s_objet_argument_2).objet))) / ((real8) + (*((integer8 *) (*s_objet_argument_1).objet)))))); } else { @@ -6237,7 +6249,7 @@ instruction_mod(struct_processus *s_etat (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) (*s_objet_argument_2).objet)) - - ((*((integer8 *) (*s_objet_argument_1).objet)) * + ((real8) (*((integer8 *) (*s_objet_argument_1).objet)) * floor((*((real8 *) (*s_objet_argument_2) .objet)) / ((real8) (*((integer8 *) (*s_objet_argument_1).objet))))); @@ -6255,8 +6267,8 @@ instruction_mod(struct_processus *s_etat return; } - (*((real8 *) (*s_objet_resultat).objet)) = - (*((integer8 *) (*s_objet_argument_2).objet)) - + (*((real8 *) (*s_objet_resultat).objet)) = ((real8) + (*((integer8 *) (*s_objet_argument_2).objet))) - ((*((real8 *) (*s_objet_argument_1).objet)) * floor(((real8) (*((integer8 *) (*s_objet_argument_2) .objet))) / (*((real8 *) @@ -6310,8 +6322,9 @@ instruction_mod(struct_processus *s_etat .taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*((struct_vecteur *) (*s_objet_resultat).objet)) - .taille * sizeof(integer8))) == NULL) + malloc(((size_t) (*((struct_vecteur *) + (*s_objet_resultat).objet)).taille) * sizeof(integer8))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -6325,11 +6338,11 @@ instruction_mod(struct_processus *s_etat .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_1).objet)) * ((integer8) + floor(((real8) ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]) / ((real8) (*((integer8 *) (*s_objet_argument_1) - .objet))))); + .objet)))))); } } else @@ -6347,8 +6360,9 @@ instruction_mod(struct_processus *s_etat .taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*((struct_vecteur *) (*s_objet_resultat).objet)) - .taille * sizeof(real8))) == NULL) + malloc(((size_t) (*((struct_vecteur *) + (*s_objet_resultat).objet)).taille) * sizeof(real8))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -6361,7 +6375,7 @@ instruction_mod(struct_processus *s_etat ((real8 *) (*((struct_vecteur *) (*s_objet_resultat) .objet)).tableau)[i] = ((real8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)) - .tableau)[i] - ((*((integer8 *) + .tableau)[i] - ((real8) (*((integer8 *) (*s_objet_argument_1).objet)) * floor( ((real8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i] / @@ -6387,8 +6401,9 @@ instruction_mod(struct_processus *s_etat .taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*((struct_vecteur *) (*s_objet_resultat).objet)) - .taille * sizeof(real8))) == NULL) + malloc(((size_t) (*((struct_vecteur *) + (*s_objet_resultat).objet)).taille) * sizeof(real8))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -6399,9 +6414,9 @@ instruction_mod(struct_processus *s_etat .taille; i++) { ((real8 *) (*((struct_vecteur *) (*s_objet_resultat) - .objet)).tableau)[i] = ((integer8 *) + .objet)).tableau)[i] = ((real8) ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)) - .tableau)[i] - ((*((real8 *) + .tableau)[i]) - ((*((real8 *) (*s_objet_argument_1).objet)) * floor(((real8) ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2).objet)).tableau)[i]) / @@ -6424,8 +6439,9 @@ instruction_mod(struct_processus *s_etat .taille; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau = - malloc((*((struct_vecteur *) (*s_objet_resultat).objet)) - .taille * sizeof(real8))) == NULL) + malloc(((size_t) (*((struct_vecteur *) + (*s_objet_resultat).objet)).taille) * sizeof(real8))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -6480,8 +6496,9 @@ instruction_mod(struct_processus *s_etat (*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) + malloc(((size_t) (*((struct_matrice *) + (*s_objet_resultat).objet)).nombre_lignes) * + sizeof(integer8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -6493,9 +6510,9 @@ instruction_mod(struct_processus *s_etat { if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i] = - malloc((*((struct_matrice *) (*s_objet_resultat) - .objet)).nombre_colonnes * sizeof(integer8))) - == NULL) + malloc(((size_t) (*((struct_matrice *) + (*s_objet_resultat).objet)).nombre_colonnes) + * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -6509,11 +6526,12 @@ instruction_mod(struct_processus *s_etat .objet)).tableau)[i][j] = ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2) .objet)).tableau)[i][j] - ((*((integer8 *) - (*s_objet_argument_1).objet)) * floor(((real8) + (*s_objet_argument_1).objet)) * + ((integer8) floor(((real8) ((integer8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j]) / ((real8) (*((integer8 *) (*s_objet_argument_1) - .objet))))); + .objet)))))); } } } @@ -6535,8 +6553,9 @@ instruction_mod(struct_processus *s_etat (*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) + malloc(((size_t) (*((struct_matrice *) + (*s_objet_resultat).objet)).nombre_lignes) * + sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -6548,9 +6567,9 @@ instruction_mod(struct_processus *s_etat { if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i] = - malloc((*((struct_matrice *) (*s_objet_resultat) - .objet)).nombre_colonnes * sizeof(real8))) - == NULL) + malloc(((size_t) (*((struct_matrice *) + (*s_objet_resultat).objet)).nombre_colonnes) * + sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -6563,7 +6582,8 @@ instruction_mod(struct_processus *s_etat ((real8 **) (*((struct_matrice *) (*s_objet_resultat) .objet)).tableau)[i][j] = ((real8 **) (*((struct_matrice *) (*s_objet_argument_2) - .objet)).tableau)[i][j] - ((*((integer8 *) + .objet)).tableau)[i][j] - + ((real8) (*((integer8 *) (*s_objet_argument_1).objet)) * floor( ((real8 **) (*((struct_matrice *) (*s_objet_argument_2).objet)).tableau)[i][j] / @@ -6593,8 +6613,9 @@ instruction_mod(struct_processus *s_etat (*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) + malloc(((size_t) (*((struct_matrice *) + (*s_objet_resultat).objet)).nombre_lignes) * + sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -6606,9 +6627,9 @@ instruction_mod(struct_processus *s_etat { if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i] = - malloc((*((struct_matrice *) (*s_objet_resultat) - .objet)).nombre_colonnes * sizeof(real8))) - == NULL) + malloc(((size_t) (*((struct_matrice *) + (*s_objet_resultat).objet)).nombre_colonnes) + * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -6619,14 +6640,14 @@ instruction_mod(struct_processus *s_etat .objet)).nombre_colonnes; j++) { ((real8 **) (*((struct_matrice *) (*s_objet_resultat) - .objet)).tableau)[i][j] = ((integer8 **) + .objet)).tableau)[i][j] = ((real8) + ((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)) * floor(((real8) - ((integer8 **) (*((struct_matrice *) - (*s_objet_argument_2).objet)).tableau)[i][j]) / - (*((real8 *) (*s_objet_argument_1) - .objet)))); + .objet)).tableau)[i][j]) / (*((real8 *) + (*s_objet_argument_1).objet)))); } } } @@ -6648,8 +6669,9 @@ instruction_mod(struct_processus *s_etat (*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) + malloc(((size_t) (*((struct_matrice *) + (*s_objet_resultat).objet)).nombre_lignes) * + sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -6661,9 +6683,9 @@ instruction_mod(struct_processus *s_etat { if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i] = - malloc((*((struct_matrice *) (*s_objet_resultat) - .objet)).nombre_colonnes * sizeof(real8))) - == NULL) + malloc(((size_t) (*((struct_matrice *) + (*s_objet_resultat).objet)).nombre_colonnes) * + sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;