Annotation of rpl/src/instructions_m1.c, revision 1.1
1.1 ! bertrand 1: /*
! 2: ================================================================================
! 3: RPL/2 (R) version 4.0.9
! 4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
! 5:
! 6: This file is part of RPL/2.
! 7:
! 8: RPL/2 is free software; you can redistribute it and/or modify it
! 9: under the terms of the CeCILL V2 License as published by the french
! 10: CEA, CNRS and INRIA.
! 11:
! 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
! 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
! 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
! 15: for more details.
! 16:
! 17: You should have received a copy of the CeCILL License
! 18: along with RPL/2. If not, write to info@cecill.info.
! 19: ================================================================================
! 20: */
! 21:
! 22:
! 23: #include "rpl.conv.h"
! 24:
! 25:
! 26: /*
! 27: ================================================================================
! 28: Fonction '-'
! 29: ================================================================================
! 30: Entrées : structure processus
! 31: --------------------------------------------------------------------------------
! 32: Sorties :
! 33: --------------------------------------------------------------------------------
! 34: Effets de bord : néant
! 35: ================================================================================
! 36: */
! 37:
! 38: void
! 39: instruction_moins(struct_processus *s_etat_processus)
! 40: {
! 41: integer8 tampon;
! 42: integer8 tampon_2;
! 43:
! 44: logical1 depassement;
! 45: logical1 drapeau;
! 46: logical1 drapeau_neg;
! 47:
! 48: struct_liste_chainee *l_element_courant;
! 49: struct_liste_chainee *l_element_precedent;
! 50:
! 51: struct_objet *s_copie_argument_1;
! 52: struct_objet *s_copie_argument_2;
! 53: struct_objet *s_objet_argument_1;
! 54: struct_objet *s_objet_argument_2;
! 55: struct_objet *s_objet_resultat;
! 56:
! 57: unsigned long i;
! 58: unsigned long j;
! 59: unsigned long nombre_elements;
! 60:
! 61: (*s_etat_processus).erreur_execution = d_ex;
! 62:
! 63: if ((*s_etat_processus).affichage_arguments == 'Y')
! 64: {
! 65: printf("\n - ");
! 66:
! 67: if ((*s_etat_processus).langue == 'F')
! 68: {
! 69: printf("(soustraction)\n\n");
! 70: }
! 71: else
! 72: {
! 73: printf("(substraction)\n\n");
! 74: }
! 75:
! 76: printf(" 2: %s, %s, %s\n", d_INT, d_REL, d_CPL);
! 77: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
! 78: printf("-> 1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL);
! 79:
! 80: printf(" 2: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
! 81: printf(" 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
! 82: printf("-> 1: %s, %s, %s\n\n", d_VIN, d_VRL, d_VCX);
! 83:
! 84: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 85: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 86: printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX);
! 87:
! 88: printf(" 2: %s, %s\n", d_BIN, d_INT);
! 89: printf(" 1: %s, %s\n", d_BIN, d_INT);
! 90: printf("-> 1: %s\n\n", d_BIN);
! 91:
! 92: printf(" 2: %s, %s, %s, %s, %s, %s\n",
! 93: d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN);
! 94: printf(" 1: %s, %s, %s, %s, %s, %s\n",
! 95: d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN);
! 96: printf("-> 1: %s, %s\n", d_ALG, d_RPN);
! 97:
! 98: return;
! 99: }
! 100: else if ((*s_etat_processus).test_instruction == 'Y')
! 101: {
! 102: (*s_etat_processus).nombre_arguments = 0;
! 103: return;
! 104: }
! 105:
! 106: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 107: {
! 108: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 109: {
! 110: return;
! 111: }
! 112: }
! 113:
! 114: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 115: &s_objet_argument_1) == d_erreur)
! 116: {
! 117: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 118: return;
! 119: }
! 120:
! 121: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 122: &s_objet_argument_2) == d_erreur)
! 123: {
! 124: liberation(s_etat_processus, s_objet_argument_1);
! 125:
! 126: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 127: return;
! 128: }
! 129:
! 130: /*
! 131: --------------------------------------------------------------------------------
! 132: Soustraction de deux entiers
! 133: --------------------------------------------------------------------------------
! 134: */
! 135:
! 136: if (((*s_objet_argument_1).type == INT) &&
! 137: ((*s_objet_argument_2).type == INT))
! 138: {
! 139: tampon_2 = -(*((integer8 *) (*s_objet_argument_1).objet));
! 140:
! 141: if (depassement_addition(&tampon_2,
! 142: (integer8 *) (*s_objet_argument_2).objet, &tampon) ==
! 143: d_absence_erreur)
! 144: {
! 145: if ((s_objet_resultat = allocation(s_etat_processus, INT))
! 146: == NULL)
! 147: {
! 148: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 149: return;
! 150: }
! 151:
! 152: (*((integer8 *) (*s_objet_resultat).objet)) = tampon;
! 153: }
! 154: else
! 155: {
! 156: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 157: == NULL)
! 158: {
! 159: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 160: return;
! 161: }
! 162:
! 163: (*((real8 *) (*s_objet_resultat).objet)) = ((real8)
! 164: (-(*((integer8 *) (*s_objet_argument_1).objet))))
! 165: + ((real8) (*((integer8 *) (*s_objet_argument_2).objet)));
! 166: }
! 167: }
! 168:
! 169: /*
! 170: --------------------------------------------------------------------------------
! 171: Soustraction d'un entier et d'un réel
! 172: --------------------------------------------------------------------------------
! 173: */
! 174:
! 175: else if ((((*s_objet_argument_1).type == INT) &&
! 176: ((*s_objet_argument_2).type == REL)) ||
! 177: (((*s_objet_argument_1).type == REL) &&
! 178: ((*s_objet_argument_2).type == INT)))
! 179: {
! 180: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 181: == NULL)
! 182: {
! 183: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 184: return;
! 185: }
! 186:
! 187: if ((*s_objet_argument_1).type == INT)
! 188: {
! 189: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
! 190: (*s_objet_argument_2).objet)) - (*((integer8 *)
! 191: (*s_objet_argument_1).objet));
! 192: }
! 193: else
! 194: {
! 195: (*((real8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
! 196: (*s_objet_argument_2).objet)) - (*((real8 *)
! 197: (*s_objet_argument_1).objet));
! 198: }
! 199: }
! 200:
! 201: /*
! 202: --------------------------------------------------------------------------------
! 203: Soustraction d'un entier et d'un complexe
! 204: --------------------------------------------------------------------------------
! 205: */
! 206:
! 207: else if ((((*s_objet_argument_1).type == INT) &&
! 208: ((*s_objet_argument_2).type == CPL)) ||
! 209: (((*s_objet_argument_1).type == CPL) &&
! 210: ((*s_objet_argument_2).type == INT)))
! 211: {
! 212: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 213: == NULL)
! 214: {
! 215: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 216: return;
! 217: }
! 218:
! 219: if ((*s_objet_argument_1).type == INT)
! 220: {
! 221: f77soustractionci_((struct_complexe16 *) (*s_objet_argument_2)
! 222: .objet, (integer8 *) (*s_objet_argument_1).objet,
! 223: (struct_complexe16 *) (*s_objet_resultat).objet);
! 224: }
! 225: else
! 226: {
! 227: f77soustractionic_((integer8 *) (*s_objet_argument_2).objet,
! 228: (struct_complexe16 *) (*s_objet_argument_1).objet,
! 229: (struct_complexe16 *) (*s_objet_resultat).objet);
! 230: }
! 231: }
! 232:
! 233: /*
! 234: --------------------------------------------------------------------------------
! 235: Soustraction de deux réels
! 236: --------------------------------------------------------------------------------
! 237: */
! 238:
! 239: else if (((*s_objet_argument_1).type == REL) &&
! 240: ((*s_objet_argument_2).type == REL))
! 241: {
! 242: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 243: == NULL)
! 244: {
! 245: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 246: return;
! 247: }
! 248:
! 249: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
! 250: (*s_objet_argument_2).objet)) - (*((real8 *)
! 251: (*s_objet_argument_1).objet));
! 252: }
! 253:
! 254: /*
! 255: --------------------------------------------------------------------------------
! 256: Soustraction d'un réel et d'un complexe
! 257: --------------------------------------------------------------------------------
! 258: */
! 259:
! 260: else if ((((*s_objet_argument_1).type == REL) &&
! 261: ((*s_objet_argument_2).type == CPL)) ||
! 262: (((*s_objet_argument_1).type == CPL) &&
! 263: ((*s_objet_argument_2).type == REL)))
! 264: {
! 265: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 266: == NULL)
! 267: {
! 268: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 269: return;
! 270: }
! 271:
! 272: if ((*s_objet_argument_1).type == REL)
! 273: {
! 274: f77soustractioncr_((struct_complexe16 *)
! 275: (*s_objet_argument_2).objet,
! 276: (real8 *) (*s_objet_argument_1).objet,
! 277: (struct_complexe16 *) (*s_objet_resultat).objet);
! 278: }
! 279: else
! 280: {
! 281: f77soustractionrc_((real8 *) (*s_objet_argument_2).objet,
! 282: (struct_complexe16 *) (*s_objet_argument_1).objet,
! 283: (struct_complexe16 *) (*s_objet_resultat).objet);
! 284: }
! 285: }
! 286:
! 287: /*
! 288: --------------------------------------------------------------------------------
! 289: Soustraction de deux complexes
! 290: --------------------------------------------------------------------------------
! 291: */
! 292:
! 293: else if (((*s_objet_argument_1).type == CPL) &&
! 294: ((*s_objet_argument_2).type == CPL))
! 295: {
! 296: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 297: == NULL)
! 298: {
! 299: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 300: return;
! 301: }
! 302:
! 303: f77soustractioncc_((struct_complexe16 *) (*s_objet_argument_2).objet,
! 304: (struct_complexe16 *) (*s_objet_argument_1).objet,
! 305: (struct_complexe16 *) (*s_objet_resultat).objet);
! 306: }
! 307:
! 308: /*
! 309: --------------------------------------------------------------------------------
! 310: Soustraction de deux vecteurs
! 311: --------------------------------------------------------------------------------
! 312: */
! 313: /*
! 314: * Entier / Entier
! 315: */
! 316:
! 317: else if (((*s_objet_argument_1).type == VIN) &&
! 318: ((*s_objet_argument_2).type == VIN))
! 319: {
! 320: if ((s_objet_resultat = allocation(s_etat_processus, VIN))
! 321: == NULL)
! 322: {
! 323: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 324: return;
! 325: }
! 326:
! 327: if ((*(((struct_vecteur *) (*s_objet_argument_1).objet))).taille !=
! 328: (*(((struct_vecteur *) (*s_objet_argument_2).objet))).taille)
! 329: {
! 330: liberation(s_etat_processus, s_objet_argument_1);
! 331: liberation(s_etat_processus, s_objet_argument_2);
! 332: liberation(s_etat_processus, s_objet_resultat);
! 333:
! 334: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 335: return;
! 336: }
! 337:
! 338: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 339: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 340:
! 341: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 342: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 343: .objet))).taille * sizeof(integer8))) == NULL)
! 344: {
! 345: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 346: return;
! 347: }
! 348:
! 349: depassement = d_faux;
! 350:
! 351: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 352: .objet))).taille; i++)
! 353: {
! 354: tampon = -((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1)
! 355: .objet)).tableau)[i];
! 356:
! 357: if (depassement_addition(&(((integer8 *) (*((struct_vecteur *)
! 358: (*s_objet_argument_2).objet)).tableau)[i]), &tampon,
! 359: &(((integer8 *) (*((struct_vecteur *)
! 360: (*s_objet_resultat).objet)).tableau)[i])) == d_erreur)
! 361: {
! 362: depassement = d_vrai;
! 363: }
! 364: }
! 365:
! 366: if (depassement == d_vrai)
! 367: {
! 368: free((*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau);
! 369:
! 370: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 371: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 372: .objet))).taille * sizeof(real8))) == NULL)
! 373: {
! 374: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 375: return;
! 376: }
! 377:
! 378: (*s_objet_resultat).type = VRL;
! 379: (*((struct_vecteur *) (*s_objet_resultat).objet)).type = 'R';
! 380:
! 381: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 382: .objet))).taille; i++)
! 383: {
! 384: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 385: .tableau)[i] = (real8) (((integer8 *)
! 386: (*((struct_vecteur *) (*s_objet_argument_2).objet))
! 387: .tableau)[i]) - (real8) (((integer8 *)
! 388: (*((struct_vecteur *) (*s_objet_argument_1)
! 389: .objet)).tableau)[i]);
! 390: }
! 391: }
! 392: }
! 393:
! 394: /*
! 395: * Entier / Réel
! 396: */
! 397:
! 398: else if ((((*s_objet_argument_1).type == VIN) &&
! 399: ((*s_objet_argument_2).type == VRL)) ||
! 400: (((*s_objet_argument_1).type == VRL) &&
! 401: ((*s_objet_argument_2).type == VIN)))
! 402: {
! 403: if ((s_objet_resultat = allocation(s_etat_processus, VRL))
! 404: == NULL)
! 405: {
! 406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 407: return;
! 408: }
! 409:
! 410: if ((*(((struct_vecteur *) (*s_objet_argument_1).objet))).taille !=
! 411: (*(((struct_vecteur *) (*s_objet_argument_2).objet))).taille)
! 412: {
! 413: liberation(s_etat_processus, s_objet_argument_1);
! 414: liberation(s_etat_processus, s_objet_argument_2);
! 415: liberation(s_etat_processus, s_objet_resultat);
! 416:
! 417: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 418: return;
! 419: }
! 420:
! 421: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 422: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 423:
! 424: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 425: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 426: .objet))).taille * sizeof(real8))) == NULL)
! 427: {
! 428: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 429: return;
! 430: }
! 431:
! 432: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 433: .objet))).taille; i++)
! 434: {
! 435: if ((*s_objet_argument_1).type == VIN)
! 436: {
! 437: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 438: .tableau)[i] = ((real8 *) (*((struct_vecteur *)
! 439: (*s_objet_argument_2).objet)).tableau)[i]
! 440: - ((integer8 *) (*((struct_vecteur *)
! 441: (*s_objet_argument_1).objet)).tableau)[i];
! 442: }
! 443: else
! 444: {
! 445: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 446: .tableau)[i] = ((integer8 *) (*((struct_vecteur *)
! 447: (*s_objet_argument_2).objet)).tableau)[i]
! 448: - ((real8 *) (*((struct_vecteur *)
! 449: (*s_objet_argument_1).objet)).tableau)[i];
! 450: }
! 451: }
! 452: }
! 453:
! 454: /*
! 455: * Réel / Réel
! 456: */
! 457:
! 458: else if (((*s_objet_argument_1).type == VRL) &&
! 459: ((*s_objet_argument_2).type == VRL))
! 460: {
! 461: if ((s_objet_resultat = allocation(s_etat_processus, VRL))
! 462: == NULL)
! 463: {
! 464: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 465: return;
! 466: }
! 467:
! 468: if ((*(((struct_vecteur *) (*s_objet_argument_1).objet))).taille !=
! 469: (*(((struct_vecteur *) (*s_objet_argument_2).objet))).taille)
! 470: {
! 471: liberation(s_etat_processus, s_objet_argument_1);
! 472: liberation(s_etat_processus, s_objet_argument_2);
! 473: liberation(s_etat_processus, s_objet_resultat);
! 474:
! 475: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 476: return;
! 477: }
! 478:
! 479: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 480: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 481:
! 482: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 483: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 484: .objet))).taille * sizeof(real8))) == NULL)
! 485: {
! 486: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 487: return;
! 488: }
! 489:
! 490: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 491: .objet))).taille; i++)
! 492: {
! 493: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 494: .tableau)[i] = ((real8 *) (*((struct_vecteur *)
! 495: (*s_objet_argument_2).objet)).tableau)[i] -
! 496: ((real8 *) (*((struct_vecteur *) (*s_objet_argument_1)
! 497: .objet)).tableau)[i];
! 498: }
! 499: }
! 500:
! 501: /*
! 502: * Entier / Complexe
! 503: */
! 504:
! 505: else if ((((*s_objet_argument_1).type == VIN) &&
! 506: ((*s_objet_argument_2).type == VCX)) ||
! 507: (((*s_objet_argument_1).type == VCX) &&
! 508: ((*s_objet_argument_2).type == VIN)))
! 509: {
! 510: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 511: == NULL)
! 512: {
! 513: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 514: return;
! 515: }
! 516:
! 517: if ((*(((struct_vecteur *) (*s_objet_argument_1).objet))).taille !=
! 518: (*(((struct_vecteur *) (*s_objet_argument_2).objet))).taille)
! 519: {
! 520: liberation(s_etat_processus, s_objet_argument_1);
! 521: liberation(s_etat_processus, s_objet_argument_2);
! 522: liberation(s_etat_processus, s_objet_resultat);
! 523:
! 524: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 525: return;
! 526: }
! 527:
! 528: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 529: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 530:
! 531: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 532: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 533: .objet))).taille * sizeof(struct_complexe16))) == NULL)
! 534: {
! 535: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 536: return;
! 537: }
! 538:
! 539: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 540: .objet))).taille; i++)
! 541: {
! 542: if ((*s_objet_argument_1).type == VIN)
! 543: {
! 544: f77soustractionci_(&(((struct_complexe16 *)
! 545: (*((struct_vecteur *)
! 546: (*s_objet_argument_2).objet)).tableau)[i]),
! 547: &(((integer8 *) (*((struct_vecteur *)
! 548: (*s_objet_argument_1).objet)).tableau)[i]),
! 549: &(((struct_complexe16 *) (*((struct_vecteur *)
! 550: (*s_objet_resultat).objet)).tableau)[i]));
! 551: }
! 552: else
! 553: {
! 554: f77soustractionic_(&(((integer8 *) (*((struct_vecteur *)
! 555: (*s_objet_argument_2).objet)).tableau)[i]),
! 556: &(((struct_complexe16 *) (*((struct_vecteur *)
! 557: (*s_objet_argument_1).objet)).tableau)[i]),
! 558: &(((struct_complexe16 *) (*((struct_vecteur *)
! 559: (*s_objet_resultat).objet)).tableau)[i]));
! 560: }
! 561: }
! 562: }
! 563:
! 564: /*
! 565: * Réel / Complexe
! 566: */
! 567:
! 568: else if ((((*s_objet_argument_1).type == VRL) &&
! 569: ((*s_objet_argument_2).type == VCX)) ||
! 570: (((*s_objet_argument_1).type == VCX) &&
! 571: ((*s_objet_argument_2).type == VRL)))
! 572: {
! 573: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 574: == NULL)
! 575: {
! 576: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 577: return;
! 578: }
! 579:
! 580: if ((*(((struct_vecteur *) (*s_objet_argument_1).objet))).taille !=
! 581: (*(((struct_vecteur *) (*s_objet_argument_2).objet))).taille)
! 582: {
! 583: liberation(s_etat_processus, s_objet_argument_1);
! 584: liberation(s_etat_processus, s_objet_argument_2);
! 585: liberation(s_etat_processus, s_objet_resultat);
! 586:
! 587: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 588: return;
! 589: }
! 590:
! 591: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 592: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 593:
! 594: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 595: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 596: .objet))).taille * sizeof(struct_complexe16))) == NULL)
! 597: {
! 598: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 599: return;
! 600: }
! 601:
! 602: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 603: .objet))).taille; i++)
! 604: {
! 605: if ((*s_objet_argument_1).type == VRL)
! 606: {
! 607: f77soustractioncr_(&(((struct_complexe16 *)
! 608: (*((struct_vecteur *)
! 609: (*s_objet_argument_2).objet)).tableau)[i]),
! 610: &(((real8 *) (*((struct_vecteur *)
! 611: (*s_objet_argument_1).objet)).tableau)[i]),
! 612: &(((struct_complexe16 *) (*((struct_vecteur *)
! 613: (*s_objet_resultat).objet)).tableau)[i]));
! 614: }
! 615: else
! 616: {
! 617: f77soustractionrc_(&(((real8 *) (*((struct_vecteur *)
! 618: (*s_objet_argument_2).objet)).tableau)[i]),
! 619: &(((struct_complexe16 *) (*((struct_vecteur *)
! 620: (*s_objet_argument_1).objet)).tableau)[i]),
! 621: &(((struct_complexe16 *) (*((struct_vecteur *)
! 622: (*s_objet_resultat).objet)).tableau)[i]));
! 623: }
! 624: }
! 625: }
! 626:
! 627: /*
! 628: * Complexe / Complexe
! 629: */
! 630:
! 631: else if (((*s_objet_argument_1).type == VCX) &&
! 632: ((*s_objet_argument_2).type == VCX))
! 633: {
! 634: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 635: == NULL)
! 636: {
! 637: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 638: return;
! 639: }
! 640:
! 641: if ((*(((struct_vecteur *) (*s_objet_argument_1).objet))).taille !=
! 642: (*(((struct_vecteur *) (*s_objet_argument_2).objet))).taille)
! 643: {
! 644: liberation(s_etat_processus, s_objet_argument_1);
! 645: liberation(s_etat_processus, s_objet_argument_2);
! 646: liberation(s_etat_processus, s_objet_resultat);
! 647:
! 648: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 649: return;
! 650: }
! 651:
! 652: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 653: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 654:
! 655: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 656: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 657: .objet))).taille * sizeof(struct_complexe16))) == NULL)
! 658: {
! 659: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 660: return;
! 661: }
! 662:
! 663: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 664: .objet))).taille; i++)
! 665: {
! 666: f77soustractioncc_(&(((struct_complexe16 *) (*((struct_vecteur *)
! 667: (*s_objet_argument_2).objet)).tableau)[i]),
! 668: &(((struct_complexe16 *) (*((struct_vecteur *)
! 669: (*s_objet_argument_1).objet)).tableau)[i]),
! 670: &(((struct_complexe16 *) (*((struct_vecteur *)
! 671: (*s_objet_resultat).objet)).tableau)[i]));
! 672: }
! 673: }
! 674:
! 675: /*
! 676: --------------------------------------------------------------------------------
! 677: Soustraction de deux matrices
! 678: --------------------------------------------------------------------------------
! 679: */
! 680: /*
! 681: * Entier / Entier
! 682: */
! 683:
! 684: else if (((*s_objet_argument_1).type == MIN) &&
! 685: ((*s_objet_argument_2).type == MIN))
! 686: {
! 687: if ((s_objet_resultat = allocation(s_etat_processus, MIN))
! 688: == NULL)
! 689: {
! 690: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 691: return;
! 692: }
! 693:
! 694: if (((*(((struct_matrice *) (*s_objet_argument_1).objet)))
! 695: .nombre_lignes != (*(((struct_matrice *) (*s_objet_argument_2)
! 696: .objet))).nombre_lignes) || ((*(((struct_matrice *)
! 697: (*s_objet_argument_1).objet))).nombre_colonnes !=
! 698: (*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 699: .nombre_colonnes))
! 700: {
! 701: liberation(s_etat_processus, s_objet_argument_1);
! 702: liberation(s_etat_processus, s_objet_argument_2);
! 703: liberation(s_etat_processus, s_objet_resultat);
! 704:
! 705: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 706: return;
! 707: }
! 708:
! 709: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 710: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 711: .nombre_lignes;
! 712: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 713: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 714: .nombre_colonnes;
! 715:
! 716: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 717: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 718: .objet))).nombre_lignes * sizeof(integer8 *))) == NULL)
! 719: {
! 720: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 721: return;
! 722: }
! 723:
! 724: depassement = d_faux;
! 725:
! 726: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 727: .objet))).nombre_lignes; i++)
! 728: {
! 729: if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
! 730: .objet)).tableau)[i] = malloc((*((
! 731: (struct_matrice *) (*s_objet_resultat).objet)))
! 732: .nombre_colonnes * sizeof(integer8))) == NULL)
! 733: {
! 734: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 735: return;
! 736: }
! 737:
! 738: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet)))
! 739: .nombre_colonnes; j++)
! 740: {
! 741: tampon = -((integer8 **) (*((struct_matrice *)
! 742: (*s_objet_argument_1).objet)).tableau)[i][j];
! 743:
! 744: if (depassement_addition(&(((integer8 **) (*((struct_matrice *)
! 745: (*s_objet_argument_2).objet)).tableau)[i][j]), &tampon,
! 746: &(((integer8 **) (*((struct_matrice *)
! 747: (*s_objet_resultat).objet)).tableau)[i][j]))
! 748: == d_erreur)
! 749: {
! 750: depassement = d_vrai;
! 751: }
! 752: }
! 753: }
! 754:
! 755: if (depassement == d_vrai)
! 756: {
! 757: (*s_objet_resultat).type = MRL;
! 758: (*((struct_matrice *) (*s_objet_resultat).objet)).type = 'R';
! 759:
! 760: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 761: .objet))).nombre_lignes; i++)
! 762: {
! 763: free(((integer8 **) (*((struct_matrice *)
! 764: (*s_objet_resultat).objet)).tableau)[i]);
! 765:
! 766: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
! 767: .objet)).tableau)[i] = malloc((*((
! 768: (struct_matrice *) (*s_objet_resultat).objet)))
! 769: .nombre_colonnes * sizeof(real8))) == NULL)
! 770: {
! 771: (*s_etat_processus).erreur_systeme =
! 772: d_es_allocation_memoire;
! 773: return;
! 774: }
! 775:
! 776: for(j = 0; j < (*(((struct_matrice *)
! 777: (*s_objet_resultat).objet))).nombre_colonnes; j++)
! 778: {
! 779: ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
! 780: .objet)).tableau)[i][j] = ((real8) ((integer8 **)
! 781: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 782: .tableau)[i][j]) - ((real8) ((integer8 **)
! 783: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 784: .tableau)[i][j]);
! 785: }
! 786: }
! 787: }
! 788: }
! 789:
! 790: /*
! 791: * Entier / Réel
! 792: */
! 793:
! 794: else if ((((*s_objet_argument_1).type == MIN) &&
! 795: ((*s_objet_argument_2).type == MRL)) ||
! 796: (((*s_objet_argument_1).type == MRL) &&
! 797: ((*s_objet_argument_2).type == MIN)))
! 798: {
! 799: if ((s_objet_resultat = allocation(s_etat_processus, MRL))
! 800: == NULL)
! 801: {
! 802: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 803: return;
! 804: }
! 805:
! 806: if (((*(((struct_matrice *) (*s_objet_argument_1).objet)))
! 807: .nombre_lignes != (*(((struct_matrice *) (*s_objet_argument_2)
! 808: .objet))).nombre_lignes) || ((*(((struct_matrice *)
! 809: (*s_objet_argument_1).objet))).nombre_colonnes !=
! 810: (*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 811: .nombre_colonnes))
! 812: {
! 813: liberation(s_etat_processus, s_objet_argument_1);
! 814: liberation(s_etat_processus, s_objet_argument_2);
! 815: liberation(s_etat_processus, s_objet_resultat);
! 816:
! 817: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 818: return;
! 819: }
! 820:
! 821: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 822: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 823: .nombre_lignes;
! 824: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 825: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 826: .nombre_colonnes;
! 827:
! 828: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 829: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 830: .objet))).nombre_lignes * sizeof(real8 *))) == NULL)
! 831: {
! 832: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 833: return;
! 834: }
! 835:
! 836: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 837: .objet))).nombre_lignes; i++)
! 838: {
! 839: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
! 840: .objet)).tableau)[i] = malloc((*((
! 841: (struct_matrice *) (*s_objet_resultat).objet)))
! 842: .nombre_colonnes * sizeof(real8))) == NULL)
! 843: {
! 844: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 845: return;
! 846: }
! 847:
! 848: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet)))
! 849: .nombre_colonnes; j++)
! 850: {
! 851: if ((*s_objet_argument_1).type == MIN)
! 852: {
! 853: ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
! 854: .objet)).tableau)[i][j] = ((real8 **)
! 855: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 856: .tableau)[i][j] - ((integer8 **)
! 857: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 858: .tableau)[i][j];
! 859: }
! 860: else
! 861: {
! 862: ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
! 863: .objet)).tableau)[i][j] = ((integer8 **)
! 864: (*((struct_matrice *) (*s_objet_argument_2)
! 865: .objet)).tableau)[i][j] - ((real8 **)
! 866: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 867: .tableau)[i][j];
! 868: }
! 869: }
! 870: }
! 871: }
! 872:
! 873: /*
! 874: * Réel / Réel
! 875: */
! 876:
! 877: else if (((*s_objet_argument_1).type == MRL) &&
! 878: ((*s_objet_argument_2).type == MRL))
! 879: {
! 880: if ((s_objet_resultat = allocation(s_etat_processus, MRL))
! 881: == NULL)
! 882: {
! 883: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 884: return;
! 885: }
! 886:
! 887: if (((*(((struct_matrice *) (*s_objet_argument_1).objet)))
! 888: .nombre_lignes != (*(((struct_matrice *) (*s_objet_argument_2)
! 889: .objet))).nombre_lignes) || ((*(((struct_matrice *)
! 890: (*s_objet_argument_1).objet))).nombre_colonnes !=
! 891: (*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 892: .nombre_colonnes))
! 893: {
! 894: liberation(s_etat_processus, s_objet_argument_1);
! 895: liberation(s_etat_processus, s_objet_argument_2);
! 896: liberation(s_etat_processus, s_objet_resultat);
! 897:
! 898: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 899: return;
! 900: }
! 901:
! 902: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 903: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 904: .nombre_lignes;
! 905: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 906: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 907: .nombre_colonnes;
! 908:
! 909: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 910: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 911: .objet))).nombre_lignes * sizeof(real8 *))) == NULL)
! 912: {
! 913: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 914: return;
! 915: }
! 916:
! 917: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 918: .objet))).nombre_lignes; i++)
! 919: {
! 920: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
! 921: .objet)).tableau)[i] = malloc((*((
! 922: (struct_matrice *) (*s_objet_resultat).objet)))
! 923: .nombre_colonnes * sizeof(real8))) == NULL)
! 924: {
! 925: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 926: return;
! 927: }
! 928:
! 929: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet)))
! 930: .nombre_colonnes; j++)
! 931: {
! 932: ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
! 933: .objet)).tableau)[i][j] = ((real8 **)
! 934: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 935: .tableau)[i][j] - ((real8 **) (*((struct_matrice *)
! 936: (*s_objet_argument_1).objet)).tableau)[i][j];
! 937: }
! 938: }
! 939: }
! 940:
! 941: /*
! 942: * Entier / Complexe
! 943: */
! 944:
! 945: else if ((((*s_objet_argument_1).type == MIN) &&
! 946: ((*s_objet_argument_2).type == MCX)) ||
! 947: (((*s_objet_argument_1).type == MCX) &&
! 948: ((*s_objet_argument_2).type == MIN)))
! 949: {
! 950: if ((s_objet_resultat = allocation(s_etat_processus, MCX))
! 951: == NULL)
! 952: {
! 953: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 954: return;
! 955: }
! 956:
! 957: if (((*(((struct_matrice *) (*s_objet_argument_1).objet)))
! 958: .nombre_lignes != (*(((struct_matrice *) (*s_objet_argument_2)
! 959: .objet))).nombre_lignes) || ((*(((struct_matrice *)
! 960: (*s_objet_argument_1).objet))).nombre_colonnes !=
! 961: (*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 962: .nombre_colonnes))
! 963: {
! 964: liberation(s_etat_processus, s_objet_argument_1);
! 965: liberation(s_etat_processus, s_objet_argument_2);
! 966: liberation(s_etat_processus, s_objet_resultat);
! 967:
! 968: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 969: return;
! 970: }
! 971:
! 972: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 973: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 974: .nombre_lignes;
! 975: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 976: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 977: .nombre_colonnes;
! 978:
! 979: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 980: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 981: .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 982: {
! 983: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 984: return;
! 985: }
! 986:
! 987: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 988: .objet))).nombre_lignes; i++)
! 989: {
! 990: if ((((struct_complexe16 **) (*((struct_matrice *)
! 991: (*s_objet_resultat).objet)).tableau)[i] = malloc((*((
! 992: (struct_matrice *) (*s_objet_resultat).objet)))
! 993: .nombre_colonnes * sizeof(struct_complexe16))) == NULL)
! 994: {
! 995: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 996: return;
! 997: }
! 998:
! 999: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet)))
! 1000: .nombre_colonnes; j++)
! 1001: {
! 1002: if ((*s_objet_argument_1).type == MIN)
! 1003: {
! 1004: f77soustractionci_(&(((struct_complexe16 **)
! 1005: (*((struct_matrice *)
! 1006: (*s_objet_argument_2).objet)).tableau)[i][j]),
! 1007: &(((integer8 **) (*((struct_matrice *)
! 1008: (*s_objet_argument_1).objet)).tableau)[i][j]),
! 1009: &(((struct_complexe16 **) (*((struct_matrice *)
! 1010: (*s_objet_resultat).objet)).tableau)[i][j]));
! 1011: }
! 1012: else
! 1013: {
! 1014: f77soustractionic_(&(((integer8 **) (*((struct_matrice *)
! 1015: (*s_objet_argument_2).objet)).tableau)[i][j]),
! 1016: &(((struct_complexe16 **) (*((struct_matrice *)
! 1017: (*s_objet_argument_1).objet)).tableau)[i][j]),
! 1018: &(((struct_complexe16 **) (*((struct_matrice *)
! 1019: (*s_objet_resultat).objet)).tableau)[i][j]));
! 1020: }
! 1021: }
! 1022: }
! 1023: }
! 1024:
! 1025: /*
! 1026: * Réel / Complexe
! 1027: */
! 1028:
! 1029: else if ((((*s_objet_argument_1).type == MRL) &&
! 1030: ((*s_objet_argument_2).type == MCX)) ||
! 1031: (((*s_objet_argument_1).type == MCX) &&
! 1032: ((*s_objet_argument_2).type == MRL)))
! 1033: {
! 1034: if ((s_objet_resultat = allocation(s_etat_processus, MCX))
! 1035: == NULL)
! 1036: {
! 1037: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1038: return;
! 1039: }
! 1040:
! 1041: if (((*(((struct_matrice *) (*s_objet_argument_1).objet)))
! 1042: .nombre_lignes != (*(((struct_matrice *) (*s_objet_argument_2)
! 1043: .objet))).nombre_lignes) || ((*(((struct_matrice *)
! 1044: (*s_objet_argument_1).objet))).nombre_colonnes !=
! 1045: (*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 1046: .nombre_colonnes))
! 1047: {
! 1048: liberation(s_etat_processus, s_objet_argument_1);
! 1049: liberation(s_etat_processus, s_objet_argument_2);
! 1050: liberation(s_etat_processus, s_objet_resultat);
! 1051:
! 1052: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 1053: return;
! 1054: }
! 1055:
! 1056: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 1057: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 1058: .nombre_lignes;
! 1059: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 1060: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 1061: .nombre_colonnes;
! 1062:
! 1063: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 1064: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 1065: .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 1066: {
! 1067: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1068: return;
! 1069: }
! 1070:
! 1071: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 1072: .objet))).nombre_lignes; i++)
! 1073: {
! 1074: if ((((struct_complexe16 **) (*((struct_matrice *)
! 1075: (*s_objet_resultat).objet)).tableau)[i] = malloc((*((
! 1076: (struct_matrice *) (*s_objet_resultat).objet)))
! 1077: .nombre_colonnes * sizeof(struct_complexe16))) == NULL)
! 1078: {
! 1079: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1080: return;
! 1081: }
! 1082:
! 1083: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet)))
! 1084: .nombre_colonnes; j++)
! 1085: {
! 1086: if ((*s_objet_argument_1).type == MRL)
! 1087: {
! 1088: f77soustractioncr_(&(((struct_complexe16 **)
! 1089: (*((struct_matrice *)
! 1090: (*s_objet_argument_2).objet)).tableau)[i][j]),
! 1091: &(((real8 **) (*((struct_matrice *)
! 1092: (*s_objet_argument_1).objet)).tableau)[i][j]),
! 1093: &(((struct_complexe16 **) (*((struct_matrice *)
! 1094: (*s_objet_resultat).objet)).tableau)[i][j]));
! 1095: }
! 1096: else
! 1097: {
! 1098: f77soustractionrc_(&(((real8 **) (*((struct_matrice *)
! 1099: (*s_objet_argument_2).objet)).tableau)[i][j]),
! 1100: &(((struct_complexe16 **) (*((struct_matrice *)
! 1101: (*s_objet_argument_1).objet)).tableau)[i][j]),
! 1102: &(((struct_complexe16 **) (*((struct_matrice *)
! 1103: (*s_objet_resultat).objet)).tableau)[i][j]));
! 1104: }
! 1105: }
! 1106: }
! 1107: }
! 1108:
! 1109: /*
! 1110: * Complexe / Complexe
! 1111: */
! 1112:
! 1113: else if (((*s_objet_argument_1).type == MCX) &&
! 1114: ((*s_objet_argument_2).type == MCX))
! 1115: {
! 1116: if ((s_objet_resultat = allocation(s_etat_processus, MCX))
! 1117: == NULL)
! 1118: {
! 1119: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1120: return;
! 1121: }
! 1122:
! 1123: if (((*(((struct_matrice *) (*s_objet_argument_1).objet)))
! 1124: .nombre_lignes != (*(((struct_matrice *) (*s_objet_argument_2)
! 1125: .objet))).nombre_lignes) || ((*(((struct_matrice *)
! 1126: (*s_objet_argument_1).objet))).nombre_colonnes !=
! 1127: (*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 1128: .nombre_colonnes))
! 1129: {
! 1130: liberation(s_etat_processus, s_objet_argument_1);
! 1131: liberation(s_etat_processus, s_objet_argument_2);
! 1132: liberation(s_etat_processus, s_objet_resultat);
! 1133:
! 1134: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 1135: return;
! 1136: }
! 1137:
! 1138: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 1139: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 1140: .nombre_lignes;
! 1141: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 1142: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 1143: .nombre_colonnes;
! 1144:
! 1145: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 1146: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 1147: .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 1148: {
! 1149: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1150: return;
! 1151: }
! 1152:
! 1153: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 1154: .objet))).nombre_lignes; i++)
! 1155: {
! 1156: if ((((struct_complexe16 **) (*((struct_matrice *)
! 1157: (*s_objet_resultat).objet)).tableau)[i] = malloc((*((
! 1158: (struct_matrice *) (*s_objet_resultat).objet)))
! 1159: .nombre_colonnes * sizeof(struct_complexe16))) == NULL)
! 1160: {
! 1161: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1162: return;
! 1163: }
! 1164:
! 1165: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat).objet)))
! 1166: .nombre_colonnes; j++)
! 1167: {
! 1168: f77soustractioncc_(&(((struct_complexe16 **)
! 1169: (*((struct_matrice *)
! 1170: (*s_objet_argument_2).objet)).tableau)[i][j]),
! 1171: &(((struct_complexe16 **) (*((struct_matrice *)
! 1172: (*s_objet_argument_1).objet)).tableau)[i][j]),
! 1173: &(((struct_complexe16 **) (*((struct_matrice *)
! 1174: (*s_objet_resultat).objet)).tableau)[i][j]));
! 1175: }
! 1176: }
! 1177: }
! 1178:
! 1179: /*
! 1180: --------------------------------------------------------------------------------
! 1181: Soustraction mettant en oeuvre des binaires
! 1182: --------------------------------------------------------------------------------
! 1183: */
! 1184: /*
! 1185: * Binaire / Binaire
! 1186: */
! 1187:
! 1188: else if (((*s_objet_argument_1).type == BIN) &&
! 1189: ((*s_objet_argument_2).type == BIN))
! 1190: {
! 1191: if ((s_objet_resultat = allocation(s_etat_processus, BIN))
! 1192: == NULL)
! 1193: {
! 1194: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1195: return;
! 1196: }
! 1197:
! 1198: (*((logical8 *) (*s_objet_resultat).objet)) =
! 1199: (*((logical8 *) (*s_objet_argument_2).objet))
! 1200: - (*((logical8 *) (*s_objet_argument_1).objet));
! 1201: }
! 1202:
! 1203: /*
! 1204: * Binaire / Entier
! 1205: */
! 1206:
! 1207: else if ((((*s_objet_argument_1).type == BIN) &&
! 1208: ((*s_objet_argument_2).type == INT)) ||
! 1209: (((*s_objet_argument_1).type == INT) &&
! 1210: ((*s_objet_argument_2).type == BIN)))
! 1211: {
! 1212: if ((s_objet_resultat = allocation(s_etat_processus, BIN))
! 1213: == NULL)
! 1214: {
! 1215: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1216: return;
! 1217: }
! 1218:
! 1219: if ((*s_objet_argument_1).type == BIN)
! 1220: {
! 1221: (*((logical8 *) (*s_objet_resultat).objet)) =
! 1222: (*((integer8 *) (*s_objet_argument_2).objet))
! 1223: - (*((logical8 *) (*s_objet_argument_1).objet));
! 1224: }
! 1225: else
! 1226: {
! 1227: (*((logical8 *) (*s_objet_resultat).objet)) =
! 1228: (*((logical8 *) (*s_objet_argument_2).objet))
! 1229: - (*((integer8 *) (*s_objet_argument_1).objet));
! 1230: }
! 1231: }
! 1232:
! 1233: /*
! 1234: --------------------------------------------------------------------------------
! 1235: Soustraction mettant en oeuvre un nom ou une expression algébrique
! 1236: --------------------------------------------------------------------------------
! 1237: */
! 1238: /*
! 1239: * Nom ou valeur numérique / Nom ou valeur numérique
! 1240: */
! 1241:
! 1242: else if ((((*s_objet_argument_1).type == NOM) &&
! 1243: (((*s_objet_argument_2).type == NOM) ||
! 1244: ((*s_objet_argument_2).type == INT) ||
! 1245: ((*s_objet_argument_2).type == REL) ||
! 1246: ((*s_objet_argument_2).type == CPL))) ||
! 1247: (((*s_objet_argument_2).type == NOM) &&
! 1248: (((*s_objet_argument_1).type == INT) ||
! 1249: ((*s_objet_argument_1).type == REL) ||
! 1250: ((*s_objet_argument_1).type == CPL))))
! 1251: {
! 1252: drapeau = d_vrai;
! 1253: drapeau_neg = d_faux;
! 1254:
! 1255: if ((*s_objet_argument_2).type == NOM)
! 1256: {
! 1257: if ((*s_objet_argument_1).type == INT)
! 1258: {
! 1259: if ((*((integer8 *) (*s_objet_argument_1).objet)) == 0)
! 1260: {
! 1261: drapeau = d_faux;
! 1262:
! 1263: s_objet_resultat = s_objet_argument_2;
! 1264: s_objet_argument_2 = NULL;
! 1265: }
! 1266: }
! 1267: else if ((*s_objet_argument_1).type == REL)
! 1268: {
! 1269: if ((*((real8 *) (*s_objet_argument_1).objet)) == 0)
! 1270: {
! 1271: drapeau = d_faux;
! 1272:
! 1273: s_objet_resultat = s_objet_argument_2;
! 1274: s_objet_argument_2 = NULL;
! 1275: }
! 1276: }
! 1277: else if ((*s_objet_argument_1).type == CPL)
! 1278: {
! 1279: if (((*((complex16 *) (*s_objet_argument_1).objet))
! 1280: .partie_reelle == 0) && ((*((complex16 *)
! 1281: (*s_objet_argument_1).objet)).partie_imaginaire == 0))
! 1282: {
! 1283: drapeau = d_faux;
! 1284:
! 1285: s_objet_resultat = s_objet_argument_2;
! 1286: s_objet_argument_2 = NULL;
! 1287: }
! 1288: }
! 1289: }
! 1290: else if ((*s_objet_argument_1).type == NOM)
! 1291: {
! 1292: if ((*s_objet_argument_2).type == INT)
! 1293: {
! 1294: if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0)
! 1295: {
! 1296: drapeau_neg = d_vrai;
! 1297: }
! 1298: }
! 1299: else if ((*s_objet_argument_2).type == REL)
! 1300: {
! 1301: if ((*((real8 *) (*s_objet_argument_2).objet)) == 0)
! 1302: {
! 1303: drapeau_neg = d_vrai;
! 1304: }
! 1305: }
! 1306: else if ((*s_objet_argument_2).type == CPL)
! 1307: {
! 1308: if (((*((complex16 *) (*s_objet_argument_2).objet))
! 1309: .partie_reelle == 0) && ((*((complex16 *)
! 1310: (*s_objet_argument_2).objet)).partie_imaginaire == 0))
! 1311: {
! 1312: drapeau_neg = d_vrai;
! 1313: }
! 1314: }
! 1315: }
! 1316:
! 1317: if (drapeau == d_vrai)
! 1318: {
! 1319: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
! 1320: == NULL)
! 1321: {
! 1322: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1323: return;
! 1324: }
! 1325:
! 1326: if (((*s_objet_resultat).objet =
! 1327: allocation_maillon(s_etat_processus)) == NULL)
! 1328: {
! 1329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1330: return;
! 1331: }
! 1332:
! 1333: l_element_courant = (*s_objet_resultat).objet;
! 1334:
! 1335: if (((*l_element_courant).donnee = allocation(s_etat_processus,
! 1336: FCT)) == NULL)
! 1337: {
! 1338: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1339: return;
! 1340: }
! 1341:
! 1342: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1343: .nombre_arguments = 0;
! 1344: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1345: .fonction = instruction_vers_niveau_superieur;
! 1346:
! 1347: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1348: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 1349: {
! 1350: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1351: return;
! 1352: }
! 1353:
! 1354: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1355: .nom_fonction, "<<");
! 1356:
! 1357: if (drapeau_neg == d_faux)
! 1358: {
! 1359: if (((*l_element_courant).suivant =
! 1360: allocation_maillon(s_etat_processus)) == NULL)
! 1361: {
! 1362: (*s_etat_processus).erreur_systeme =
! 1363: d_es_allocation_memoire;
! 1364: return;
! 1365: }
! 1366:
! 1367: l_element_courant = (*l_element_courant).suivant;
! 1368: (*l_element_courant).donnee = s_objet_argument_2;
! 1369: }
! 1370: else
! 1371: {
! 1372: liberation(s_etat_processus, s_objet_argument_2);
! 1373: }
! 1374:
! 1375: if (((*l_element_courant).suivant =
! 1376: allocation_maillon(s_etat_processus)) == NULL)
! 1377: {
! 1378: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1379: return;
! 1380: }
! 1381:
! 1382: l_element_courant = (*l_element_courant).suivant;
! 1383: (*l_element_courant).donnee = s_objet_argument_1;
! 1384:
! 1385: if (((*l_element_courant).suivant =
! 1386: allocation_maillon(s_etat_processus)) == NULL)
! 1387: {
! 1388: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1389: return;
! 1390: }
! 1391:
! 1392: l_element_courant = (*l_element_courant).suivant;
! 1393:
! 1394: if (((*l_element_courant).donnee = allocation(s_etat_processus,
! 1395: FCT)) == NULL)
! 1396: {
! 1397: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1398: return;
! 1399: }
! 1400:
! 1401: if (drapeau_neg == d_faux)
! 1402: {
! 1403: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1404: .nombre_arguments = 0;
! 1405: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1406: .fonction = instruction_moins;
! 1407:
! 1408: if (((*((struct_fonction *) (*(*l_element_courant)
! 1409: .donnee).objet)).nom_fonction =
! 1410: malloc(2 * sizeof(unsigned char))) == NULL)
! 1411: {
! 1412: (*s_etat_processus).erreur_systeme =
! 1413: d_es_allocation_memoire;
! 1414: return;
! 1415: }
! 1416:
! 1417: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
! 1418: .objet)).nom_fonction, "-");
! 1419: }
! 1420: else
! 1421: {
! 1422: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1423: .nombre_arguments = 1;
! 1424: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1425: .fonction = instruction_neg;
! 1426:
! 1427: if (((*((struct_fonction *) (*(*l_element_courant)
! 1428: .donnee).objet)).nom_fonction =
! 1429: malloc(4 * sizeof(unsigned char))) == NULL)
! 1430: {
! 1431: (*s_etat_processus).erreur_systeme =
! 1432: d_es_allocation_memoire;
! 1433: return;
! 1434: }
! 1435:
! 1436: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
! 1437: .objet)).nom_fonction, "NEG");
! 1438: }
! 1439:
! 1440: if (((*l_element_courant).suivant =
! 1441: allocation_maillon(s_etat_processus)) == NULL)
! 1442: {
! 1443: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1444: return;
! 1445: }
! 1446:
! 1447: l_element_courant = (*l_element_courant).suivant;
! 1448:
! 1449: if (((*l_element_courant).donnee = allocation(s_etat_processus,
! 1450: FCT)) == NULL)
! 1451: {
! 1452: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1453: return;
! 1454: }
! 1455:
! 1456: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1457: .nombre_arguments = 0;
! 1458: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1459: .fonction = instruction_vers_niveau_inferieur;
! 1460:
! 1461: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1462: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 1463: {
! 1464: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1465: return;
! 1466: }
! 1467:
! 1468: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1469: .nom_fonction, ">>");
! 1470:
! 1471: (*l_element_courant).suivant = NULL;
! 1472:
! 1473: s_objet_argument_1 = NULL;
! 1474: s_objet_argument_2 = NULL;
! 1475: }
! 1476: }
! 1477:
! 1478: /*
! 1479: * Nom ou valeur numérique / Expression
! 1480: */
! 1481:
! 1482: else if ((((*s_objet_argument_1).type == ALG) ||
! 1483: ((*s_objet_argument_1).type == RPN)) &&
! 1484: (((*s_objet_argument_2).type == NOM) ||
! 1485: ((*s_objet_argument_2).type == INT) ||
! 1486: ((*s_objet_argument_2).type == REL) ||
! 1487: ((*s_objet_argument_2).type == CPL)))
! 1488: {
! 1489: drapeau_neg = d_faux;
! 1490:
! 1491: nombre_elements = 0;
! 1492: l_element_courant = (struct_liste_chainee *)
! 1493: (*s_objet_argument_1).objet;
! 1494:
! 1495: while(l_element_courant != NULL)
! 1496: {
! 1497: nombre_elements++;
! 1498: l_element_courant = (*l_element_courant).suivant;
! 1499: }
! 1500:
! 1501: if (nombre_elements == 2)
! 1502: {
! 1503: liberation(s_etat_processus, s_objet_argument_1);
! 1504: liberation(s_etat_processus, s_objet_argument_2);
! 1505:
! 1506: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 1507: return;
! 1508: }
! 1509:
! 1510: if ((*s_objet_argument_2).type == INT)
! 1511: {
! 1512: if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0)
! 1513: {
! 1514: drapeau_neg = d_vrai;
! 1515: }
! 1516: }
! 1517: else if ((*s_objet_argument_2).type == REL)
! 1518: {
! 1519: if ((*((real8 *) (*s_objet_argument_2).objet)) == 0)
! 1520: {
! 1521: drapeau_neg = d_vrai;
! 1522: }
! 1523: }
! 1524: else if ((*s_objet_argument_2).type == CPL)
! 1525: {
! 1526: if (((*((complex16 *) (*s_objet_argument_2).objet))
! 1527: .partie_reelle == 0) && ((*((complex16 *)
! 1528: (*s_objet_argument_2).objet)).partie_imaginaire == 0))
! 1529: {
! 1530: drapeau_neg = d_vrai;
! 1531: }
! 1532: }
! 1533:
! 1534: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 1535: s_objet_argument_1, 'N')) == NULL)
! 1536: {
! 1537: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1538: return;
! 1539: }
! 1540:
! 1541: l_element_courant = (struct_liste_chainee *)
! 1542: (*s_objet_resultat).objet;
! 1543: l_element_precedent = l_element_courant;
! 1544: l_element_courant = (*l_element_courant).suivant;
! 1545:
! 1546: if (drapeau_neg == d_faux)
! 1547: {
! 1548: if (((*l_element_precedent).suivant =
! 1549: allocation_maillon(s_etat_processus)) == NULL)
! 1550: {
! 1551: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1552: return;
! 1553: }
! 1554:
! 1555: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
! 1556: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 1557: }
! 1558: else
! 1559: {
! 1560: liberation(s_etat_processus, s_objet_argument_2);
! 1561: }
! 1562:
! 1563: while((*l_element_courant).suivant != NULL)
! 1564: {
! 1565: l_element_precedent = l_element_courant;
! 1566: l_element_courant = (*l_element_courant).suivant;
! 1567: }
! 1568:
! 1569: if (((*l_element_precedent).suivant =
! 1570: allocation_maillon(s_etat_processus)) == NULL)
! 1571: {
! 1572: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1573: return;
! 1574: }
! 1575:
! 1576: if (((*(*l_element_precedent).suivant).donnee =
! 1577: allocation(s_etat_processus, FCT)) == NULL)
! 1578: {
! 1579: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1580: return;
! 1581: }
! 1582:
! 1583: if (drapeau_neg == d_faux)
! 1584: {
! 1585: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 1586: .donnee).objet)).nombre_arguments = 0;
! 1587: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 1588: .donnee).objet)).fonction = instruction_moins;
! 1589:
! 1590: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 1591: .suivant).donnee).objet)).nom_fonction =
! 1592: malloc(2 * sizeof(unsigned char))) == NULL)
! 1593: {
! 1594: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1595: return;
! 1596: }
! 1597:
! 1598: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 1599: .suivant).donnee).objet)).nom_fonction, "-");
! 1600: }
! 1601: else
! 1602: {
! 1603: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 1604: .donnee).objet)).nombre_arguments = 1;
! 1605: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 1606: .donnee).objet)).fonction = instruction_neg;
! 1607:
! 1608: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 1609: .suivant).donnee).objet)).nom_fonction =
! 1610: malloc(4 * sizeof(unsigned char))) == NULL)
! 1611: {
! 1612: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1613: return;
! 1614: }
! 1615:
! 1616: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 1617: .suivant).donnee).objet)).nom_fonction, "NEG");
! 1618: }
! 1619:
! 1620: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 1621:
! 1622: s_objet_argument_2 = NULL;
! 1623: }
! 1624:
! 1625: /*
! 1626: * Expression / Nom ou valeur numérique
! 1627: */
! 1628:
! 1629: else if ((((*s_objet_argument_1).type == NOM) ||
! 1630: ((*s_objet_argument_1).type == INT) ||
! 1631: ((*s_objet_argument_1).type == REL) ||
! 1632: ((*s_objet_argument_1).type == CPL)) &&
! 1633: (((*s_objet_argument_2).type == ALG) ||
! 1634: ((*s_objet_argument_2).type == RPN)))
! 1635: {
! 1636: drapeau = d_vrai;
! 1637:
! 1638: nombre_elements = 0;
! 1639: l_element_courant = (struct_liste_chainee *)
! 1640: (*s_objet_argument_2).objet;
! 1641:
! 1642: while(l_element_courant != NULL)
! 1643: {
! 1644: nombre_elements++;
! 1645: l_element_courant = (*l_element_courant).suivant;
! 1646: }
! 1647:
! 1648: if (nombre_elements == 2)
! 1649: {
! 1650: liberation(s_etat_processus, s_objet_argument_1);
! 1651: liberation(s_etat_processus, s_objet_argument_2);
! 1652:
! 1653: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 1654: return;
! 1655: }
! 1656:
! 1657: if ((*s_objet_argument_1).type == INT)
! 1658: {
! 1659: if ((*((integer8 *) (*s_objet_argument_1).objet)) == 0)
! 1660: {
! 1661: drapeau = d_faux;
! 1662:
! 1663: s_objet_resultat = s_objet_argument_2;
! 1664: s_objet_argument_2 = NULL;
! 1665: }
! 1666: }
! 1667: else if ((*s_objet_argument_1).type == REL)
! 1668: {
! 1669: if ((*((real8 *) (*s_objet_argument_1).objet)) == 0)
! 1670: {
! 1671: drapeau = d_faux;
! 1672:
! 1673: s_objet_resultat = s_objet_argument_2;
! 1674: s_objet_argument_2 = NULL;
! 1675: }
! 1676: }
! 1677: else if ((*s_objet_argument_1).type == CPL)
! 1678: {
! 1679: if (((*((complex16 *) (*s_objet_argument_1).objet))
! 1680: .partie_reelle == 0) && ((*((complex16 *)
! 1681: (*s_objet_argument_1).objet)).partie_imaginaire == 0))
! 1682: {
! 1683: drapeau = d_faux;
! 1684:
! 1685: s_objet_resultat = s_objet_argument_2;
! 1686: s_objet_argument_2 = NULL;
! 1687: }
! 1688: }
! 1689:
! 1690: if (drapeau == d_vrai)
! 1691: {
! 1692: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 1693: s_objet_argument_2, 'N')) == NULL)
! 1694: {
! 1695: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1696: return;
! 1697: }
! 1698:
! 1699: l_element_courant = (struct_liste_chainee *)
! 1700: (*s_objet_resultat).objet;
! 1701: l_element_precedent = l_element_courant;
! 1702:
! 1703: while((*l_element_courant).suivant != NULL)
! 1704: {
! 1705: l_element_precedent = l_element_courant;
! 1706: l_element_courant = (*l_element_courant).suivant;
! 1707: }
! 1708:
! 1709: if (((*l_element_precedent).suivant =
! 1710: allocation_maillon(s_etat_processus)) == NULL)
! 1711: {
! 1712: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1713: return;
! 1714: }
! 1715:
! 1716: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
! 1717: l_element_precedent = (*l_element_precedent).suivant;
! 1718:
! 1719: if (((*l_element_precedent).suivant =
! 1720: allocation_maillon(s_etat_processus)) == NULL)
! 1721: {
! 1722: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1723: return;
! 1724: }
! 1725:
! 1726: if (((*(*l_element_precedent).suivant).donnee =
! 1727: allocation(s_etat_processus, FCT)) == NULL)
! 1728: {
! 1729: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1730: return;
! 1731: }
! 1732:
! 1733: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 1734: .donnee).objet)).nombre_arguments = 0;
! 1735: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 1736: .donnee).objet)).fonction = instruction_moins;
! 1737:
! 1738: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 1739: .suivant).donnee).objet)).nom_fonction =
! 1740: malloc(2 * sizeof(unsigned char))) == NULL)
! 1741: {
! 1742: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1743: return;
! 1744: }
! 1745:
! 1746: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 1747: .suivant).donnee).objet)).nom_fonction, "-");
! 1748:
! 1749: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 1750:
! 1751: s_objet_argument_1 = NULL;
! 1752: }
! 1753: }
! 1754:
! 1755: /*
! 1756: * Expression / Expression
! 1757: */
! 1758:
! 1759: else if ((((*s_objet_argument_1).type == ALG) &&
! 1760: ((*s_objet_argument_2).type == ALG)) ||
! 1761: (((*s_objet_argument_1).type == RPN) &&
! 1762: ((*s_objet_argument_2).type == RPN)))
! 1763: {
! 1764: nombre_elements = 0;
! 1765: l_element_courant = (struct_liste_chainee *)
! 1766: (*s_objet_argument_1).objet;
! 1767:
! 1768: while(l_element_courant != NULL)
! 1769: {
! 1770: nombre_elements++;
! 1771: l_element_courant = (*l_element_courant).suivant;
! 1772: }
! 1773:
! 1774: if (nombre_elements == 2)
! 1775: {
! 1776: liberation(s_etat_processus, s_objet_argument_1);
! 1777: liberation(s_etat_processus, s_objet_argument_2);
! 1778:
! 1779: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 1780: return;
! 1781: }
! 1782:
! 1783: nombre_elements = 0;
! 1784: l_element_courant = (struct_liste_chainee *)
! 1785: (*s_objet_argument_2).objet;
! 1786:
! 1787: while(l_element_courant != NULL)
! 1788: {
! 1789: nombre_elements++;
! 1790: l_element_courant = (*l_element_courant).suivant;
! 1791: }
! 1792:
! 1793: if (nombre_elements == 2)
! 1794: {
! 1795: liberation(s_etat_processus, s_objet_argument_1);
! 1796: liberation(s_etat_processus, s_objet_argument_2);
! 1797:
! 1798: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 1799: return;
! 1800: }
! 1801:
! 1802: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
! 1803: s_objet_argument_1, 'N')) == NULL)
! 1804: {
! 1805: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1806: return;
! 1807: }
! 1808:
! 1809: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
! 1810: s_objet_argument_2, 'N')) == NULL)
! 1811: {
! 1812: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1813: return;
! 1814: }
! 1815:
! 1816: l_element_courant = (struct_liste_chainee *)
! 1817: (*s_copie_argument_1).objet;
! 1818: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
! 1819: (*s_copie_argument_1).objet)).suivant;
! 1820:
! 1821: liberation(s_etat_processus, (*l_element_courant).donnee);
! 1822: free(l_element_courant);
! 1823:
! 1824: l_element_courant = (struct_liste_chainee *)
! 1825: (*s_copie_argument_2).objet;
! 1826: l_element_precedent = l_element_courant;
! 1827: s_objet_resultat = s_copie_argument_2;
! 1828:
! 1829: while((*l_element_courant).suivant != NULL)
! 1830: {
! 1831: l_element_precedent = l_element_courant;
! 1832: l_element_courant = (*l_element_courant).suivant;
! 1833: }
! 1834:
! 1835: liberation(s_etat_processus, (*l_element_courant).donnee);
! 1836: free(l_element_courant);
! 1837:
! 1838: (*l_element_precedent).suivant = (struct_liste_chainee *)
! 1839: (*s_copie_argument_1).objet;
! 1840: free(s_copie_argument_1);
! 1841:
! 1842: l_element_courant = (*l_element_precedent).suivant;
! 1843: while((*l_element_courant).suivant != NULL)
! 1844: {
! 1845: l_element_precedent = l_element_courant;
! 1846: l_element_courant = (*l_element_courant).suivant;
! 1847: }
! 1848:
! 1849: if (((*l_element_precedent).suivant =
! 1850: allocation_maillon(s_etat_processus)) == NULL)
! 1851: {
! 1852: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1853: return;
! 1854: }
! 1855:
! 1856: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 1857: l_element_courant = (*l_element_precedent).suivant;
! 1858:
! 1859: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 1860: == NULL)
! 1861: {
! 1862: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1863: return;
! 1864: }
! 1865:
! 1866: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1867: .nombre_arguments = 0;
! 1868: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1869: .fonction = instruction_moins;
! 1870:
! 1871: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1872: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL)
! 1873: {
! 1874: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1875: return;
! 1876: }
! 1877:
! 1878: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1879: .nom_fonction, "-");
! 1880: }
! 1881:
! 1882: /*
! 1883: --------------------------------------------------------------------------------
! 1884: Soustraction impossible
! 1885: --------------------------------------------------------------------------------
! 1886: */
! 1887:
! 1888: else
! 1889: {
! 1890: liberation(s_etat_processus, s_objet_argument_1);
! 1891: liberation(s_etat_processus, s_objet_argument_2);
! 1892:
! 1893: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1894: return;
! 1895: }
! 1896:
! 1897: liberation(s_etat_processus, s_objet_argument_1);
! 1898: liberation(s_etat_processus, s_objet_argument_2);
! 1899:
! 1900: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1901: s_objet_resultat) == d_erreur)
! 1902: {
! 1903: return;
! 1904: }
! 1905:
! 1906: return;
! 1907: }
! 1908:
! 1909:
! 1910: /*
! 1911: ================================================================================
! 1912: Fonction '*'
! 1913: ================================================================================
! 1914: Entrées : structure processus
! 1915: --------------------------------------------------------------------------------
! 1916: Sorties :
! 1917: --------------------------------------------------------------------------------
! 1918: Effets de bord : néant
! 1919: ================================================================================
! 1920: */
! 1921:
! 1922: void
! 1923: instruction_multiplication(struct_processus *s_etat_processus)
! 1924: {
! 1925: integer8 cumul;
! 1926: integer8 tampon;
! 1927:
! 1928: logical1 depassement;
! 1929: logical1 drapeau;
! 1930: logical1 erreur_memoire;
! 1931:
! 1932: struct_liste_chainee *l_element_courant;
! 1933: struct_liste_chainee *l_element_precedent;
! 1934:
! 1935: struct_objet *s_copie_argument_1;
! 1936: struct_objet *s_copie_argument_2;
! 1937: struct_objet *s_objet_argument_1;
! 1938: struct_objet *s_objet_argument_2;
! 1939: struct_objet *s_objet_resultat;
! 1940:
! 1941: unsigned long i;
! 1942: unsigned long j;
! 1943: unsigned long k;
! 1944: unsigned long nombre_elements;
! 1945:
! 1946: void *accumulateur;
! 1947:
! 1948: (*s_etat_processus).erreur_execution = d_ex;
! 1949:
! 1950: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1951: {
! 1952: printf("\n * ");
! 1953:
! 1954: if ((*s_etat_processus).langue == 'F')
! 1955: {
! 1956: printf("(multiplication)\n\n");
! 1957: }
! 1958: else
! 1959: {
! 1960: printf("(multiplication)\n\n");
! 1961: }
! 1962:
! 1963: printf(" 2: %s, %s, %s\n", d_INT, d_REL, d_CPL);
! 1964: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
! 1965: printf("-> 1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL);
! 1966:
! 1967: printf(" 2: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
! 1968: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
! 1969: printf("-> 1: %s, %s, %s\n\n", d_VIN, d_VRL, d_VCX);
! 1970:
! 1971: printf(" 2: %s, %s, %s\n", d_INT, d_REL, d_CPL);
! 1972: printf(" 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
! 1973: printf("-> 1: %s, %s, %s\n\n", d_VIN, d_VRL, d_VCX);
! 1974:
! 1975: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 1976: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
! 1977: printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX);
! 1978:
! 1979: printf(" 2: %s, %s, %s\n", d_INT, d_REL, d_CPL);
! 1980: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 1981: printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX);
! 1982:
! 1983: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 1984: printf(" 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
! 1985: printf("-> 1: %s, %s, %s\n\n", d_VIN, d_VRL, d_VCX);
! 1986:
! 1987: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 1988: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 1989: printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX);
! 1990:
! 1991: printf(" 2: %s, %s\n", d_BIN, d_INT);
! 1992: printf(" 1: %s, %s\n", d_BIN, d_INT);
! 1993: printf("-> 1: %s\n\n", d_BIN);
! 1994:
! 1995: printf(" 2: %s, %s, %s, %s, %s, %s\n",
! 1996: d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN);
! 1997: printf(" 1: %s, %s, %s, %s, %s, %s\n",
! 1998: d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN);
! 1999: printf("-> 1: %s, %s\n", d_ALG, d_RPN);
! 2000:
! 2001: return;
! 2002: }
! 2003: else if ((*s_etat_processus).test_instruction == 'Y')
! 2004: {
! 2005: (*s_etat_processus).nombre_arguments = 0;
! 2006: return;
! 2007: }
! 2008:
! 2009: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 2010: {
! 2011: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 2012: {
! 2013: return;
! 2014: }
! 2015: }
! 2016:
! 2017: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2018: &s_objet_argument_1) == d_erreur)
! 2019: {
! 2020: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 2021: return;
! 2022: }
! 2023:
! 2024: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2025: &s_objet_argument_2) == d_erreur)
! 2026: {
! 2027: liberation(s_etat_processus, s_objet_argument_1);
! 2028:
! 2029: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 2030: return;
! 2031: }
! 2032:
! 2033: /*
! 2034: --------------------------------------------------------------------------------
! 2035: Multiplication de deux entiers
! 2036: --------------------------------------------------------------------------------
! 2037: */
! 2038:
! 2039: if (((*s_objet_argument_1).type == INT) &&
! 2040: ((*s_objet_argument_2).type == INT))
! 2041: {
! 2042: if (depassement_multiplication((integer8 *) (*s_objet_argument_1)
! 2043: .objet, (integer8 *) (*s_objet_argument_2).objet, &tampon) ==
! 2044: d_absence_erreur)
! 2045: {
! 2046: if ((s_objet_resultat = allocation(s_etat_processus, INT))
! 2047: == NULL)
! 2048: {
! 2049: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2050: return;
! 2051: }
! 2052:
! 2053: (*((integer8 *) (*s_objet_resultat).objet)) = tampon;
! 2054: }
! 2055: else
! 2056: {
! 2057: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 2058: == NULL)
! 2059: {
! 2060: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2061: return;
! 2062: }
! 2063:
! 2064: (*((real8 *) (*s_objet_resultat).objet)) = ((real8) (*((integer8 *)
! 2065: (*s_objet_argument_2).objet))) * ((real8) (*((integer8 *)
! 2066: (*s_objet_argument_1).objet)));
! 2067: }
! 2068: }
! 2069:
! 2070: /*
! 2071: --------------------------------------------------------------------------------
! 2072: Multiplication d'un entier et d'un réel
! 2073: --------------------------------------------------------------------------------
! 2074: */
! 2075:
! 2076: else if ((((*s_objet_argument_1).type == INT) &&
! 2077: ((*s_objet_argument_2).type == REL)) ||
! 2078: (((*s_objet_argument_1).type == REL) &&
! 2079: ((*s_objet_argument_2).type == INT)))
! 2080: {
! 2081: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 2082: == NULL)
! 2083: {
! 2084: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2085: return;
! 2086: }
! 2087:
! 2088: if ((*s_objet_argument_1).type == INT)
! 2089: {
! 2090: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
! 2091: (*s_objet_argument_2).objet)) * (*((integer8 *)
! 2092: (*s_objet_argument_1).objet));
! 2093: }
! 2094: else
! 2095: {
! 2096: (*((real8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
! 2097: (*s_objet_argument_2).objet)) * (*((real8 *)
! 2098: (*s_objet_argument_1).objet));
! 2099: }
! 2100: }
! 2101:
! 2102: /*
! 2103: --------------------------------------------------------------------------------
! 2104: Multiplication d'un entier et d'un complexe
! 2105: --------------------------------------------------------------------------------
! 2106: */
! 2107:
! 2108: else if ((((*s_objet_argument_1).type == INT) &&
! 2109: ((*s_objet_argument_2).type == CPL)) ||
! 2110: (((*s_objet_argument_1).type == CPL) &&
! 2111: ((*s_objet_argument_2).type == INT)))
! 2112: {
! 2113: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 2114: == NULL)
! 2115: {
! 2116: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2117: return;
! 2118: }
! 2119:
! 2120: if ((*s_objet_argument_1).type == INT)
! 2121: {
! 2122: f77multiplicationci_((struct_complexe16 *) (*s_objet_argument_2)
! 2123: .objet, (integer8 *) (*s_objet_argument_1).objet,
! 2124: (struct_complexe16 *) (*s_objet_resultat).objet);
! 2125: }
! 2126: else
! 2127: {
! 2128: f77multiplicationci_((struct_complexe16 *) (*s_objet_argument_1)
! 2129: .objet, (integer8 *) (*s_objet_argument_2).objet,
! 2130: (struct_complexe16 *) (*s_objet_resultat).objet);
! 2131: }
! 2132: }
! 2133:
! 2134: /*
! 2135: --------------------------------------------------------------------------------
! 2136: Multiplication de deux réels
! 2137: --------------------------------------------------------------------------------
! 2138: */
! 2139:
! 2140: else if (((*s_objet_argument_1).type == REL) &&
! 2141: ((*s_objet_argument_2).type == REL))
! 2142: {
! 2143: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 2144: == NULL)
! 2145: {
! 2146: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2147: return;
! 2148: }
! 2149:
! 2150: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
! 2151: (*s_objet_argument_2).objet)) * (*((real8 *)
! 2152: (*s_objet_argument_1).objet));
! 2153: }
! 2154:
! 2155: /*
! 2156: --------------------------------------------------------------------------------
! 2157: Multiplication d'un réel et d'un complexe
! 2158: --------------------------------------------------------------------------------
! 2159: */
! 2160:
! 2161: else if ((((*s_objet_argument_1).type == REL) &&
! 2162: ((*s_objet_argument_2).type == CPL)) ||
! 2163: (((*s_objet_argument_1).type == CPL) &&
! 2164: ((*s_objet_argument_2).type == REL)))
! 2165: {
! 2166: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 2167: == NULL)
! 2168: {
! 2169: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2170: return;
! 2171: }
! 2172:
! 2173: if ((*s_objet_argument_1).type == REL)
! 2174: {
! 2175: f77multiplicationcr_((struct_complexe16 *)
! 2176: (*s_objet_argument_2).objet,
! 2177: (real8 *) (*s_objet_argument_1).objet,
! 2178: (struct_complexe16 *) (*s_objet_resultat).objet);
! 2179: }
! 2180: else
! 2181: {
! 2182: f77multiplicationcr_((struct_complexe16 *) (*s_objet_argument_1)
! 2183: .objet, (real8 *) (*s_objet_argument_2).objet,
! 2184: (struct_complexe16 *) (*s_objet_resultat).objet);
! 2185: }
! 2186: }
! 2187:
! 2188: /*
! 2189: --------------------------------------------------------------------------------
! 2190: Multiplication de deux complexes
! 2191: --------------------------------------------------------------------------------
! 2192: */
! 2193:
! 2194: else if (((*s_objet_argument_1).type == CPL) &&
! 2195: ((*s_objet_argument_2).type == CPL))
! 2196: {
! 2197: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 2198: == NULL)
! 2199: {
! 2200: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2201: return;
! 2202: }
! 2203:
! 2204: f77multiplicationcc_((struct_complexe16 *) (*s_objet_argument_2).objet,
! 2205: (struct_complexe16 *) (*s_objet_argument_1).objet,
! 2206: (struct_complexe16 *) (*s_objet_resultat).objet);
! 2207: }
! 2208:
! 2209: /*
! 2210: --------------------------------------------------------------------------------
! 2211: Multiplication d'un vecteur par un scalaire
! 2212: --------------------------------------------------------------------------------
! 2213: */
! 2214: /*
! 2215: * Vecteur d'entiers / Entier
! 2216: */
! 2217:
! 2218: else if ((((*s_objet_argument_1).type == VIN) &&
! 2219: ((*s_objet_argument_2).type == INT)) ||
! 2220: (((*s_objet_argument_1).type == INT) &&
! 2221: ((*s_objet_argument_2).type == VIN)))
! 2222: {
! 2223: if ((s_objet_resultat = allocation(s_etat_processus, VIN))
! 2224: == NULL)
! 2225: {
! 2226: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2227: return;
! 2228: }
! 2229:
! 2230: if ((*s_objet_argument_1).type == VIN)
! 2231: {
! 2232: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2233: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 2234: }
! 2235: else
! 2236: {
! 2237: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2238: (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;
! 2239: }
! 2240:
! 2241: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 2242: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 2243: .objet))).taille * sizeof(integer8))) == NULL)
! 2244: {
! 2245: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2246: return;
! 2247: }
! 2248:
! 2249: depassement = d_faux;
! 2250:
! 2251: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 2252: .objet))).taille; i++)
! 2253: {
! 2254: if ((*s_objet_argument_1).type == VIN)
! 2255: {
! 2256: if (depassement_multiplication((integer8 *)
! 2257: (*s_objet_argument_2).objet, &(((integer8 *)
! 2258: (*((struct_vecteur *) (*s_objet_argument_1).objet))
! 2259: .tableau)[i]), &(((integer8 *) (*((struct_vecteur *)
! 2260: (*s_objet_resultat).objet)).tableau)[i])) == d_erreur)
! 2261: {
! 2262: depassement = d_vrai;
! 2263: }
! 2264: }
! 2265: else
! 2266: {
! 2267: if (depassement_multiplication((integer8 *)
! 2268: (*s_objet_argument_1).objet, &(((integer8 *)
! 2269: (*((struct_vecteur *) (*s_objet_argument_2).objet))
! 2270: .tableau)[i]), &(((integer8 *) (*((struct_vecteur *)
! 2271: (*s_objet_resultat).objet)).tableau)[i])) == d_erreur)
! 2272: {
! 2273: depassement = d_vrai;
! 2274: }
! 2275: }
! 2276: }
! 2277:
! 2278: if (depassement == d_vrai)
! 2279: {
! 2280: (*s_objet_resultat).type = VRL;
! 2281: (*((struct_vecteur *) (*s_objet_resultat).objet)).type = 'R';
! 2282:
! 2283: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 2284: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 2285: .objet))).taille * sizeof(real8))) == NULL)
! 2286: {
! 2287: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2288: return;
! 2289: }
! 2290:
! 2291: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 2292: .objet))).taille; i++)
! 2293: {
! 2294: if ((*s_objet_argument_1).type == VIN)
! 2295: {
! 2296: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 2297: .tableau)[i] = ((real8) (*((integer8 *)
! 2298: (*s_objet_argument_2).objet))) * ((real8)
! 2299: ((integer8 *) (*((struct_vecteur *)
! 2300: (*s_objet_argument_1).objet)).tableau)[i]);
! 2301: }
! 2302: else
! 2303: {
! 2304: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 2305: .tableau)[i] = ((real8) (*((integer8 *)
! 2306: (*s_objet_argument_1).objet))) * ((real8)
! 2307: ((integer8 *) (*((struct_vecteur *)
! 2308: (*s_objet_argument_2).objet)).tableau)[i]);
! 2309: }
! 2310: }
! 2311: }
! 2312: }
! 2313:
! 2314: /*
! 2315: * Vecteur de réels / Entier
! 2316: */
! 2317:
! 2318: else if ((((*s_objet_argument_1).type == VRL) &&
! 2319: ((*s_objet_argument_2).type == INT)) ||
! 2320: (((*s_objet_argument_1).type == INT) &&
! 2321: ((*s_objet_argument_2).type == VRL)))
! 2322: {
! 2323: if ((s_objet_resultat = allocation(s_etat_processus, VRL))
! 2324: == NULL)
! 2325: {
! 2326: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2327: return;
! 2328: }
! 2329:
! 2330: if ((*s_objet_argument_1).type == VRL)
! 2331: {
! 2332: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2333: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 2334: }
! 2335: else
! 2336: {
! 2337: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2338: (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;
! 2339: }
! 2340:
! 2341: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 2342: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 2343: .objet))).taille * sizeof(real8))) == NULL)
! 2344: {
! 2345: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2346: return;
! 2347: }
! 2348:
! 2349: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 2350: .objet))).taille; i++)
! 2351: {
! 2352: if ((*s_objet_argument_1).type == VRL)
! 2353: {
! 2354: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 2355: .tableau)[i] = (*((integer8 *) (*s_objet_argument_2)
! 2356: .objet)) * ((real8 *) (*((struct_vecteur *)
! 2357: (*s_objet_argument_1).objet)).tableau)[i];
! 2358: }
! 2359: else
! 2360: {
! 2361: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 2362: .tableau)[i] = (*((integer8 *) (*s_objet_argument_1)
! 2363: .objet)) * ((real8 *) (*((struct_vecteur *)
! 2364: (*s_objet_argument_2).objet)).tableau)[i];
! 2365: }
! 2366: }
! 2367: }
! 2368:
! 2369: /*
! 2370: * Vecteur de complexes / Entier
! 2371: */
! 2372:
! 2373: else if ((((*s_objet_argument_1).type == VCX) &&
! 2374: ((*s_objet_argument_2).type == INT)) ||
! 2375: (((*s_objet_argument_1).type == INT) &&
! 2376: ((*s_objet_argument_2).type == VCX)))
! 2377: {
! 2378: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 2379: == NULL)
! 2380: {
! 2381: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2382: return;
! 2383: }
! 2384:
! 2385: if ((*s_objet_argument_1).type == VCX)
! 2386: {
! 2387: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2388: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 2389: }
! 2390: else
! 2391: {
! 2392: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2393: (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;
! 2394: }
! 2395:
! 2396: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 2397: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 2398: .objet))).taille * sizeof(struct_complexe16))) == NULL)
! 2399: {
! 2400: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2401: return;
! 2402: }
! 2403:
! 2404: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 2405: .objet))).taille; i++)
! 2406: {
! 2407: if ((*s_objet_argument_1).type == VCX)
! 2408: {
! 2409: f77multiplicationci_(&(((struct_complexe16 *)
! 2410: (*((struct_vecteur *)
! 2411: (*s_objet_argument_1).objet)).tableau)[i]),
! 2412: &((*((integer8 *) (*s_objet_argument_2).objet))),
! 2413: &(((struct_complexe16 *) (*((struct_vecteur *)
! 2414: (*s_objet_resultat).objet)).tableau)[i]));
! 2415: }
! 2416: else
! 2417: {
! 2418: f77multiplicationci_(&(((struct_complexe16 *)
! 2419: (*((struct_vecteur *)
! 2420: (*s_objet_argument_2).objet)).tableau)[i]),
! 2421: &((*((integer8 *) (*s_objet_argument_1).objet))),
! 2422: &(((struct_complexe16 *) (*((struct_vecteur *)
! 2423: (*s_objet_resultat).objet)).tableau)[i]));
! 2424: }
! 2425: }
! 2426: }
! 2427:
! 2428: /*
! 2429: * Vecteur d'entiers / Réel
! 2430: */
! 2431:
! 2432: else if ((((*s_objet_argument_1).type == VIN) &&
! 2433: ((*s_objet_argument_2).type == REL)) ||
! 2434: (((*s_objet_argument_1).type == REL) &&
! 2435: ((*s_objet_argument_2).type == VIN)))
! 2436: {
! 2437: if ((s_objet_resultat = allocation(s_etat_processus, VRL))
! 2438: == NULL)
! 2439: {
! 2440: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2441: return;
! 2442: }
! 2443:
! 2444: if ((*s_objet_argument_1).type == VIN)
! 2445: {
! 2446: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2447: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 2448: }
! 2449: else
! 2450: {
! 2451: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2452: (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;
! 2453: }
! 2454:
! 2455: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 2456: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 2457: .objet))).taille * sizeof(real8))) == NULL)
! 2458: {
! 2459: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2460: return;
! 2461: }
! 2462:
! 2463: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 2464: .objet))).taille; i++)
! 2465: {
! 2466: if ((*s_objet_argument_1).type == VIN)
! 2467: {
! 2468: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 2469: .tableau)[i] = (*((real8 *) (*s_objet_argument_2)
! 2470: .objet)) * ((integer8 *) (*((struct_vecteur *)
! 2471: (*s_objet_argument_1).objet)).tableau)[i];
! 2472: }
! 2473: else
! 2474: {
! 2475: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 2476: .tableau)[i] = (*((real8 *) (*s_objet_argument_1)
! 2477: .objet)) * ((integer8 *) (*((struct_vecteur *)
! 2478: (*s_objet_argument_2).objet)).tableau)[i];
! 2479: }
! 2480: }
! 2481: }
! 2482:
! 2483: /*
! 2484: * Vecteur de réels / Réel
! 2485: */
! 2486:
! 2487: else if ((((*s_objet_argument_1).type == VRL) &&
! 2488: ((*s_objet_argument_2).type == REL)) ||
! 2489: (((*s_objet_argument_1).type == REL) &&
! 2490: ((*s_objet_argument_2).type == VRL)))
! 2491: {
! 2492: if ((s_objet_resultat = allocation(s_etat_processus, VRL))
! 2493: == NULL)
! 2494: {
! 2495: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2496: return;
! 2497: }
! 2498:
! 2499: if ((*s_objet_argument_1).type == VRL)
! 2500: {
! 2501: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2502: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 2503: }
! 2504: else
! 2505: {
! 2506: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2507: (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;
! 2508: }
! 2509:
! 2510: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 2511: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 2512: .objet))).taille * sizeof(real8))) == NULL)
! 2513: {
! 2514: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2515: return;
! 2516: }
! 2517:
! 2518: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 2519: .objet))).taille; i++)
! 2520: {
! 2521: if ((*s_objet_argument_1).type == VRL)
! 2522: {
! 2523: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 2524: .tableau)[i] = (*((real8 *) (*s_objet_argument_2)
! 2525: .objet)) * ((real8 *) (*((struct_vecteur *)
! 2526: (*s_objet_argument_1).objet)).tableau)[i];
! 2527: }
! 2528: else
! 2529: {
! 2530: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 2531: .tableau)[i] = (*((real8 *) (*s_objet_argument_1)
! 2532: .objet)) * ((real8 *) (*((struct_vecteur *)
! 2533: (*s_objet_argument_2).objet)).tableau)[i];
! 2534: }
! 2535: }
! 2536: }
! 2537:
! 2538: /*
! 2539: * Vecteur de complexes / Réel
! 2540: */
! 2541:
! 2542: else if ((((*s_objet_argument_1).type == VCX) &&
! 2543: ((*s_objet_argument_2).type == REL)) ||
! 2544: (((*s_objet_argument_1).type == REL) &&
! 2545: ((*s_objet_argument_2).type == VCX)))
! 2546: {
! 2547: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 2548: == NULL)
! 2549: {
! 2550: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2551: return;
! 2552: }
! 2553:
! 2554: if ((*s_objet_argument_1).type == VCX)
! 2555: {
! 2556: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2557: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 2558: }
! 2559: else
! 2560: {
! 2561: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2562: (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;
! 2563: }
! 2564:
! 2565: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 2566: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 2567: .objet))).taille * sizeof(struct_complexe16))) == NULL)
! 2568: {
! 2569: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2570: return;
! 2571: }
! 2572:
! 2573: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 2574: .objet))).taille; i++)
! 2575: {
! 2576: if ((*s_objet_argument_1).type == VCX)
! 2577: {
! 2578: f77multiplicationcr_(&(((struct_complexe16 *)
! 2579: (*((struct_vecteur *)
! 2580: (*s_objet_argument_1).objet)).tableau)[i]),
! 2581: &((*((real8 *) (*s_objet_argument_2).objet))),
! 2582: &(((struct_complexe16 *) (*((struct_vecteur *)
! 2583: (*s_objet_resultat).objet)).tableau)[i]));
! 2584: }
! 2585: else
! 2586: {
! 2587: f77multiplicationcr_(&(((struct_complexe16 *)
! 2588: (*((struct_vecteur *)
! 2589: (*s_objet_argument_2).objet)).tableau)[i]),
! 2590: &((*((real8 *) (*s_objet_argument_1).objet))),
! 2591: &(((struct_complexe16 *) (*((struct_vecteur *)
! 2592: (*s_objet_resultat).objet)).tableau)[i]));
! 2593: }
! 2594: }
! 2595: }
! 2596:
! 2597: /*
! 2598: * Vecteur d'entiers / Complexe
! 2599: */
! 2600:
! 2601: else if ((((*s_objet_argument_1).type == VIN) &&
! 2602: ((*s_objet_argument_2).type == CPL)) ||
! 2603: (((*s_objet_argument_1).type == CPL) &&
! 2604: ((*s_objet_argument_2).type == VIN)))
! 2605: {
! 2606: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 2607: == NULL)
! 2608: {
! 2609: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2610: return;
! 2611: }
! 2612:
! 2613: if ((*s_objet_argument_1).type == VIN)
! 2614: {
! 2615: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2616: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 2617: }
! 2618: else
! 2619: {
! 2620: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2621: (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;
! 2622: }
! 2623:
! 2624: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 2625: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 2626: .objet))).taille * sizeof(struct_complexe16))) == NULL)
! 2627: {
! 2628: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2629: return;
! 2630: }
! 2631:
! 2632: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 2633: .objet))).taille; i++)
! 2634: {
! 2635: if ((*s_objet_argument_1).type == VIN)
! 2636: {
! 2637: f77multiplicationci_(&((*((struct_complexe16 *)
! 2638: (*s_objet_argument_2).objet))),
! 2639: &(((integer8 *) (*((struct_vecteur *)
! 2640: (*s_objet_argument_1).objet)).tableau)[i]),
! 2641: &(((struct_complexe16 *) (*((struct_vecteur *)
! 2642: (*s_objet_resultat).objet)).tableau)[i]));
! 2643: }
! 2644: else
! 2645: {
! 2646: f77multiplicationci_(&((*((struct_complexe16 *)
! 2647: (*s_objet_argument_1).objet))),
! 2648: &(((integer8 *) (*((struct_vecteur *)
! 2649: (*s_objet_argument_2).objet)).tableau)[i]),
! 2650: &(((struct_complexe16 *) (*((struct_vecteur *)
! 2651: (*s_objet_resultat).objet)).tableau)[i]));
! 2652: }
! 2653: }
! 2654: }
! 2655:
! 2656: /*
! 2657: * Vecteur de réels / Complexe
! 2658: */
! 2659:
! 2660: else if ((((*s_objet_argument_1).type == VRL) &&
! 2661: ((*s_objet_argument_2).type == CPL)) ||
! 2662: (((*s_objet_argument_1).type == CPL) &&
! 2663: ((*s_objet_argument_2).type == VRL)))
! 2664: {
! 2665: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 2666: == NULL)
! 2667: {
! 2668: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2669: return;
! 2670: }
! 2671:
! 2672: if ((*s_objet_argument_1).type == VRL)
! 2673: {
! 2674: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2675: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 2676: }
! 2677: else
! 2678: {
! 2679: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2680: (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;
! 2681: }
! 2682:
! 2683: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 2684: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 2685: .objet))).taille * sizeof(struct_complexe16))) == NULL)
! 2686: {
! 2687: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2688: return;
! 2689: }
! 2690:
! 2691: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 2692: .objet))).taille; i++)
! 2693: {
! 2694: if ((*s_objet_argument_1).type == VRL)
! 2695: {
! 2696: f77multiplicationcr_(&((*((struct_complexe16 *)
! 2697: (*s_objet_argument_2).objet))),
! 2698: &(((real8 *) (*((struct_vecteur *)
! 2699: (*s_objet_argument_1).objet)).tableau)[i]),
! 2700: &(((struct_complexe16 *) (*((struct_vecteur *)
! 2701: (*s_objet_resultat).objet)).tableau)[i]));
! 2702: }
! 2703: else
! 2704: {
! 2705: f77multiplicationcr_(&((*((struct_complexe16 *)
! 2706: (*s_objet_argument_1).objet))),
! 2707: &(((real8 *) (*((struct_vecteur *)
! 2708: (*s_objet_argument_2).objet)).tableau)[i]),
! 2709: &(((struct_complexe16 *) (*((struct_vecteur *)
! 2710: (*s_objet_resultat).objet)).tableau)[i]));
! 2711: }
! 2712: }
! 2713: }
! 2714:
! 2715: /*
! 2716: * Vecteur de complexes / Complexe
! 2717: */
! 2718:
! 2719: else if ((((*s_objet_argument_1).type == VCX) &&
! 2720: ((*s_objet_argument_2).type == CPL)) ||
! 2721: (((*s_objet_argument_1).type == CPL) &&
! 2722: ((*s_objet_argument_2).type == VCX)))
! 2723: {
! 2724: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 2725: == NULL)
! 2726: {
! 2727: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2728: return;
! 2729: }
! 2730:
! 2731: if ((*s_objet_argument_1).type == VCX)
! 2732: {
! 2733: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2734: (*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
! 2735: }
! 2736: else
! 2737: {
! 2738: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 2739: (*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;
! 2740: }
! 2741:
! 2742: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 2743: malloc((*(((struct_vecteur *) (*s_objet_resultat)
! 2744: .objet))).taille * sizeof(struct_complexe16))) == NULL)
! 2745: {
! 2746: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2747: return;
! 2748: }
! 2749:
! 2750: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
! 2751: .objet))).taille; i++)
! 2752: {
! 2753: if ((*s_objet_argument_1).type == VCX)
! 2754: {
! 2755: f77multiplicationcc_(&(((struct_complexe16 *)
! 2756: (*((struct_vecteur *)
! 2757: (*s_objet_argument_1).objet)).tableau)[i]),
! 2758: &((*((struct_complexe16 *)
! 2759: (*s_objet_argument_2).objet))),
! 2760: &(((struct_complexe16 *) (*((struct_vecteur *)
! 2761: (*s_objet_resultat).objet)).tableau)[i]));
! 2762: }
! 2763: else
! 2764: {
! 2765: f77multiplicationcc_(&(((struct_complexe16 *)
! 2766: (*((struct_vecteur *)
! 2767: (*s_objet_argument_2).objet)).tableau)[i]),
! 2768: &((*((struct_complexe16 *)
! 2769: (*s_objet_argument_1).objet))),
! 2770: &(((struct_complexe16 *) (*((struct_vecteur *)
! 2771: (*s_objet_resultat).objet)).tableau)[i]));
! 2772: }
! 2773: }
! 2774: }
! 2775:
! 2776: /*
! 2777: --------------------------------------------------------------------------------
! 2778: Multiplication d'une matrice par un scalaire
! 2779: --------------------------------------------------------------------------------
! 2780: */
! 2781: /*
! 2782: * Matrice d'entiers / Entier
! 2783: */
! 2784:
! 2785: else if ((((*s_objet_argument_1).type == MIN) &&
! 2786: ((*s_objet_argument_2).type == INT)) ||
! 2787: (((*s_objet_argument_1).type == INT) &&
! 2788: ((*s_objet_argument_2).type == MIN)))
! 2789: {
! 2790: if ((s_objet_resultat = allocation(s_etat_processus, MIN))
! 2791: == NULL)
! 2792: {
! 2793: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2794: return;
! 2795: }
! 2796:
! 2797: if ((*s_objet_argument_1).type == MIN)
! 2798: {
! 2799: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 2800: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 2801: .nombre_lignes;
! 2802: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 2803: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 2804: .nombre_colonnes;
! 2805: }
! 2806: else
! 2807: {
! 2808: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 2809: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 2810: .nombre_lignes;
! 2811: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 2812: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 2813: .nombre_colonnes;
! 2814: }
! 2815:
! 2816: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 2817: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 2818: .objet))).nombre_lignes * sizeof(integer8 *))) == NULL)
! 2819: {
! 2820: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2821: return;
! 2822: }
! 2823:
! 2824: depassement = d_faux;
! 2825:
! 2826: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 2827: .objet))).nombre_lignes; i++)
! 2828: {
! 2829: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 2830: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 2831: .objet))).nombre_colonnes * sizeof(integer8))) == NULL)
! 2832: {
! 2833: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2834: return;
! 2835: }
! 2836:
! 2837: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 2838: .objet))).nombre_colonnes; j++)
! 2839: {
! 2840: if ((*s_objet_argument_1).type == MIN)
! 2841: {
! 2842: if (depassement_multiplication((integer8 *)
! 2843: (*s_objet_argument_2).objet, &(((integer8 **)
! 2844: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 2845: .tableau)[i][j]), &(((integer8 **)
! 2846: (*((struct_matrice *) (*s_objet_resultat).objet))
! 2847: .tableau)[i][j])) == d_erreur)
! 2848: {
! 2849: depassement = d_vrai;
! 2850: }
! 2851: }
! 2852: else
! 2853: {
! 2854: if (depassement_multiplication((integer8 *)
! 2855: (*s_objet_argument_1).objet, &(((integer8 **)
! 2856: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 2857: .tableau)[i][j]), &(((integer8 **)
! 2858: (*((struct_matrice *) (*s_objet_resultat).objet))
! 2859: .tableau)[i][j])) == d_erreur)
! 2860: {
! 2861: depassement = d_vrai;
! 2862: }
! 2863: }
! 2864: }
! 2865: }
! 2866:
! 2867: if (depassement == d_vrai)
! 2868: {
! 2869: (*s_objet_resultat).type = MRL;
! 2870: (*((struct_matrice *) (*s_objet_resultat).objet)).type = 'R';
! 2871:
! 2872: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 2873: .objet))).nombre_lignes; i++)
! 2874: {
! 2875: free(((integer8 **) (*((struct_matrice *)
! 2876: (*s_objet_resultat).objet)).tableau)[i]);
! 2877:
! 2878: if (((*((struct_matrice *) (*s_objet_resultat).objet))
! 2879: .tableau[i] = malloc((*(((struct_matrice *)
! 2880: (*s_objet_resultat).objet))).nombre_colonnes *
! 2881: sizeof(real8))) == NULL)
! 2882: {
! 2883: (*s_etat_processus).erreur_systeme =
! 2884: d_es_allocation_memoire;
! 2885: return;
! 2886: }
! 2887:
! 2888: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 2889: .objet))).nombre_colonnes; j++)
! 2890: {
! 2891: if ((*s_objet_argument_1).type == MIN)
! 2892: {
! 2893: ((real8 **) (*((struct_matrice *)
! 2894: (*s_objet_resultat).objet)).tableau)[i][j] =
! 2895: ((real8) (*((integer8 *) (*s_objet_argument_2)
! 2896: .objet))) * ((real8) ((integer8 **)
! 2897: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 2898: .tableau)[i][j]);
! 2899: }
! 2900: else
! 2901: {
! 2902: ((real8 **) (*((struct_matrice *)
! 2903: (*s_objet_resultat).objet)).tableau)[i][j] =
! 2904: ((real8) (*((integer8 *) (*s_objet_argument_1)
! 2905: .objet))) * ((real8) ((integer8 **)
! 2906: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 2907: .tableau)[i][j]);
! 2908: }
! 2909: }
! 2910: }
! 2911: }
! 2912: }
! 2913:
! 2914: /*
! 2915: * Matrice de réels / Entier
! 2916: */
! 2917:
! 2918: else if ((((*s_objet_argument_1).type == MRL) &&
! 2919: ((*s_objet_argument_2).type == INT)) ||
! 2920: (((*s_objet_argument_1).type == INT) &&
! 2921: ((*s_objet_argument_2).type == MRL)))
! 2922: {
! 2923: if ((s_objet_resultat = allocation(s_etat_processus, MRL))
! 2924: == NULL)
! 2925: {
! 2926: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2927: return;
! 2928: }
! 2929:
! 2930: if ((*s_objet_argument_1).type == MRL)
! 2931: {
! 2932: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 2933: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 2934: .nombre_lignes;
! 2935: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 2936: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 2937: .nombre_colonnes;
! 2938: }
! 2939: else
! 2940: {
! 2941: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 2942: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 2943: .nombre_lignes;
! 2944: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 2945: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 2946: .nombre_colonnes;
! 2947: }
! 2948:
! 2949: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 2950: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 2951: .objet))).nombre_lignes * sizeof(real8 *))) == NULL)
! 2952: {
! 2953: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2954: return;
! 2955: }
! 2956:
! 2957: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 2958: .objet))).nombre_lignes; i++)
! 2959: {
! 2960: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 2961: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 2962: .objet))).nombre_colonnes * sizeof(real8))) == NULL)
! 2963: {
! 2964: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2965: return;
! 2966: }
! 2967:
! 2968: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 2969: .objet))).nombre_colonnes; j++)
! 2970: {
! 2971: if ((*s_objet_argument_1).type == MRL)
! 2972: {
! 2973: ((real8 **) (*((struct_matrice *)
! 2974: (*s_objet_resultat).objet)).tableau)[i][j] =
! 2975: (*((integer8 *) (*s_objet_argument_2)
! 2976: .objet)) * ((real8 **) (*((struct_matrice *)
! 2977: (*s_objet_argument_1).objet)).tableau)[i][j];
! 2978: }
! 2979: else
! 2980: {
! 2981: ((real8 **) (*((struct_matrice *)
! 2982: (*s_objet_resultat).objet)).tableau)[i][j] =
! 2983: (*((integer8 *) (*s_objet_argument_1)
! 2984: .objet)) * ((real8 **) (*((struct_matrice *)
! 2985: (*s_objet_argument_2).objet)).tableau)[i][j];
! 2986: }
! 2987: }
! 2988: }
! 2989: }
! 2990:
! 2991: /*
! 2992: * Matrice de complexes / Entier
! 2993: */
! 2994:
! 2995: else if ((((*s_objet_argument_1).type == MCX) &&
! 2996: ((*s_objet_argument_2).type == INT)) ||
! 2997: (((*s_objet_argument_1).type == INT) &&
! 2998: ((*s_objet_argument_2).type == MCX)))
! 2999: {
! 3000: if ((s_objet_resultat = allocation(s_etat_processus, MCX))
! 3001: == NULL)
! 3002: {
! 3003: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3004: return;
! 3005: }
! 3006:
! 3007: if ((*s_objet_argument_1).type == MCX)
! 3008: {
! 3009: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3010: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3011: .nombre_lignes;
! 3012: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3013: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3014: .nombre_colonnes;
! 3015: }
! 3016: else
! 3017: {
! 3018: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3019: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3020: .nombre_lignes;
! 3021: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3022: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3023: .nombre_colonnes;
! 3024: }
! 3025:
! 3026: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 3027: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3028: .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 3029: {
! 3030: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3031: return;
! 3032: }
! 3033:
! 3034: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 3035: .objet))).nombre_lignes; i++)
! 3036: {
! 3037: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 3038: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3039: .objet))).nombre_colonnes * sizeof(struct_complexe16)))
! 3040: == NULL)
! 3041: {
! 3042: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3043: return;
! 3044: }
! 3045:
! 3046: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 3047: .objet))).nombre_colonnes; j++)
! 3048: {
! 3049: if ((*s_objet_argument_1).type == MCX)
! 3050: {
! 3051: f77multiplicationci_(&(((struct_complexe16 **)
! 3052: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3053: .tableau)[i][j]), &((*((integer8 *)
! 3054: (*s_objet_argument_2).objet))),
! 3055: &(((struct_complexe16 **) (*((struct_matrice *)
! 3056: (*s_objet_resultat).objet)).tableau)[i][j]));
! 3057: }
! 3058: else
! 3059: {
! 3060: f77multiplicationci_(&(((struct_complexe16 **)
! 3061: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3062: .tableau)[i][j]), &((*((integer8 *)
! 3063: (*s_objet_argument_1).objet))),
! 3064: &(((struct_complexe16 **) (*((struct_matrice *)
! 3065: (*s_objet_resultat).objet)).tableau)[i][j]));
! 3066: }
! 3067: }
! 3068: }
! 3069: }
! 3070:
! 3071: /*
! 3072: * Matrice d'entiers / Réel
! 3073: */
! 3074:
! 3075: else if ((((*s_objet_argument_1).type == MIN) &&
! 3076: ((*s_objet_argument_2).type == REL)) ||
! 3077: (((*s_objet_argument_1).type == REL) &&
! 3078: ((*s_objet_argument_2).type == MIN)))
! 3079: {
! 3080: if ((s_objet_resultat = allocation(s_etat_processus, MRL))
! 3081: == NULL)
! 3082: {
! 3083: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3084: return;
! 3085: }
! 3086:
! 3087: if ((*s_objet_argument_1).type == MIN)
! 3088: {
! 3089: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3090: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3091: .nombre_lignes;
! 3092: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3093: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3094: .nombre_colonnes;
! 3095: }
! 3096: else
! 3097: {
! 3098: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3099: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3100: .nombre_lignes;
! 3101: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3102: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3103: .nombre_colonnes;
! 3104: }
! 3105:
! 3106: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 3107: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3108: .objet))).nombre_lignes * sizeof(real8 *))) == NULL)
! 3109: {
! 3110: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3111: return;
! 3112: }
! 3113:
! 3114: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 3115: .objet))).nombre_lignes; i++)
! 3116: {
! 3117: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 3118: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3119: .objet))).nombre_colonnes * sizeof(real8))) == NULL)
! 3120: {
! 3121: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3122: return;
! 3123: }
! 3124:
! 3125: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 3126: .objet))).nombre_colonnes; j++)
! 3127: {
! 3128: if ((*s_objet_argument_1).type == MIN)
! 3129: {
! 3130: ((real8 **) (*((struct_matrice *)
! 3131: (*s_objet_resultat).objet)).tableau)[i][j] =
! 3132: (*((real8 *) (*s_objet_argument_2)
! 3133: .objet)) * ((integer8 **) (*((struct_matrice *)
! 3134: (*s_objet_argument_1).objet)).tableau)[i][j];
! 3135: }
! 3136: else
! 3137: {
! 3138: ((real8 **) (*((struct_matrice *)
! 3139: (*s_objet_resultat).objet)).tableau)[i][j] =
! 3140: (*((real8 *) (*s_objet_argument_1)
! 3141: .objet)) * ((integer8 **) (*((struct_matrice *)
! 3142: (*s_objet_argument_2).objet)).tableau)[i][j];
! 3143: }
! 3144: }
! 3145: }
! 3146: }
! 3147:
! 3148: /*
! 3149: * Matrice de réels / Réel
! 3150: */
! 3151:
! 3152: else if ((((*s_objet_argument_1).type == MRL) &&
! 3153: ((*s_objet_argument_2).type == REL)) ||
! 3154: (((*s_objet_argument_1).type == REL) &&
! 3155: ((*s_objet_argument_2).type == MRL)))
! 3156: {
! 3157: if ((s_objet_resultat = allocation(s_etat_processus, MRL))
! 3158: == NULL)
! 3159: {
! 3160: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3161: return;
! 3162: }
! 3163:
! 3164: if ((*s_objet_argument_1).type == MRL)
! 3165: {
! 3166: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3167: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3168: .nombre_lignes;
! 3169: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3170: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3171: .nombre_colonnes;
! 3172: }
! 3173: else
! 3174: {
! 3175: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3176: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3177: .nombre_lignes;
! 3178: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3179: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3180: .nombre_colonnes;
! 3181: }
! 3182:
! 3183: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 3184: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3185: .objet))).nombre_lignes * sizeof(real8 *))) == NULL)
! 3186: {
! 3187: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3188: return;
! 3189: }
! 3190:
! 3191: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 3192: .objet))).nombre_lignes; i++)
! 3193: {
! 3194: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 3195: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3196: .objet))).nombre_colonnes * sizeof(real8))) == NULL)
! 3197: {
! 3198: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3199: return;
! 3200: }
! 3201:
! 3202: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 3203: .objet))).nombre_colonnes; j++)
! 3204: {
! 3205: if ((*s_objet_argument_1).type == MRL)
! 3206: {
! 3207: ((real8 **) (*((struct_matrice *)
! 3208: (*s_objet_resultat).objet)).tableau)[i][j] =
! 3209: (*((real8 *) (*s_objet_argument_2)
! 3210: .objet)) * ((real8 **) (*((struct_matrice *)
! 3211: (*s_objet_argument_1).objet)).tableau)[i][j];
! 3212: }
! 3213: else
! 3214: {
! 3215: ((real8 **) (*((struct_matrice *)
! 3216: (*s_objet_resultat).objet)).tableau)[i][j] =
! 3217: (*((real8 *) (*s_objet_argument_1)
! 3218: .objet)) * ((real8 **) (*((struct_matrice *)
! 3219: (*s_objet_argument_2).objet)).tableau)[i][j];
! 3220: }
! 3221: }
! 3222: }
! 3223: }
! 3224:
! 3225: /*
! 3226: * Matrice de complexes / Réel
! 3227: */
! 3228:
! 3229: else if ((((*s_objet_argument_1).type == MCX) &&
! 3230: ((*s_objet_argument_2).type == REL)) ||
! 3231: (((*s_objet_argument_1).type == REL) &&
! 3232: ((*s_objet_argument_2).type == MCX)))
! 3233: {
! 3234: if ((s_objet_resultat = allocation(s_etat_processus, MCX))
! 3235: == NULL)
! 3236: {
! 3237: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3238: return;
! 3239: }
! 3240:
! 3241: if ((*s_objet_argument_1).type == MCX)
! 3242: {
! 3243: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3244: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3245: .nombre_lignes;
! 3246: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3247: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3248: .nombre_colonnes;
! 3249: }
! 3250: else
! 3251: {
! 3252: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3253: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3254: .nombre_lignes;
! 3255: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3256: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3257: .nombre_colonnes;
! 3258: }
! 3259:
! 3260: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 3261: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3262: .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 3263: {
! 3264: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3265: return;
! 3266: }
! 3267:
! 3268: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 3269: .objet))).nombre_lignes; i++)
! 3270: {
! 3271: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 3272: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3273: .objet))).nombre_colonnes * sizeof(struct_complexe16)))
! 3274: == NULL)
! 3275: {
! 3276: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3277: return;
! 3278: }
! 3279:
! 3280: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 3281: .objet))).nombre_colonnes; j++)
! 3282: {
! 3283: if ((*s_objet_argument_1).type == MCX)
! 3284: {
! 3285: f77multiplicationcr_(&(((struct_complexe16 **)
! 3286: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3287: .tableau)[i][j]), &((*((real8 *)
! 3288: (*s_objet_argument_2).objet))),
! 3289: &(((struct_complexe16 **) (*((struct_matrice *)
! 3290: (*s_objet_resultat).objet)).tableau)[i][j]));
! 3291: }
! 3292: else
! 3293: {
! 3294: f77multiplicationcr_(&(((struct_complexe16 **)
! 3295: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3296: .tableau)[i][j]), &((*((real8 *)
! 3297: (*s_objet_argument_1).objet))),
! 3298: &(((struct_complexe16 **) (*((struct_matrice *)
! 3299: (*s_objet_resultat).objet)).tableau)[i][j]));
! 3300: }
! 3301: }
! 3302: }
! 3303: }
! 3304:
! 3305: /*
! 3306: * Matrice d'entiers / Complexe
! 3307: */
! 3308:
! 3309: else if ((((*s_objet_argument_1).type == MIN) &&
! 3310: ((*s_objet_argument_2).type == CPL)) ||
! 3311: (((*s_objet_argument_1).type == CPL) &&
! 3312: ((*s_objet_argument_2).type == MIN)))
! 3313: {
! 3314: if ((s_objet_resultat = allocation(s_etat_processus, MCX))
! 3315: == NULL)
! 3316: {
! 3317: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3318: return;
! 3319: }
! 3320:
! 3321: if ((*s_objet_argument_1).type == MIN)
! 3322: {
! 3323: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3324: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3325: .nombre_lignes;
! 3326: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3327: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3328: .nombre_colonnes;
! 3329: }
! 3330: else
! 3331: {
! 3332: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3333: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3334: .nombre_lignes;
! 3335: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3336: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3337: .nombre_colonnes;
! 3338: }
! 3339:
! 3340: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 3341: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3342: .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 3343: {
! 3344: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3345: return;
! 3346: }
! 3347:
! 3348: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 3349: .objet))).nombre_lignes; i++)
! 3350: {
! 3351: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 3352: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3353: .objet))).nombre_colonnes * sizeof(struct_complexe16)))
! 3354: == NULL)
! 3355: {
! 3356: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3357: return;
! 3358: }
! 3359:
! 3360: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 3361: .objet))).nombre_colonnes; j++)
! 3362: {
! 3363: if ((*s_objet_argument_1).type == MIN)
! 3364: {
! 3365: f77multiplicationci_(&((*((struct_complexe16 *)
! 3366: (*s_objet_argument_2).objet))),
! 3367: &(((integer8 **) (*((struct_matrice *)
! 3368: (*s_objet_argument_1).objet)).tableau)[i][j]),
! 3369: &(((struct_complexe16 **) (*((struct_matrice *)
! 3370: (*s_objet_resultat).objet)).tableau)[i][j]));
! 3371: }
! 3372: else
! 3373: {
! 3374: f77multiplicationci_(&((*((struct_complexe16 *)
! 3375: (*s_objet_argument_1).objet))),
! 3376: &(((integer8 **) (*((struct_matrice *)
! 3377: (*s_objet_argument_2).objet)).tableau)[i][j]),
! 3378: &(((struct_complexe16 **) (*((struct_matrice *)
! 3379: (*s_objet_resultat).objet)).tableau)[i][j]));
! 3380: }
! 3381: }
! 3382: }
! 3383: }
! 3384:
! 3385: /*
! 3386: * Matrice de réels / Complexe
! 3387: */
! 3388:
! 3389: else if ((((*s_objet_argument_1).type == MRL) &&
! 3390: ((*s_objet_argument_2).type == CPL)) ||
! 3391: (((*s_objet_argument_1).type == CPL) &&
! 3392: ((*s_objet_argument_2).type == MRL)))
! 3393: {
! 3394: if ((s_objet_resultat = allocation(s_etat_processus, MCX))
! 3395: == NULL)
! 3396: {
! 3397: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3398: return;
! 3399: }
! 3400:
! 3401: if ((*s_objet_argument_1).type == MRL)
! 3402: {
! 3403: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3404: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3405: .nombre_lignes;
! 3406: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3407: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3408: .nombre_colonnes;
! 3409: }
! 3410: else
! 3411: {
! 3412: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3413: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3414: .nombre_lignes;
! 3415: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3416: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3417: .nombre_colonnes;
! 3418: }
! 3419:
! 3420: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 3421: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3422: .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 3423: {
! 3424: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3425: return;
! 3426: }
! 3427:
! 3428: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 3429: .objet))).nombre_lignes; i++)
! 3430: {
! 3431: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 3432: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3433: .objet))).nombre_colonnes * sizeof(struct_complexe16)))
! 3434: == NULL)
! 3435: {
! 3436: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3437: return;
! 3438: }
! 3439:
! 3440: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 3441: .objet))).nombre_colonnes; j++)
! 3442: {
! 3443: if ((*s_objet_argument_1).type == MRL)
! 3444: {
! 3445: f77multiplicationcr_(&((*((struct_complexe16 *)
! 3446: (*s_objet_argument_2).objet))),
! 3447: &(((real8 **) (*((struct_matrice *)
! 3448: (*s_objet_argument_1).objet)).tableau)[i][j]),
! 3449: &(((struct_complexe16 **) (*((struct_matrice *)
! 3450: (*s_objet_resultat).objet)).tableau)[i][j]));
! 3451: }
! 3452: else
! 3453: {
! 3454: f77multiplicationcr_(&((*((struct_complexe16 *)
! 3455: (*s_objet_argument_1).objet))),
! 3456: &(((real8 **) (*((struct_matrice *)
! 3457: (*s_objet_argument_2).objet)).tableau)[i][j]),
! 3458: &(((struct_complexe16 **) (*((struct_matrice *)
! 3459: (*s_objet_resultat).objet)).tableau)[i][j]));
! 3460: }
! 3461: }
! 3462: }
! 3463: }
! 3464:
! 3465: /*
! 3466: * Matrice de complexes / Complexe
! 3467: */
! 3468:
! 3469: else if ((((*s_objet_argument_1).type == MCX) &&
! 3470: ((*s_objet_argument_2).type == CPL)) ||
! 3471: (((*s_objet_argument_1).type == CPL) &&
! 3472: ((*s_objet_argument_2).type == MCX)))
! 3473: {
! 3474: if ((s_objet_resultat = allocation(s_etat_processus, MCX))
! 3475: == NULL)
! 3476: {
! 3477: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3478: return;
! 3479: }
! 3480:
! 3481: if ((*s_objet_argument_1).type == MCX)
! 3482: {
! 3483: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3484: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3485: .nombre_lignes;
! 3486: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3487: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 3488: .nombre_colonnes;
! 3489: }
! 3490: else
! 3491: {
! 3492: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 3493: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3494: .nombre_lignes;
! 3495: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 3496: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3497: .nombre_colonnes;
! 3498: }
! 3499:
! 3500: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 3501: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3502: .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 3503: {
! 3504: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3505: return;
! 3506: }
! 3507:
! 3508: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 3509: .objet))).nombre_lignes; i++)
! 3510: {
! 3511: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 3512: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 3513: .objet))).nombre_colonnes * sizeof(struct_complexe16)))
! 3514: == NULL)
! 3515: {
! 3516: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3517: return;
! 3518: }
! 3519:
! 3520: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 3521: .objet))).nombre_colonnes; j++)
! 3522: {
! 3523: if ((*s_objet_argument_1).type == MCX)
! 3524: {
! 3525: f77multiplicationcc_(&((*((struct_complexe16 *)
! 3526: (*s_objet_argument_2).objet))),
! 3527: &(((struct_complexe16 **) (*((struct_matrice *)
! 3528: (*s_objet_argument_1).objet)).tableau)[i][j]),
! 3529: &(((struct_complexe16 **) (*((struct_matrice *)
! 3530: (*s_objet_resultat).objet)).tableau)[i][j]));
! 3531: }
! 3532: else
! 3533: {
! 3534: f77multiplicationcc_(&((*((struct_complexe16 *)
! 3535: (*s_objet_argument_1).objet))),
! 3536: &(((struct_complexe16 **) (*((struct_matrice *)
! 3537: (*s_objet_argument_2).objet)).tableau)[i][j]),
! 3538: &(((struct_complexe16 **) (*((struct_matrice *)
! 3539: (*s_objet_resultat).objet)).tableau)[i][j]));
! 3540: }
! 3541: }
! 3542: }
! 3543: }
! 3544:
! 3545: /*
! 3546: --------------------------------------------------------------------------------
! 3547: Multiplication d'une matrice par un vecteur (résultat : vecteur)
! 3548: --------------------------------------------------------------------------------
! 3549: */
! 3550: /*
! 3551: * Matrice d'entiers / Vecteur d'entiers
! 3552: */
! 3553:
! 3554: else if (((*s_objet_argument_2).type == MIN) &&
! 3555: ((*s_objet_argument_1).type == VIN))
! 3556: {
! 3557: if ((s_objet_resultat = allocation(s_etat_processus, VIN))
! 3558: == NULL)
! 3559: {
! 3560: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3561: return;
! 3562: }
! 3563:
! 3564: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 3565: (*(((struct_matrice *) (*s_objet_argument_2)
! 3566: .objet))).nombre_lignes;
! 3567:
! 3568: if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille !=
! 3569: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3570: .nombre_colonnes)
! 3571: {
! 3572: liberation(s_etat_processus, s_objet_argument_1);
! 3573: liberation(s_etat_processus, s_objet_argument_2);
! 3574: liberation(s_etat_processus, s_objet_resultat);
! 3575:
! 3576: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 3577: return;
! 3578: }
! 3579:
! 3580: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 3581: malloc((*(((struct_matrice *) (*s_objet_argument_2)
! 3582: .objet))).nombre_lignes * sizeof(integer8))) == NULL)
! 3583: {
! 3584: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3585: return;
! 3586: }
! 3587:
! 3588: depassement = d_faux;
! 3589:
! 3590: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2)
! 3591: .objet))).nombre_lignes; i++)
! 3592: {
! 3593: ((integer8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 3594: .tableau)[i] = 0;
! 3595:
! 3596: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 3597: .objet))).nombre_colonnes; k++)
! 3598: {
! 3599: if (depassement_multiplication(&(((integer8 **)
! 3600: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3601: .tableau)[i][k]), &(((integer8 *) (*((struct_vecteur *)
! 3602: (*s_objet_argument_1).objet)).tableau)[k]), &tampon)
! 3603: == d_erreur)
! 3604: {
! 3605: depassement = d_vrai;
! 3606: }
! 3607:
! 3608: if (depassement_addition(&(((integer8 *) (*((struct_vecteur *)
! 3609: (*s_objet_resultat).objet)).tableau)[i]), &tampon,
! 3610: &cumul) == d_erreur)
! 3611: {
! 3612: depassement = d_vrai;
! 3613: }
! 3614:
! 3615: ((integer8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 3616: .tableau)[i] = cumul;
! 3617: }
! 3618: }
! 3619:
! 3620: if (depassement == d_vrai)
! 3621: {
! 3622: (*s_objet_resultat).type = VRL;
! 3623: (*((struct_vecteur *) (*s_objet_resultat).objet)).type = 'R';
! 3624:
! 3625: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 3626: malloc((*(((struct_matrice *) (*s_objet_argument_2)
! 3627: .objet))).nombre_lignes * sizeof(real8))) == NULL)
! 3628: {
! 3629: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3630: return;
! 3631: }
! 3632:
! 3633: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2)
! 3634: .objet))).nombre_lignes; i++)
! 3635: {
! 3636: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 3637: .tableau)[i] = 0;
! 3638:
! 3639: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 3640: .objet))).nombre_colonnes; k++)
! 3641: {
! 3642: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 3643: .tableau)[i] = ((real8) ((integer8 *)
! 3644: (*((struct_vecteur *) (*s_objet_resultat).objet))
! 3645: .tableau)[i]) + ((real8) (((integer8 **)
! 3646: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3647: .tableau)[i][k]) * ((real8) ((integer8 *)
! 3648: (*((struct_vecteur *) (*s_objet_argument_1).objet))
! 3649: .tableau)[k]));
! 3650: }
! 3651: }
! 3652: }
! 3653: }
! 3654:
! 3655: /*
! 3656: * Matrice d'entiers / Vecteur de réels
! 3657: */
! 3658:
! 3659: else if (((*s_objet_argument_2).type == MIN) &&
! 3660: ((*s_objet_argument_1).type == VRL))
! 3661: {
! 3662: if ((s_objet_resultat = allocation(s_etat_processus, VRL))
! 3663: == NULL)
! 3664: {
! 3665: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3666: return;
! 3667: }
! 3668:
! 3669: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 3670: (*(((struct_matrice *) (*s_objet_argument_2)
! 3671: .objet))).nombre_lignes;
! 3672:
! 3673: if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille !=
! 3674: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3675: .nombre_colonnes)
! 3676: {
! 3677: liberation(s_etat_processus, s_objet_argument_1);
! 3678: liberation(s_etat_processus, s_objet_argument_2);
! 3679: liberation(s_etat_processus, s_objet_resultat);
! 3680:
! 3681: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 3682: return;
! 3683: }
! 3684:
! 3685: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 3686: malloc((*(((struct_matrice *) (*s_objet_argument_2)
! 3687: .objet))).nombre_lignes * sizeof(real8))) == NULL)
! 3688: {
! 3689: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3690: return;
! 3691: }
! 3692:
! 3693: if ((accumulateur = malloc((*(((struct_matrice *)
! 3694: (*s_objet_argument_2).objet))).nombre_colonnes *
! 3695: sizeof(real8))) == NULL)
! 3696: {
! 3697: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3698: return;
! 3699: }
! 3700:
! 3701: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2)
! 3702: .objet))).nombre_lignes; i++)
! 3703: {
! 3704: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 3705: .objet))).nombre_colonnes; k++)
! 3706: {
! 3707: ((real8 *) accumulateur)[k] = (((integer8 **)
! 3708: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3709: .tableau)[i][k] * ((real8 *) (*((struct_vecteur *)
! 3710: (*s_objet_argument_1).objet)).tableau)[k]);
! 3711: }
! 3712:
! 3713: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 3714: .tableau)[i] = sommation_vecteur_reel(accumulateur,
! 3715: &((*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 3716: .nombre_colonnes), &erreur_memoire);
! 3717:
! 3718: if (erreur_memoire == d_vrai)
! 3719: {
! 3720: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3721: return;
! 3722: }
! 3723: }
! 3724:
! 3725: free(accumulateur);
! 3726: }
! 3727:
! 3728: /*
! 3729: * Matrice d'entiers / Vecteur de complexes
! 3730: */
! 3731:
! 3732: else if (((*s_objet_argument_2).type == MIN) &&
! 3733: ((*s_objet_argument_1).type == VCX))
! 3734: {
! 3735: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 3736: == NULL)
! 3737: {
! 3738: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3739: return;
! 3740: }
! 3741:
! 3742: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 3743: (*(((struct_matrice *) (*s_objet_argument_2)
! 3744: .objet))).nombre_lignes;
! 3745:
! 3746: if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille !=
! 3747: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3748: .nombre_colonnes)
! 3749: {
! 3750: liberation(s_etat_processus, s_objet_argument_1);
! 3751: liberation(s_etat_processus, s_objet_argument_2);
! 3752: liberation(s_etat_processus, s_objet_resultat);
! 3753:
! 3754: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 3755: return;
! 3756: }
! 3757:
! 3758: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 3759: malloc((*(((struct_matrice *) (*s_objet_argument_2)
! 3760: .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL)
! 3761: {
! 3762: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3763: return;
! 3764: }
! 3765:
! 3766: if ((accumulateur = malloc((*(((struct_matrice *)
! 3767: (*s_objet_argument_2).objet))).nombre_colonnes *
! 3768: sizeof(complex16))) == NULL)
! 3769: {
! 3770: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3771: return;
! 3772: }
! 3773:
! 3774: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2)
! 3775: .objet))).nombre_lignes; i++)
! 3776: {
! 3777: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 3778: .objet))).nombre_colonnes; k++)
! 3779: {
! 3780: f77multiplicationci_(&(((struct_complexe16 *)
! 3781: (*((struct_vecteur *) (*s_objet_argument_1).objet))
! 3782: .tableau)[k]), &(((integer8 **) (*((struct_matrice *)
! 3783: (*s_objet_argument_2).objet)).tableau)[i][k]),
! 3784: &(((complex16 *) accumulateur)[k]));
! 3785: }
! 3786:
! 3787: ((complex16 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 3788: .tableau)[i] = sommation_vecteur_complexe(accumulateur,
! 3789: &((*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 3790: .nombre_colonnes), &erreur_memoire);
! 3791:
! 3792: if (erreur_memoire == d_vrai)
! 3793: {
! 3794: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3795: return;
! 3796: }
! 3797: }
! 3798:
! 3799: free(accumulateur);
! 3800: }
! 3801:
! 3802: /*
! 3803: * Matrice de réels / Vecteur d'entiers
! 3804: */
! 3805:
! 3806: else if (((*s_objet_argument_2).type == MRL) &&
! 3807: ((*s_objet_argument_1).type == VIN))
! 3808: {
! 3809: if ((s_objet_resultat = allocation(s_etat_processus, VRL))
! 3810: == NULL)
! 3811: {
! 3812: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3813: return;
! 3814: }
! 3815:
! 3816: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 3817: (*(((struct_matrice *) (*s_objet_argument_2)
! 3818: .objet))).nombre_lignes;
! 3819:
! 3820: if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille !=
! 3821: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3822: .nombre_colonnes)
! 3823: {
! 3824: liberation(s_etat_processus, s_objet_argument_1);
! 3825: liberation(s_etat_processus, s_objet_argument_2);
! 3826: liberation(s_etat_processus, s_objet_resultat);
! 3827:
! 3828: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 3829: return;
! 3830: }
! 3831:
! 3832: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 3833: malloc((*(((struct_matrice *) (*s_objet_argument_2)
! 3834: .objet))).nombre_lignes * sizeof(real8))) == NULL)
! 3835: {
! 3836: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3837: return;
! 3838: }
! 3839:
! 3840: if ((accumulateur = malloc((*(((struct_matrice *)
! 3841: (*s_objet_argument_2).objet))).nombre_colonnes *
! 3842: sizeof(real8))) == NULL)
! 3843: {
! 3844: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3845: return;
! 3846: }
! 3847:
! 3848: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2)
! 3849: .objet))).nombre_lignes; i++)
! 3850: {
! 3851: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 3852: .objet))).nombre_colonnes; k++)
! 3853: {
! 3854: ((real8 *) accumulateur)[k] = (((real8 **) (*((struct_matrice *)
! 3855: (*s_objet_argument_2).objet)).tableau)[i][k] *
! 3856: ((integer8 *) (*((struct_vecteur *)
! 3857: (*s_objet_argument_1).objet)).tableau)[k]);
! 3858: }
! 3859:
! 3860: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 3861: .tableau)[i] = sommation_vecteur_reel(accumulateur,
! 3862: &((*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 3863: .nombre_colonnes), &erreur_memoire);
! 3864:
! 3865: if (erreur_memoire == d_vrai)
! 3866: {
! 3867: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3868: return;
! 3869: }
! 3870: }
! 3871:
! 3872: free(accumulateur);
! 3873: }
! 3874:
! 3875: /*
! 3876: * Matrice de réels / Vecteur de réels
! 3877: */
! 3878:
! 3879: else if (((*s_objet_argument_2).type == MRL) &&
! 3880: ((*s_objet_argument_1).type == VRL))
! 3881: {
! 3882: if ((s_objet_resultat = allocation(s_etat_processus, VRL))
! 3883: == NULL)
! 3884: {
! 3885: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3886: return;
! 3887: }
! 3888:
! 3889: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 3890: (*(((struct_matrice *) (*s_objet_argument_2)
! 3891: .objet))).nombre_lignes;
! 3892:
! 3893: if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille !=
! 3894: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3895: .nombre_colonnes)
! 3896: {
! 3897: liberation(s_etat_processus, s_objet_argument_1);
! 3898: liberation(s_etat_processus, s_objet_argument_2);
! 3899: liberation(s_etat_processus, s_objet_resultat);
! 3900:
! 3901: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 3902: return;
! 3903: }
! 3904:
! 3905: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 3906: malloc((*(((struct_matrice *) (*s_objet_argument_2)
! 3907: .objet))).nombre_lignes * sizeof(real8))) == NULL)
! 3908: {
! 3909: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3910: return;
! 3911: }
! 3912:
! 3913: if ((accumulateur = malloc((*(((struct_matrice *)
! 3914: (*s_objet_argument_2).objet))).nombre_colonnes *
! 3915: sizeof(real8))) == NULL)
! 3916: {
! 3917: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3918: return;
! 3919: }
! 3920:
! 3921: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2)
! 3922: .objet))).nombre_lignes; i++)
! 3923: {
! 3924: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 3925: .objet))).nombre_colonnes; k++)
! 3926: {
! 3927: ((real8 *) accumulateur)[k] = (((real8 **) (*((struct_matrice *)
! 3928: (*s_objet_argument_2).objet)).tableau)[i][k] *
! 3929: ((real8 *) (*((struct_vecteur *)
! 3930: (*s_objet_argument_1).objet)).tableau)[k]);
! 3931: }
! 3932:
! 3933: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
! 3934: .tableau)[i] = sommation_vecteur_reel(accumulateur,
! 3935: &((*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 3936: .nombre_colonnes), &erreur_memoire);
! 3937:
! 3938: if (erreur_memoire == d_vrai)
! 3939: {
! 3940: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3941: return;
! 3942: }
! 3943: }
! 3944:
! 3945: free(accumulateur);
! 3946: }
! 3947:
! 3948: /*
! 3949: * Matrice de réels / Vecteur de complexes
! 3950: */
! 3951:
! 3952: else if (((*s_objet_argument_2).type == MRL) &&
! 3953: ((*s_objet_argument_1).type == VCX))
! 3954: {
! 3955: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 3956: == NULL)
! 3957: {
! 3958: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3959: return;
! 3960: }
! 3961:
! 3962: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 3963: (*(((struct_matrice *) (*s_objet_argument_2)
! 3964: .objet))).nombre_lignes;
! 3965:
! 3966: if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille !=
! 3967: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 3968: .nombre_colonnes)
! 3969: {
! 3970: liberation(s_etat_processus, s_objet_argument_1);
! 3971: liberation(s_etat_processus, s_objet_argument_2);
! 3972: liberation(s_etat_processus, s_objet_resultat);
! 3973:
! 3974: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 3975: return;
! 3976: }
! 3977:
! 3978: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 3979: malloc((*(((struct_matrice *) (*s_objet_argument_2)
! 3980: .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL)
! 3981: {
! 3982: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3983: return;
! 3984: }
! 3985:
! 3986: if ((accumulateur = malloc((*(((struct_matrice *)
! 3987: (*s_objet_argument_2).objet))).nombre_colonnes *
! 3988: sizeof(complex16))) == NULL)
! 3989: {
! 3990: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3991: return;
! 3992: }
! 3993:
! 3994: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2)
! 3995: .objet))).nombre_lignes; i++)
! 3996: {
! 3997: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 3998: .objet))).nombre_colonnes; k++)
! 3999: {
! 4000: f77multiplicationcr_(&(((struct_complexe16 *)
! 4001: (*((struct_vecteur *) (*s_objet_argument_1).objet))
! 4002: .tableau)[k]), &(((real8 **) (*((struct_matrice *)
! 4003: (*s_objet_argument_2).objet)).tableau)[i][k]),
! 4004: &(((complex16 *) accumulateur)[k]));
! 4005: }
! 4006:
! 4007: ((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat)
! 4008: .objet)).tableau)[i] = sommation_vecteur_complexe(
! 4009: accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2)
! 4010: .objet))).nombre_colonnes), &erreur_memoire);
! 4011:
! 4012: if (erreur_memoire == d_vrai)
! 4013: {
! 4014: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4015: return;
! 4016: }
! 4017: }
! 4018:
! 4019: free(accumulateur);
! 4020: }
! 4021:
! 4022: /*
! 4023: * Matrice de complexes / Vecteur d'entiers
! 4024: */
! 4025:
! 4026: else if (((*s_objet_argument_2).type == MCX) &&
! 4027: ((*s_objet_argument_1).type == VIN))
! 4028: {
! 4029: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 4030: == NULL)
! 4031: {
! 4032: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4033: return;
! 4034: }
! 4035:
! 4036: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 4037: (*(((struct_matrice *) (*s_objet_argument_2)
! 4038: .objet))).nombre_lignes;
! 4039:
! 4040: if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille !=
! 4041: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4042: .nombre_colonnes)
! 4043: {
! 4044: liberation(s_etat_processus, s_objet_argument_1);
! 4045: liberation(s_etat_processus, s_objet_argument_2);
! 4046: liberation(s_etat_processus, s_objet_resultat);
! 4047:
! 4048: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 4049: return;
! 4050: }
! 4051:
! 4052: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 4053: malloc((*(((struct_matrice *) (*s_objet_argument_2)
! 4054: .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL)
! 4055: {
! 4056: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4057: return;
! 4058: }
! 4059:
! 4060: if ((accumulateur = malloc((*(((struct_matrice *)
! 4061: (*s_objet_argument_2).objet))).nombre_colonnes *
! 4062: sizeof(complex16))) == NULL)
! 4063: {
! 4064: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4065: return;
! 4066: }
! 4067:
! 4068: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2)
! 4069: .objet))).nombre_lignes; i++)
! 4070: {
! 4071: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 4072: .objet))).nombre_colonnes; k++)
! 4073: {
! 4074: f77multiplicationci_(&(((struct_complexe16 **)
! 4075: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4076: .tableau)[i][k]), &(((integer8 *)
! 4077: (*((struct_vecteur *) (*s_objet_argument_1).objet))
! 4078: .tableau)[k]), &(((complex16 *) accumulateur)[k]));
! 4079: }
! 4080:
! 4081: ((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat)
! 4082: .objet)).tableau)[i] = sommation_vecteur_complexe(
! 4083: accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2)
! 4084: .objet))).nombre_colonnes), &erreur_memoire);
! 4085:
! 4086: if (erreur_memoire == d_vrai)
! 4087: {
! 4088: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4089: return;
! 4090: }
! 4091: }
! 4092:
! 4093: free(accumulateur);
! 4094: }
! 4095:
! 4096: /*
! 4097: * Matrice de complexes / Vecteur de réels
! 4098: */
! 4099:
! 4100: else if (((*s_objet_argument_2).type == MCX) &&
! 4101: ((*s_objet_argument_1).type == VRL))
! 4102: {
! 4103: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 4104: == NULL)
! 4105: {
! 4106: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4107: return;
! 4108: }
! 4109:
! 4110: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 4111: (*(((struct_matrice *) (*s_objet_argument_2)
! 4112: .objet))).nombre_lignes;
! 4113:
! 4114: if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille !=
! 4115: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4116: .nombre_colonnes)
! 4117: {
! 4118: liberation(s_etat_processus, s_objet_argument_1);
! 4119: liberation(s_etat_processus, s_objet_argument_2);
! 4120: liberation(s_etat_processus, s_objet_resultat);
! 4121:
! 4122: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 4123: return;
! 4124: }
! 4125:
! 4126: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 4127: malloc((*(((struct_matrice *) (*s_objet_argument_2)
! 4128: .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL)
! 4129: {
! 4130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4131: return;
! 4132: }
! 4133:
! 4134: if ((accumulateur = malloc((*(((struct_matrice *)
! 4135: (*s_objet_argument_2).objet))).nombre_colonnes *
! 4136: sizeof(complex16))) == NULL)
! 4137: {
! 4138: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4139: return;
! 4140: }
! 4141:
! 4142: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2)
! 4143: .objet))).nombre_lignes; i++)
! 4144: {
! 4145: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 4146: .objet))).nombre_colonnes; k++)
! 4147: {
! 4148: f77multiplicationcr_(&(((struct_complexe16 **)
! 4149: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4150: .tableau)[i][k]), &(((real8 *)
! 4151: (*((struct_vecteur *) (*s_objet_argument_1).objet))
! 4152: .tableau)[k]), &(((complex16 *) accumulateur)[k]));
! 4153: }
! 4154:
! 4155: ((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat)
! 4156: .objet)).tableau)[i] = sommation_vecteur_complexe(
! 4157: accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2)
! 4158: .objet))).nombre_colonnes), &erreur_memoire);
! 4159:
! 4160: if (erreur_memoire == d_vrai)
! 4161: {
! 4162: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4163: return;
! 4164: }
! 4165: }
! 4166:
! 4167: free(accumulateur);
! 4168: }
! 4169:
! 4170: /*
! 4171: * Matrice de complexes / Vecteur de complexes
! 4172: */
! 4173:
! 4174: else if (((*s_objet_argument_2).type == MCX) &&
! 4175: ((*s_objet_argument_1).type == VCX))
! 4176: {
! 4177: if ((s_objet_resultat = allocation(s_etat_processus, VCX))
! 4178: == NULL)
! 4179: {
! 4180: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4181: return;
! 4182: }
! 4183:
! 4184: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 4185: (*(((struct_matrice *) (*s_objet_argument_2)
! 4186: .objet))).nombre_lignes;
! 4187:
! 4188: if ((*((struct_vecteur *) (*s_objet_argument_1).objet)).taille !=
! 4189: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4190: .nombre_colonnes)
! 4191: {
! 4192: liberation(s_etat_processus, s_objet_argument_1);
! 4193: liberation(s_etat_processus, s_objet_argument_2);
! 4194: liberation(s_etat_processus, s_objet_resultat);
! 4195:
! 4196: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 4197: return;
! 4198: }
! 4199:
! 4200: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 4201: malloc((*(((struct_matrice *) (*s_objet_argument_2)
! 4202: .objet))).nombre_lignes * sizeof(struct_complexe16))) == NULL)
! 4203: {
! 4204: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4205: return;
! 4206: }
! 4207:
! 4208: if ((accumulateur = malloc((*(((struct_matrice *)
! 4209: (*s_objet_argument_2).objet))).nombre_colonnes *
! 4210: sizeof(complex16))) == NULL)
! 4211: {
! 4212: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4213: return;
! 4214: }
! 4215:
! 4216: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2)
! 4217: .objet))).nombre_lignes; i++)
! 4218: {
! 4219: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 4220: .objet))).nombre_colonnes; k++)
! 4221: {
! 4222: f77multiplicationcc_(&(((struct_complexe16 **)
! 4223: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4224: .tableau)[i][k]), &(((struct_complexe16 *)
! 4225: (*((struct_vecteur *) (*s_objet_argument_1).objet))
! 4226: .tableau)[k]), &(((complex16 *) accumulateur)[k]));
! 4227: }
! 4228:
! 4229: ((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat)
! 4230: .objet)).tableau)[i] = sommation_vecteur_complexe(
! 4231: accumulateur, &((*(((struct_matrice *) (*s_objet_argument_2)
! 4232: .objet))).nombre_colonnes), &erreur_memoire);
! 4233:
! 4234: if (erreur_memoire == d_vrai)
! 4235: {
! 4236: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4237: return;
! 4238: }
! 4239: }
! 4240:
! 4241: free(accumulateur);
! 4242: }
! 4243:
! 4244: /*
! 4245: --------------------------------------------------------------------------------
! 4246: Multiplication d'une matrice par une autre matrice
! 4247: --------------------------------------------------------------------------------
! 4248: */
! 4249: /*
! 4250: * Matrice d'entiers / Matrice d'entiers
! 4251: */
! 4252:
! 4253: else if (((*s_objet_argument_2).type == MIN) &&
! 4254: ((*s_objet_argument_1).type == MIN))
! 4255: {
! 4256: if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes !=
! 4257: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4258: .nombre_colonnes)
! 4259: {
! 4260: liberation(s_etat_processus, s_objet_argument_1);
! 4261: liberation(s_etat_processus, s_objet_argument_2);
! 4262:
! 4263: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 4264: return;
! 4265: }
! 4266:
! 4267: if ((s_objet_resultat = allocation(s_etat_processus, MIN))
! 4268: == NULL)
! 4269: {
! 4270: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4271: return;
! 4272: }
! 4273:
! 4274: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 4275: (*(((struct_matrice *) (*s_objet_argument_2)
! 4276: .objet))).nombre_lignes;
! 4277: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 4278: (*(((struct_matrice *) (*s_objet_argument_1)
! 4279: .objet))).nombre_colonnes;
! 4280:
! 4281: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 4282: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 4283: .objet))).nombre_lignes * sizeof(integer8 *))) == NULL)
! 4284: {
! 4285: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4286: return;
! 4287: }
! 4288:
! 4289: depassement = d_faux;
! 4290:
! 4291: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 4292: .objet))).nombre_lignes; i++)
! 4293: {
! 4294: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 4295: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 4296: .objet))).nombre_colonnes * sizeof(integer8))) == NULL)
! 4297: {
! 4298: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4299: return;
! 4300: }
! 4301:
! 4302: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 4303: .objet))).nombre_colonnes; j++)
! 4304: {
! 4305: ((integer8 **) (*((struct_matrice *)
! 4306: (*s_objet_resultat).objet)).tableau)[i][j] = 0;
! 4307:
! 4308: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 4309: .objet))).nombre_colonnes; k++)
! 4310: {
! 4311: if (depassement_multiplication(&(((integer8 **)
! 4312: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4313: .tableau)[i][k]), &(((integer8 **)
! 4314: (*((struct_matrice *) (*s_objet_argument_1).objet))
! 4315: .tableau)[k][j]), &tampon) == d_erreur)
! 4316: {
! 4317: depassement = d_vrai;
! 4318: }
! 4319:
! 4320: if (depassement_addition(&(((integer8 **)
! 4321: (*((struct_matrice *) (*s_objet_resultat).objet))
! 4322: .tableau)[i][j]), &tampon, &cumul) == d_erreur)
! 4323: {
! 4324: depassement = d_vrai;
! 4325: }
! 4326:
! 4327: ((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
! 4328: .objet)).tableau)[i][j] = cumul;
! 4329: }
! 4330: }
! 4331: }
! 4332:
! 4333: if (depassement == d_vrai)
! 4334: {
! 4335: (*s_objet_resultat).type = MRL;
! 4336: (*((struct_matrice *) (*s_objet_resultat).objet)).type = 'R';
! 4337:
! 4338: if ((accumulateur = malloc((*(((struct_matrice *)
! 4339: (*s_objet_argument_2).objet))).nombre_colonnes *
! 4340: sizeof(real8))) == NULL)
! 4341: {
! 4342: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4343: return;
! 4344: }
! 4345:
! 4346: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 4347: .objet))).nombre_lignes; i++)
! 4348: {
! 4349: free(((integer8 **) (*((struct_matrice *)
! 4350: (*s_objet_resultat).objet)).tableau)[i]);
! 4351:
! 4352: if (((*((struct_matrice *) (*s_objet_resultat).objet))
! 4353: .tableau[i] = malloc((*(((struct_matrice *)
! 4354: (*s_objet_resultat).objet))).nombre_colonnes *
! 4355: sizeof(real8))) == NULL)
! 4356: {
! 4357: (*s_etat_processus).erreur_systeme =
! 4358: d_es_allocation_memoire;
! 4359: return;
! 4360: }
! 4361:
! 4362: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 4363: .objet))).nombre_colonnes; j++)
! 4364: {
! 4365: ((real8 **) (*((struct_matrice *)
! 4366: (*s_objet_resultat).objet)).tableau)[i][j] = 0;
! 4367:
! 4368: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 4369: .objet))).nombre_colonnes; k++)
! 4370: {
! 4371: ((real8 *) accumulateur)[k] = ((real8)
! 4372: (((integer8 **) (*((struct_matrice *)
! 4373: (*s_objet_argument_2).objet)).tableau)[i][k]) *
! 4374: ((real8) ((integer8 **) (*((struct_matrice *)
! 4375: (*s_objet_argument_1).objet)).tableau)[k][j]));
! 4376: }
! 4377:
! 4378: ((real8 **) (*((struct_matrice *)
! 4379: (*s_objet_resultat).objet)).tableau)[i][j] =
! 4380: sommation_vecteur_reel(accumulateur,
! 4381: &((*(((struct_matrice *) (*s_objet_argument_2)
! 4382: .objet))).nombre_colonnes), &erreur_memoire);
! 4383:
! 4384: if (erreur_memoire == d_vrai)
! 4385: {
! 4386: (*s_etat_processus).erreur_systeme =
! 4387: d_es_allocation_memoire;
! 4388: return;
! 4389: }
! 4390: }
! 4391: }
! 4392:
! 4393: free(accumulateur);
! 4394: }
! 4395: }
! 4396:
! 4397: /*
! 4398: * Matrice d'entiers / Matrice de réels
! 4399: */
! 4400:
! 4401: else if ((((*s_objet_argument_2).type == MIN) &&
! 4402: ((*s_objet_argument_1).type == MRL)) ||
! 4403: (((*s_objet_argument_2).type == MRL) &&
! 4404: ((*s_objet_argument_1).type == MIN)))
! 4405: {
! 4406: if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes !=
! 4407: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4408: .nombre_colonnes)
! 4409: {
! 4410: liberation(s_etat_processus, s_objet_argument_1);
! 4411: liberation(s_etat_processus, s_objet_argument_2);
! 4412:
! 4413: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 4414: return;
! 4415: }
! 4416:
! 4417: if ((s_objet_resultat = allocation(s_etat_processus, MRL))
! 4418: == NULL)
! 4419: {
! 4420: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4421: return;
! 4422: }
! 4423:
! 4424: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 4425: (*(((struct_matrice *) (*s_objet_argument_2)
! 4426: .objet))).nombre_lignes;
! 4427: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 4428: (*(((struct_matrice *) (*s_objet_argument_1)
! 4429: .objet))).nombre_colonnes;
! 4430:
! 4431: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 4432: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 4433: .objet))).nombre_lignes * sizeof(real8 *))) == NULL)
! 4434: {
! 4435: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4436: return;
! 4437: }
! 4438:
! 4439: if ((accumulateur = malloc((*(((struct_matrice *)
! 4440: (*s_objet_argument_2).objet))).nombre_colonnes *
! 4441: sizeof(real8))) == NULL)
! 4442: {
! 4443: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4444: return;
! 4445: }
! 4446:
! 4447: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 4448: .objet))).nombre_lignes; i++)
! 4449: {
! 4450: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 4451: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 4452: .objet))).nombre_colonnes * sizeof(real8))) == NULL)
! 4453: {
! 4454: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4455: return;
! 4456: }
! 4457:
! 4458: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 4459: .objet))).nombre_colonnes; j++)
! 4460: {
! 4461: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 4462: .objet))).nombre_colonnes; k++)
! 4463: {
! 4464: if ((*s_objet_argument_1).type == MRL)
! 4465: {
! 4466: ((real8 *) accumulateur)[k] =
! 4467: (((integer8 **) (*((struct_matrice *)
! 4468: (*s_objet_argument_2).objet)).tableau)[i][k] *
! 4469: ((real8 **) (*((struct_matrice *)
! 4470: (*s_objet_argument_1).objet)).tableau)[k][j]);
! 4471: }
! 4472: else
! 4473: {
! 4474: ((real8 *) accumulateur)[k] =
! 4475: (((real8 **) (*((struct_matrice *)
! 4476: (*s_objet_argument_2).objet)).tableau)[i][k] *
! 4477: ((integer8 **) (*((struct_matrice *)
! 4478: (*s_objet_argument_1).objet)).tableau)[k][j]);
! 4479: }
! 4480: }
! 4481:
! 4482: ((real8 **) (*((struct_matrice *)
! 4483: (*s_objet_resultat).objet)).tableau)[i][j] =
! 4484: sommation_vecteur_reel(accumulateur,
! 4485: &((*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 4486: .nombre_colonnes), &erreur_memoire);
! 4487:
! 4488: if (erreur_memoire == d_vrai)
! 4489: {
! 4490: (*s_etat_processus).erreur_systeme =
! 4491: d_es_allocation_memoire;
! 4492: return;
! 4493: }
! 4494: }
! 4495: }
! 4496:
! 4497: free(accumulateur);
! 4498: }
! 4499:
! 4500: /*
! 4501: * Matrice d'entiers / Matrice de complexes
! 4502: */
! 4503:
! 4504: else if ((((*s_objet_argument_2).type == MIN) &&
! 4505: ((*s_objet_argument_1).type == MCX)) ||
! 4506: (((*s_objet_argument_2).type == MCX) &&
! 4507: ((*s_objet_argument_1).type == MIN)))
! 4508: {
! 4509: if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes !=
! 4510: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4511: .nombre_colonnes)
! 4512: {
! 4513: liberation(s_etat_processus, s_objet_argument_1);
! 4514: liberation(s_etat_processus, s_objet_argument_2);
! 4515:
! 4516: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 4517: return;
! 4518: }
! 4519:
! 4520: if ((s_objet_resultat = allocation(s_etat_processus, MCX))
! 4521: == NULL)
! 4522: {
! 4523: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4524: return;
! 4525: }
! 4526:
! 4527: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 4528: (*(((struct_matrice *) (*s_objet_argument_2)
! 4529: .objet))).nombre_lignes;
! 4530: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 4531: (*(((struct_matrice *) (*s_objet_argument_1)
! 4532: .objet))).nombre_colonnes;
! 4533:
! 4534: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 4535: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 4536: .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 4537: {
! 4538: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4539: return;
! 4540: }
! 4541:
! 4542: if ((accumulateur = malloc((*(((struct_matrice *)
! 4543: (*s_objet_argument_2).objet))).nombre_colonnes *
! 4544: sizeof(complex16))) == NULL)
! 4545: {
! 4546: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4547: return;
! 4548: }
! 4549:
! 4550: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 4551: .objet))).nombre_lignes; i++)
! 4552: {
! 4553: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 4554: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 4555: .objet))).nombre_colonnes * sizeof(struct_complexe16)))
! 4556: == NULL)
! 4557: {
! 4558: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4559: return;
! 4560: }
! 4561:
! 4562: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 4563: .objet))).nombre_colonnes; j++)
! 4564: {
! 4565: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 4566: .objet))).nombre_colonnes; k++)
! 4567: {
! 4568: if ((*s_objet_argument_1).type == MCX)
! 4569: {
! 4570: f77multiplicationci_(&(((struct_complexe16 **)
! 4571: (*((struct_matrice *)(*s_objet_argument_1)
! 4572: .objet)).tableau)[k][j]), &(((integer8 **)
! 4573: (*((struct_matrice *) (*s_objet_argument_2)
! 4574: .objet)).tableau)[i][k]), &(((complex16 *)
! 4575: accumulateur)[k]));
! 4576: }
! 4577: else
! 4578: {
! 4579: f77multiplicationci_(&(((struct_complexe16 **)
! 4580: (*((struct_matrice *)(*s_objet_argument_2)
! 4581: .objet)).tableau)[i][k]), &(((integer8 **)
! 4582: (*((struct_matrice *) (*s_objet_argument_1)
! 4583: .objet)).tableau)[k][j]), &(((complex16 *)
! 4584: accumulateur)[k]));
! 4585: }
! 4586: }
! 4587:
! 4588: ((struct_complexe16 **) (*((struct_matrice *)
! 4589: (*s_objet_resultat).objet)).tableau)[i][j] =
! 4590: sommation_vecteur_complexe(accumulateur,
! 4591: &((*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 4592: .nombre_colonnes), &erreur_memoire);
! 4593:
! 4594: if (erreur_memoire == d_vrai)
! 4595: {
! 4596: (*s_etat_processus).erreur_systeme =
! 4597: d_es_allocation_memoire;
! 4598: return;
! 4599: }
! 4600: }
! 4601: }
! 4602:
! 4603: free(accumulateur);
! 4604: }
! 4605:
! 4606: /*
! 4607: * Matrice de réels / Matrice de réels
! 4608: */
! 4609:
! 4610: else if (((*s_objet_argument_2).type == MRL) &&
! 4611: ((*s_objet_argument_1).type == MRL))
! 4612: {
! 4613: if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes !=
! 4614: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4615: .nombre_colonnes)
! 4616: {
! 4617: liberation(s_etat_processus, s_objet_argument_1);
! 4618: liberation(s_etat_processus, s_objet_argument_2);
! 4619:
! 4620: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 4621: return;
! 4622: }
! 4623:
! 4624: if ((s_objet_resultat = allocation(s_etat_processus, MRL))
! 4625: == NULL)
! 4626: {
! 4627: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4628: return;
! 4629: }
! 4630:
! 4631: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 4632: (*(((struct_matrice *) (*s_objet_argument_2)
! 4633: .objet))).nombre_lignes;
! 4634: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 4635: (*(((struct_matrice *) (*s_objet_argument_1)
! 4636: .objet))).nombre_colonnes;
! 4637:
! 4638: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 4639: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 4640: .objet))).nombre_lignes * sizeof(real8 *))) == NULL)
! 4641: {
! 4642: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4643: return;
! 4644: }
! 4645:
! 4646: if ((accumulateur = malloc((*(((struct_matrice *)
! 4647: (*s_objet_argument_2).objet))).nombre_colonnes *
! 4648: sizeof(real8))) == NULL)
! 4649: {
! 4650: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4651: return;
! 4652: }
! 4653:
! 4654: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 4655: .objet))).nombre_lignes; i++)
! 4656: {
! 4657: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 4658: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 4659: .objet))).nombre_colonnes * sizeof(real8))) == NULL)
! 4660: {
! 4661: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4662: return;
! 4663: }
! 4664:
! 4665: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 4666: .objet))).nombre_colonnes; j++)
! 4667: {
! 4668: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 4669: .objet))).nombre_colonnes; k++)
! 4670: {
! 4671: ((real8 *) accumulateur)[k] =
! 4672: (((real8 **) (*((struct_matrice *)
! 4673: (*s_objet_argument_2).objet)).tableau)[i][k] *
! 4674: ((real8 **) (*((struct_matrice *)
! 4675: (*s_objet_argument_1).objet)).tableau)[k][j]);
! 4676: }
! 4677:
! 4678: ((real8 **) (*((struct_matrice *)
! 4679: (*s_objet_resultat).objet)).tableau)[i][j] =
! 4680: sommation_vecteur_reel(accumulateur,
! 4681: &((*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 4682: .nombre_colonnes), &erreur_memoire);
! 4683:
! 4684: if (erreur_memoire == d_vrai)
! 4685: {
! 4686: (*s_etat_processus).erreur_systeme =
! 4687: d_es_allocation_memoire;
! 4688: return;
! 4689: }
! 4690: }
! 4691: }
! 4692:
! 4693: free(accumulateur);
! 4694: }
! 4695:
! 4696: /*
! 4697: * Matrice de réels / Matrice de complexes
! 4698: */
! 4699:
! 4700: else if ((((*s_objet_argument_2).type == MRL) &&
! 4701: ((*s_objet_argument_1).type == MCX)) ||
! 4702: (((*s_objet_argument_2).type == MCX) &&
! 4703: ((*s_objet_argument_1).type == MRL)))
! 4704: {
! 4705: if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes !=
! 4706: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4707: .nombre_colonnes)
! 4708: {
! 4709: liberation(s_etat_processus, s_objet_argument_1);
! 4710: liberation(s_etat_processus, s_objet_argument_2);
! 4711:
! 4712: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 4713: return;
! 4714: }
! 4715:
! 4716: if ((s_objet_resultat = allocation(s_etat_processus, MCX))
! 4717: == NULL)
! 4718: {
! 4719: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4720: return;
! 4721: }
! 4722:
! 4723: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 4724: (*(((struct_matrice *) (*s_objet_argument_2)
! 4725: .objet))).nombre_lignes;
! 4726: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 4727: (*(((struct_matrice *) (*s_objet_argument_1)
! 4728: .objet))).nombre_colonnes;
! 4729:
! 4730: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 4731: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 4732: .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 4733: {
! 4734: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4735: return;
! 4736: }
! 4737:
! 4738: if ((accumulateur = malloc((*(((struct_matrice *)
! 4739: (*s_objet_argument_2).objet))).nombre_colonnes *
! 4740: sizeof(complex16))) == NULL)
! 4741: {
! 4742: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4743: return;
! 4744: }
! 4745:
! 4746: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 4747: .objet))).nombre_lignes; i++)
! 4748: {
! 4749: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 4750: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 4751: .objet))).nombre_colonnes * sizeof(struct_complexe16)))
! 4752: == NULL)
! 4753: {
! 4754: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4755: return;
! 4756: }
! 4757:
! 4758: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 4759: .objet))).nombre_colonnes; j++)
! 4760: {
! 4761: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 4762: .objet))).nombre_colonnes; k++)
! 4763: {
! 4764: if ((*s_objet_argument_1).type == MCX)
! 4765: {
! 4766: f77multiplicationcr_(&(((struct_complexe16 **)
! 4767: (*((struct_matrice *)(*s_objet_argument_1)
! 4768: .objet)).tableau)[k][j]), &(((real8 **)
! 4769: (*((struct_matrice *) (*s_objet_argument_2)
! 4770: .objet)).tableau)[i][k]), &(((complex16 *)
! 4771: accumulateur)[k]));
! 4772: }
! 4773: else
! 4774: {
! 4775: f77multiplicationcr_(&(((struct_complexe16 **)
! 4776: (*((struct_matrice *)(*s_objet_argument_2)
! 4777: .objet)).tableau)[i][k]), &(((real8 **)
! 4778: (*((struct_matrice *) (*s_objet_argument_1)
! 4779: .objet)).tableau)[k][j]), &(((complex16 *)
! 4780: accumulateur)[k]));
! 4781: }
! 4782: }
! 4783:
! 4784: ((struct_complexe16 **) (*((struct_matrice *)
! 4785: (*s_objet_resultat).objet)).tableau)[i][j] =
! 4786: sommation_vecteur_complexe(accumulateur,
! 4787: &((*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 4788: .nombre_colonnes), &erreur_memoire);
! 4789:
! 4790: if (erreur_memoire == d_vrai)
! 4791: {
! 4792: (*s_etat_processus).erreur_systeme =
! 4793: d_es_allocation_memoire;
! 4794: return;
! 4795: }
! 4796: }
! 4797: }
! 4798:
! 4799: free(accumulateur);
! 4800: }
! 4801:
! 4802: /*
! 4803: * Matrice de complexes / Matrice de complexes
! 4804: */
! 4805:
! 4806: else if (((*s_objet_argument_2).type == MCX) &&
! 4807: ((*s_objet_argument_1).type == MCX))
! 4808: {
! 4809: if ((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes !=
! 4810: (*((struct_matrice *) (*s_objet_argument_2).objet))
! 4811: .nombre_colonnes)
! 4812: {
! 4813: liberation(s_etat_processus, s_objet_argument_1);
! 4814: liberation(s_etat_processus, s_objet_argument_2);
! 4815:
! 4816: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
! 4817: return;
! 4818: }
! 4819:
! 4820: if ((s_objet_resultat = allocation(s_etat_processus, MCX))
! 4821: == NULL)
! 4822: {
! 4823: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4824: return;
! 4825: }
! 4826:
! 4827: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 4828: (*(((struct_matrice *) (*s_objet_argument_2)
! 4829: .objet))).nombre_lignes;
! 4830: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 4831: (*(((struct_matrice *) (*s_objet_argument_1)
! 4832: .objet))).nombre_colonnes;
! 4833:
! 4834: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 4835: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 4836: .objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 4837: {
! 4838: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4839: return;
! 4840: }
! 4841:
! 4842: if ((accumulateur = malloc((*(((struct_matrice *)
! 4843: (*s_objet_argument_2).objet))).nombre_colonnes *
! 4844: sizeof(complex16))) == NULL)
! 4845: {
! 4846: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4847: return;
! 4848: }
! 4849:
! 4850: for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
! 4851: .objet))).nombre_lignes; i++)
! 4852: {
! 4853: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau[i] =
! 4854: malloc((*(((struct_matrice *) (*s_objet_resultat)
! 4855: .objet))).nombre_colonnes * sizeof(struct_complexe16)))
! 4856: == NULL)
! 4857: {
! 4858: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4859: return;
! 4860: }
! 4861:
! 4862: for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
! 4863: .objet))).nombre_colonnes; j++)
! 4864: {
! 4865: ((struct_complexe16 **) (*((struct_matrice *)
! 4866: (*s_objet_resultat).objet)).tableau)[i][j]
! 4867: .partie_reelle = 0;
! 4868: ((struct_complexe16 **) (*((struct_matrice *)
! 4869: (*s_objet_resultat).objet)).tableau)[i][j]
! 4870: .partie_imaginaire = 0;
! 4871:
! 4872: for(k = 0; k < (*(((struct_matrice *) (*s_objet_argument_2)
! 4873: .objet))).nombre_colonnes; k++)
! 4874: {
! 4875: f77multiplicationcc_(&(((struct_complexe16 **)
! 4876: (*((struct_matrice *)(*s_objet_argument_1)
! 4877: .objet)).tableau)[k][j]), &(((struct_complexe16 **)
! 4878: (*((struct_matrice *) (*s_objet_argument_2)
! 4879: .objet)).tableau)[i][k]), &(((complex16 *)
! 4880: accumulateur)[k]));
! 4881: }
! 4882:
! 4883: ((struct_complexe16 **) (*((struct_matrice *)
! 4884: (*s_objet_resultat).objet)).tableau)[i][j] =
! 4885: sommation_vecteur_complexe(accumulateur,
! 4886: &((*(((struct_matrice *) (*s_objet_argument_2).objet)))
! 4887: .nombre_colonnes), &erreur_memoire);
! 4888:
! 4889: if (erreur_memoire == d_vrai)
! 4890: {
! 4891: (*s_etat_processus).erreur_systeme =
! 4892: d_es_allocation_memoire;
! 4893: return;
! 4894: }
! 4895: }
! 4896: }
! 4897:
! 4898: free(accumulateur);
! 4899: }
! 4900:
! 4901: /*
! 4902: --------------------------------------------------------------------------------
! 4903: Multiplication mettant en oeuvre des binaires
! 4904: --------------------------------------------------------------------------------
! 4905: */
! 4906: /*
! 4907: * Binaire / Binaire
! 4908: */
! 4909:
! 4910: else if (((*s_objet_argument_1).type == BIN) &&
! 4911: ((*s_objet_argument_2).type == BIN))
! 4912: {
! 4913: if ((s_objet_resultat = allocation(s_etat_processus, BIN))
! 4914: == NULL)
! 4915: {
! 4916: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4917: return;
! 4918: }
! 4919:
! 4920: (*((logical8 *) (*s_objet_resultat).objet)) =
! 4921: (*((logical8 *) (*s_objet_argument_2).objet))
! 4922: * (*((logical8 *) (*s_objet_argument_1).objet));
! 4923: }
! 4924:
! 4925: /*
! 4926: * Binaire / Entier
! 4927: */
! 4928:
! 4929: else if ((((*s_objet_argument_1).type == BIN) &&
! 4930: ((*s_objet_argument_2).type == INT)) ||
! 4931: (((*s_objet_argument_1).type == INT) &&
! 4932: ((*s_objet_argument_2).type == BIN)))
! 4933: {
! 4934: if ((s_objet_resultat = allocation(s_etat_processus, BIN))
! 4935: == NULL)
! 4936: {
! 4937: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4938: return;
! 4939: }
! 4940:
! 4941: if ((*s_objet_argument_1).type == BIN)
! 4942: {
! 4943: (*((logical8 *) (*s_objet_resultat).objet)) =
! 4944: (*((integer8 *) (*s_objet_argument_2).objet))
! 4945: * (*((logical8 *) (*s_objet_argument_1).objet));
! 4946: }
! 4947: else
! 4948: {
! 4949: (*((logical8 *) (*s_objet_resultat).objet)) =
! 4950: (*((logical8 *) (*s_objet_argument_2).objet))
! 4951: * (*((integer8 *) (*s_objet_argument_1).objet));
! 4952: }
! 4953: }
! 4954:
! 4955: /*
! 4956: --------------------------------------------------------------------------------
! 4957: Multiplication mettant en oeuvre un nom ou une expression algébrique
! 4958: --------------------------------------------------------------------------------
! 4959: */
! 4960: /*
! 4961: * Nom ou valeur numérique / Nom ou valeur numérique
! 4962: */
! 4963:
! 4964: else if ((((*s_objet_argument_1).type == NOM) &&
! 4965: (((*s_objet_argument_2).type == NOM) ||
! 4966: ((*s_objet_argument_2).type == INT) ||
! 4967: ((*s_objet_argument_2).type == REL) ||
! 4968: ((*s_objet_argument_2).type == CPL))) ||
! 4969: (((*s_objet_argument_2).type == NOM) &&
! 4970: (((*s_objet_argument_1).type == INT) ||
! 4971: ((*s_objet_argument_1).type == REL) ||
! 4972: ((*s_objet_argument_1).type == CPL))))
! 4973: {
! 4974: drapeau = d_vrai;
! 4975:
! 4976: if ((*s_objet_argument_1).type == NOM)
! 4977: {
! 4978: if ((*s_objet_argument_2).type == INT)
! 4979: {
! 4980: if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0)
! 4981: {
! 4982: drapeau = d_faux;
! 4983:
! 4984: if ((s_objet_resultat = allocation(s_etat_processus,
! 4985: INT)) == NULL)
! 4986: {
! 4987: (*s_etat_processus).erreur_systeme =
! 4988: d_es_allocation_memoire;
! 4989: return;
! 4990: }
! 4991:
! 4992: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
! 4993: }
! 4994: else if ((*((integer8 *) (*s_objet_argument_2).objet)) == 1)
! 4995: {
! 4996: drapeau = d_faux;
! 4997:
! 4998: s_objet_resultat = s_objet_argument_1;
! 4999: s_objet_argument_1 = NULL;
! 5000: }
! 5001: }
! 5002: else if ((*s_objet_argument_2).type == REL)
! 5003: {
! 5004: if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0)
! 5005: {
! 5006: drapeau = d_faux;
! 5007:
! 5008: if ((s_objet_resultat = allocation(s_etat_processus,
! 5009: REL)) == NULL)
! 5010: {
! 5011: (*s_etat_processus).erreur_systeme =
! 5012: d_es_allocation_memoire;
! 5013: return;
! 5014: }
! 5015:
! 5016: (*((real8 *) (*s_objet_resultat).objet)) = 0;
! 5017: }
! 5018: else if ((*((real8 *) (*s_objet_argument_2).objet)) == 1)
! 5019: {
! 5020: drapeau = d_faux;
! 5021:
! 5022: s_objet_resultat = s_objet_argument_1;
! 5023: s_objet_argument_1 = NULL;
! 5024: }
! 5025: }
! 5026: else if ((*s_objet_argument_2).type == CPL)
! 5027: {
! 5028: if (((*((complex16 *) (*s_objet_argument_2).objet))
! 5029: .partie_reelle == 0) && ((*((complex16 *)
! 5030: (*s_objet_argument_2).objet)).partie_imaginaire == 0))
! 5031: {
! 5032: drapeau = d_faux;
! 5033:
! 5034: if ((s_objet_resultat = allocation(s_etat_processus,
! 5035: CPL)) == NULL)
! 5036: {
! 5037: (*s_etat_processus).erreur_systeme =
! 5038: d_es_allocation_memoire;
! 5039: return;
! 5040: }
! 5041:
! 5042: (*((complex16 *) (*s_objet_resultat).objet))
! 5043: .partie_reelle = 0;
! 5044: (*((complex16 *) (*s_objet_resultat).objet))
! 5045: .partie_imaginaire = 0;
! 5046: }
! 5047: else if (((*((complex16 *) (*s_objet_argument_2).objet))
! 5048: .partie_reelle == 1) && ((*((complex16 *)
! 5049: (*s_objet_argument_2).objet)).partie_imaginaire == 0))
! 5050: {
! 5051: drapeau = d_faux;
! 5052:
! 5053: s_objet_resultat = s_objet_argument_1;
! 5054: s_objet_argument_1 = NULL;
! 5055: }
! 5056: }
! 5057: }
! 5058: else if ((*s_objet_argument_2).type == NOM)
! 5059: {
! 5060: if ((*s_objet_argument_1).type == INT)
! 5061: {
! 5062: if ((*((integer8 *) (*s_objet_argument_1).objet)) == 0)
! 5063: {
! 5064: drapeau = d_faux;
! 5065:
! 5066: if ((s_objet_resultat = allocation(s_etat_processus,
! 5067: INT)) == NULL)
! 5068: {
! 5069: (*s_etat_processus).erreur_systeme =
! 5070: d_es_allocation_memoire;
! 5071: return;
! 5072: }
! 5073:
! 5074: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
! 5075: }
! 5076: else if ((*((integer8 *) (*s_objet_argument_1).objet)) == 1)
! 5077: {
! 5078: drapeau = d_faux;
! 5079:
! 5080: s_objet_resultat = s_objet_argument_2;
! 5081: s_objet_argument_2 = NULL;
! 5082: }
! 5083: }
! 5084: else if ((*s_objet_argument_1).type == REL)
! 5085: {
! 5086: if ((*((integer8 *) (*s_objet_argument_1).objet)) == 0)
! 5087: {
! 5088: drapeau = d_faux;
! 5089:
! 5090: if ((s_objet_resultat = allocation(s_etat_processus,
! 5091: REL)) == NULL)
! 5092: {
! 5093: (*s_etat_processus).erreur_systeme =
! 5094: d_es_allocation_memoire;
! 5095: return;
! 5096: }
! 5097:
! 5098: (*((real8 *) (*s_objet_resultat).objet)) = 0;
! 5099: }
! 5100: else if ((*((real8 *) (*s_objet_argument_1).objet)) == 1)
! 5101: {
! 5102: drapeau = d_faux;
! 5103:
! 5104: s_objet_resultat = s_objet_argument_2;
! 5105: s_objet_argument_2 = NULL;
! 5106: }
! 5107: }
! 5108: else if ((*s_objet_argument_1).type == CPL)
! 5109: {
! 5110: if (((*((complex16 *) (*s_objet_argument_1).objet))
! 5111: .partie_reelle == 0) && ((*((complex16 *)
! 5112: (*s_objet_argument_1).objet)).partie_imaginaire == 0))
! 5113: {
! 5114: drapeau = d_faux;
! 5115:
! 5116: if ((s_objet_resultat = allocation(s_etat_processus,
! 5117: CPL)) == NULL)
! 5118: {
! 5119: (*s_etat_processus).erreur_systeme =
! 5120: d_es_allocation_memoire;
! 5121: return;
! 5122: }
! 5123:
! 5124: (*((complex16 *) (*s_objet_resultat).objet))
! 5125: .partie_reelle = 0;
! 5126: (*((complex16 *) (*s_objet_resultat).objet))
! 5127: .partie_imaginaire = 0;
! 5128: }
! 5129: else if (((*((complex16 *) (*s_objet_argument_1).objet))
! 5130: .partie_reelle == 1) && ((*((complex16 *)
! 5131: (*s_objet_argument_1).objet)).partie_imaginaire == 0))
! 5132: {
! 5133: drapeau = d_faux;
! 5134:
! 5135: s_objet_resultat = s_objet_argument_2;
! 5136: s_objet_argument_2 = NULL;
! 5137: }
! 5138: }
! 5139: }
! 5140:
! 5141: if (drapeau == d_vrai)
! 5142: {
! 5143: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
! 5144: == NULL)
! 5145: {
! 5146: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5147: return;
! 5148: }
! 5149:
! 5150: if (((*s_objet_resultat).objet =
! 5151: allocation_maillon(s_etat_processus)) == NULL)
! 5152: {
! 5153: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5154: return;
! 5155: }
! 5156:
! 5157: l_element_courant = (*s_objet_resultat).objet;
! 5158:
! 5159: if (((*l_element_courant).donnee = allocation(s_etat_processus,
! 5160: FCT)) == NULL)
! 5161: {
! 5162: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5163: return;
! 5164: }
! 5165:
! 5166: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5167: .nombre_arguments = 0;
! 5168: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5169: .fonction = instruction_vers_niveau_superieur;
! 5170:
! 5171: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5172: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 5173: {
! 5174: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5175: return;
! 5176: }
! 5177:
! 5178: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5179: .nom_fonction, "<<");
! 5180:
! 5181: if (((*l_element_courant).suivant =
! 5182: allocation_maillon(s_etat_processus)) == NULL)
! 5183: {
! 5184: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5185: return;
! 5186: }
! 5187:
! 5188: l_element_courant = (*l_element_courant).suivant;
! 5189: (*l_element_courant).donnee = s_objet_argument_2;
! 5190:
! 5191: if (((*l_element_courant).suivant =
! 5192: allocation_maillon(s_etat_processus)) == NULL)
! 5193: {
! 5194: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5195: return;
! 5196: }
! 5197:
! 5198: l_element_courant = (*l_element_courant).suivant;
! 5199: (*l_element_courant).donnee = s_objet_argument_1;
! 5200:
! 5201: if (((*l_element_courant).suivant =
! 5202: allocation_maillon(s_etat_processus)) == NULL)
! 5203: {
! 5204: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5205: return;
! 5206: }
! 5207:
! 5208: l_element_courant = (*l_element_courant).suivant;
! 5209:
! 5210: if (((*l_element_courant).donnee = allocation(s_etat_processus,
! 5211: FCT)) == NULL)
! 5212: {
! 5213: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5214: return;
! 5215: }
! 5216:
! 5217: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5218: .nombre_arguments = 0;
! 5219: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5220: .fonction = instruction_multiplication;
! 5221:
! 5222: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5223: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL)
! 5224: {
! 5225: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5226: return;
! 5227: }
! 5228:
! 5229: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5230: .nom_fonction, "*");
! 5231:
! 5232: if (((*l_element_courant).suivant =
! 5233: allocation_maillon(s_etat_processus)) == NULL)
! 5234: {
! 5235: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5236: return;
! 5237: }
! 5238:
! 5239: l_element_courant = (*l_element_courant).suivant;
! 5240:
! 5241: if (((*l_element_courant).donnee =
! 5242: allocation(s_etat_processus, FCT)) == NULL)
! 5243: {
! 5244: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5245: return;
! 5246: }
! 5247:
! 5248: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5249: .nombre_arguments = 0;
! 5250: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5251: .fonction = instruction_vers_niveau_inferieur;
! 5252:
! 5253: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5254: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 5255: {
! 5256: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5257: return;
! 5258: }
! 5259:
! 5260: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5261: .nom_fonction, ">>");
! 5262:
! 5263: (*l_element_courant).suivant = NULL;
! 5264:
! 5265: s_objet_argument_1 = NULL;
! 5266: s_objet_argument_2 = NULL;
! 5267: }
! 5268: }
! 5269:
! 5270: /*
! 5271: * Nom ou valeur numérique / Expression
! 5272: */
! 5273:
! 5274: else if ((((*s_objet_argument_1).type == ALG) ||
! 5275: ((*s_objet_argument_1).type == RPN)) &&
! 5276: (((*s_objet_argument_2).type == NOM) ||
! 5277: ((*s_objet_argument_2).type == INT) ||
! 5278: ((*s_objet_argument_2).type == REL) ||
! 5279: ((*s_objet_argument_2).type == CPL)))
! 5280: {
! 5281: drapeau = d_vrai;
! 5282:
! 5283: nombre_elements = 0;
! 5284: l_element_courant = (struct_liste_chainee *)
! 5285: (*s_objet_argument_1).objet;
! 5286:
! 5287: while(l_element_courant != NULL)
! 5288: {
! 5289: nombre_elements++;
! 5290: l_element_courant = (*l_element_courant).suivant;
! 5291: }
! 5292:
! 5293: if (nombre_elements == 2)
! 5294: {
! 5295: liberation(s_etat_processus, s_objet_argument_1);
! 5296: liberation(s_etat_processus, s_objet_argument_2);
! 5297:
! 5298: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 5299: return;
! 5300: }
! 5301:
! 5302: if ((*s_objet_argument_2).type == INT)
! 5303: {
! 5304: if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0)
! 5305: {
! 5306: drapeau = d_faux;
! 5307:
! 5308: if ((s_objet_resultat = allocation(s_etat_processus, INT))
! 5309: == NULL)
! 5310: {
! 5311: (*s_etat_processus).erreur_systeme =
! 5312: d_es_allocation_memoire;
! 5313: return;
! 5314: }
! 5315:
! 5316: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
! 5317: }
! 5318: else if ((*((integer8 *) (*s_objet_argument_2).objet)) == 1)
! 5319: {
! 5320: drapeau = d_faux;
! 5321:
! 5322: s_objet_resultat = s_objet_argument_1;
! 5323: s_objet_argument_1 = NULL;
! 5324: }
! 5325: }
! 5326: else if ((*s_objet_argument_2).type == REL)
! 5327: {
! 5328: if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0)
! 5329: {
! 5330: drapeau = d_faux;
! 5331:
! 5332: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 5333: == NULL)
! 5334: {
! 5335: (*s_etat_processus).erreur_systeme =
! 5336: d_es_allocation_memoire;
! 5337: return;
! 5338: }
! 5339:
! 5340: (*((real8 *) (*s_objet_resultat).objet)) = 0;
! 5341: }
! 5342: else if ((*((real8 *) (*s_objet_argument_2).objet)) == 1)
! 5343: {
! 5344: drapeau = d_faux;
! 5345:
! 5346: s_objet_resultat = s_objet_argument_1;
! 5347: s_objet_argument_1 = NULL;
! 5348: }
! 5349: }
! 5350: else if ((*s_objet_argument_2).type == CPL)
! 5351: {
! 5352: if (((*((complex16 *) (*s_objet_argument_2).objet))
! 5353: .partie_reelle == 0) && ((*((complex16 *)
! 5354: (*s_objet_argument_2).objet)).partie_imaginaire == 0))
! 5355: {
! 5356: drapeau = d_faux;
! 5357:
! 5358: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 5359: == NULL)
! 5360: {
! 5361: (*s_etat_processus).erreur_systeme =
! 5362: d_es_allocation_memoire;
! 5363: return;
! 5364: }
! 5365:
! 5366: (*((complex16 *) (*s_objet_resultat).objet))
! 5367: .partie_reelle = 0;
! 5368: (*((complex16 *) (*s_objet_resultat).objet))
! 5369: .partie_imaginaire = 0;
! 5370: }
! 5371: else if (((*((complex16 *) (*s_objet_argument_2).objet))
! 5372: .partie_reelle == 1) && ((*((complex16 *)
! 5373: (*s_objet_argument_2).objet)).partie_imaginaire == 0))
! 5374: {
! 5375: drapeau = d_faux;
! 5376:
! 5377: s_objet_resultat = s_objet_argument_1;
! 5378: s_objet_argument_1 = NULL;
! 5379: }
! 5380: }
! 5381:
! 5382: if (drapeau == d_vrai)
! 5383: {
! 5384: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 5385: s_objet_argument_1, 'N')) == NULL)
! 5386: {
! 5387: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5388: return;
! 5389: }
! 5390:
! 5391: l_element_courant = (struct_liste_chainee *)
! 5392: (*s_objet_resultat).objet;
! 5393: l_element_precedent = l_element_courant;
! 5394: l_element_courant = (*l_element_courant).suivant;
! 5395:
! 5396: if (((*l_element_precedent).suivant =
! 5397: allocation_maillon(s_etat_processus)) == NULL)
! 5398: {
! 5399: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5400: return;
! 5401: }
! 5402:
! 5403: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
! 5404: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 5405:
! 5406: while((*l_element_courant).suivant != NULL)
! 5407: {
! 5408: l_element_precedent = l_element_courant;
! 5409: l_element_courant = (*l_element_courant).suivant;
! 5410: }
! 5411:
! 5412: if (((*l_element_precedent).suivant =
! 5413: allocation_maillon(s_etat_processus)) == NULL)
! 5414: {
! 5415: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5416: return;
! 5417: }
! 5418:
! 5419: if (((*(*l_element_precedent).suivant).donnee =
! 5420: allocation(s_etat_processus, FCT)) == NULL)
! 5421: {
! 5422: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5423: return;
! 5424: }
! 5425:
! 5426: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 5427: .donnee).objet)).nombre_arguments = 0;
! 5428: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 5429: .donnee).objet)).fonction = instruction_multiplication;
! 5430:
! 5431: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 5432: .suivant).donnee).objet)).nom_fonction =
! 5433: malloc(2 * sizeof(unsigned char))) == NULL)
! 5434: {
! 5435: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5436: return;
! 5437: }
! 5438:
! 5439: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 5440: .suivant).donnee).objet)).nom_fonction, "*");
! 5441:
! 5442: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 5443:
! 5444: s_objet_argument_2 = NULL;
! 5445: }
! 5446: }
! 5447:
! 5448: /*
! 5449: * Expression / Nom ou valeur numérique
! 5450: */
! 5451:
! 5452: else if ((((*s_objet_argument_1).type == NOM) ||
! 5453: ((*s_objet_argument_1).type == INT) ||
! 5454: ((*s_objet_argument_1).type == REL) ||
! 5455: ((*s_objet_argument_1).type == CPL)) &&
! 5456: (((*s_objet_argument_2).type == ALG)||
! 5457: ((*s_objet_argument_2).type == RPN)))
! 5458: {
! 5459: drapeau = d_vrai;
! 5460:
! 5461: nombre_elements = 0;
! 5462: l_element_courant = (struct_liste_chainee *)
! 5463: (*s_objet_argument_2).objet;
! 5464:
! 5465: while(l_element_courant != NULL)
! 5466: {
! 5467: nombre_elements++;
! 5468: l_element_courant = (*l_element_courant).suivant;
! 5469: }
! 5470:
! 5471: if (nombre_elements == 2)
! 5472: {
! 5473: liberation(s_etat_processus, s_objet_argument_1);
! 5474: liberation(s_etat_processus, s_objet_argument_2);
! 5475:
! 5476: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 5477: return;
! 5478: }
! 5479:
! 5480: if ((*s_objet_argument_1).type == INT)
! 5481: {
! 5482: if ((*((integer8 *) (*s_objet_argument_1).objet)) == 0)
! 5483: {
! 5484: drapeau = d_faux;
! 5485:
! 5486: if ((s_objet_resultat = allocation(s_etat_processus, INT))
! 5487: == NULL)
! 5488: {
! 5489: (*s_etat_processus).erreur_systeme =
! 5490: d_es_allocation_memoire;
! 5491: return;
! 5492: }
! 5493:
! 5494: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
! 5495: }
! 5496: else if ((*((integer8 *) (*s_objet_argument_1).objet)) == 1)
! 5497: {
! 5498: drapeau = d_faux;
! 5499:
! 5500: s_objet_resultat = s_objet_argument_2;
! 5501: s_objet_argument_2 = NULL;
! 5502: }
! 5503: }
! 5504: else if ((*s_objet_argument_1).type == REL)
! 5505: {
! 5506: if ((*((integer8 *) (*s_objet_argument_1).objet)) == 0)
! 5507: {
! 5508: drapeau = d_faux;
! 5509:
! 5510: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 5511: == NULL)
! 5512: {
! 5513: (*s_etat_processus).erreur_systeme =
! 5514: d_es_allocation_memoire;
! 5515: return;
! 5516: }
! 5517:
! 5518: (*((real8 *) (*s_objet_resultat).objet)) = 0;
! 5519: }
! 5520: else if ((*((real8 *) (*s_objet_argument_1).objet)) == 1)
! 5521: {
! 5522: drapeau = d_faux;
! 5523:
! 5524: s_objet_resultat = s_objet_argument_2;
! 5525: s_objet_argument_2 = NULL;
! 5526: }
! 5527: }
! 5528: else if ((*s_objet_argument_1).type == CPL)
! 5529: {
! 5530: if (((*((complex16 *) (*s_objet_argument_1).objet))
! 5531: .partie_reelle == 0) && ((*((complex16 *)
! 5532: (*s_objet_argument_1).objet)).partie_imaginaire == 0))
! 5533: {
! 5534: drapeau = d_faux;
! 5535:
! 5536: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 5537: == NULL)
! 5538: {
! 5539: (*s_etat_processus).erreur_systeme =
! 5540: d_es_allocation_memoire;
! 5541: return;
! 5542: }
! 5543:
! 5544: (*((complex16 *) (*s_objet_resultat).objet))
! 5545: .partie_reelle = 0;
! 5546: (*((complex16 *) (*s_objet_resultat).objet))
! 5547: .partie_imaginaire = 0;
! 5548: }
! 5549: else if (((*((complex16 *) (*s_objet_argument_1).objet))
! 5550: .partie_reelle == 1) && ((*((complex16 *)
! 5551: (*s_objet_argument_1).objet)).partie_imaginaire == 0))
! 5552: {
! 5553: drapeau = d_faux;
! 5554:
! 5555: s_objet_resultat = s_objet_argument_2;
! 5556: s_objet_argument_2 = NULL;
! 5557: }
! 5558: }
! 5559:
! 5560: if (drapeau == d_vrai)
! 5561: {
! 5562: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 5563: s_objet_argument_2, 'N')) == NULL)
! 5564: {
! 5565: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5566: return;
! 5567: }
! 5568:
! 5569: l_element_courant = (struct_liste_chainee *)
! 5570: (*s_objet_resultat).objet;
! 5571: l_element_precedent = l_element_courant;
! 5572:
! 5573: while((*l_element_courant).suivant != NULL)
! 5574: {
! 5575: l_element_precedent = l_element_courant;
! 5576: l_element_courant = (*l_element_courant).suivant;
! 5577: }
! 5578:
! 5579: if (((*l_element_precedent).suivant =
! 5580: allocation_maillon(s_etat_processus)) == NULL)
! 5581: {
! 5582: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5583: return;
! 5584: }
! 5585:
! 5586: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
! 5587: l_element_precedent = (*l_element_precedent).suivant;
! 5588:
! 5589: if (((*l_element_precedent).suivant =
! 5590: allocation_maillon(s_etat_processus)) == NULL)
! 5591: {
! 5592: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5593: return;
! 5594: }
! 5595:
! 5596: if (((*(*l_element_precedent).suivant).donnee =
! 5597: allocation(s_etat_processus, FCT)) == NULL)
! 5598: {
! 5599: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5600: return;
! 5601: }
! 5602:
! 5603: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 5604: .donnee).objet)).nombre_arguments = 0;
! 5605: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 5606: .donnee).objet)).fonction = instruction_multiplication;
! 5607:
! 5608: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 5609: .suivant).donnee).objet)).nom_fonction =
! 5610: malloc(2 * sizeof(unsigned char))) == NULL)
! 5611: {
! 5612: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5613: return;
! 5614: }
! 5615:
! 5616: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 5617: .suivant).donnee).objet)).nom_fonction, "*");
! 5618:
! 5619: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 5620:
! 5621: s_objet_argument_1 = NULL;
! 5622: }
! 5623: }
! 5624:
! 5625: /*
! 5626: * Expression / Expression
! 5627: */
! 5628:
! 5629: else if ((((*s_objet_argument_1).type == ALG) &&
! 5630: ((*s_objet_argument_2).type == ALG)) ||
! 5631: (((*s_objet_argument_1).type == RPN) &&
! 5632: ((*s_objet_argument_2).type == RPN)))
! 5633: {
! 5634: nombre_elements = 0;
! 5635: l_element_courant = (struct_liste_chainee *)
! 5636: (*s_objet_argument_1).objet;
! 5637:
! 5638: while(l_element_courant != NULL)
! 5639: {
! 5640: nombre_elements++;
! 5641: l_element_courant = (*l_element_courant).suivant;
! 5642: }
! 5643:
! 5644: if (nombre_elements == 2)
! 5645: {
! 5646: liberation(s_etat_processus, s_objet_argument_1);
! 5647: liberation(s_etat_processus, s_objet_argument_2);
! 5648:
! 5649: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 5650: return;
! 5651: }
! 5652:
! 5653: nombre_elements = 0;
! 5654: l_element_courant = (struct_liste_chainee *)
! 5655: (*s_objet_argument_2).objet;
! 5656:
! 5657: while(l_element_courant != NULL)
! 5658: {
! 5659: nombre_elements++;
! 5660: l_element_courant = (*l_element_courant).suivant;
! 5661: }
! 5662:
! 5663: if (nombre_elements == 2)
! 5664: {
! 5665: liberation(s_etat_processus, s_objet_argument_1);
! 5666: liberation(s_etat_processus, s_objet_argument_2);
! 5667:
! 5668: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 5669: return;
! 5670: }
! 5671:
! 5672: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
! 5673: s_objet_argument_1, 'N')) == NULL)
! 5674: {
! 5675: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5676: return;
! 5677: }
! 5678:
! 5679: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
! 5680: s_objet_argument_2, 'N')) == NULL)
! 5681: {
! 5682: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5683: return;
! 5684: }
! 5685:
! 5686: l_element_courant = (struct_liste_chainee *)
! 5687: (*s_copie_argument_1).objet;
! 5688: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
! 5689: (*s_copie_argument_1).objet)).suivant;
! 5690:
! 5691: liberation(s_etat_processus, (*l_element_courant).donnee);
! 5692: free(l_element_courant);
! 5693:
! 5694: l_element_courant = (struct_liste_chainee *)
! 5695: (*s_copie_argument_2).objet;
! 5696: l_element_precedent = l_element_courant;
! 5697: s_objet_resultat = s_copie_argument_2;
! 5698:
! 5699: while((*l_element_courant).suivant != NULL)
! 5700: {
! 5701: l_element_precedent = l_element_courant;
! 5702: l_element_courant = (*l_element_courant).suivant;
! 5703: }
! 5704:
! 5705: liberation(s_etat_processus, (*l_element_courant).donnee);
! 5706: free(l_element_courant);
! 5707:
! 5708: (*l_element_precedent).suivant = (struct_liste_chainee *)
! 5709: (*s_copie_argument_1).objet;
! 5710: free(s_copie_argument_1);
! 5711:
! 5712: l_element_courant = (*l_element_precedent).suivant;
! 5713: while((*l_element_courant).suivant != NULL)
! 5714: {
! 5715: l_element_precedent = l_element_courant;
! 5716: l_element_courant = (*l_element_courant).suivant;
! 5717: }
! 5718:
! 5719: if (((*l_element_precedent).suivant =
! 5720: allocation_maillon(s_etat_processus)) == NULL)
! 5721: {
! 5722: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5723: return;
! 5724: }
! 5725:
! 5726: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 5727: l_element_courant = (*l_element_precedent).suivant;
! 5728:
! 5729: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 5730: == NULL)
! 5731: {
! 5732: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5733: return;
! 5734: }
! 5735:
! 5736: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5737: .nombre_arguments = 0;
! 5738: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5739: .fonction = instruction_multiplication;
! 5740:
! 5741: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5742: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL)
! 5743: {
! 5744: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5745: return;
! 5746: }
! 5747:
! 5748: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5749: .nom_fonction, "*");
! 5750: }
! 5751:
! 5752: /*
! 5753: --------------------------------------------------------------------------------
! 5754: Multiplication impossible
! 5755: --------------------------------------------------------------------------------
! 5756: */
! 5757:
! 5758: else
! 5759: {
! 5760: liberation(s_etat_processus, s_objet_argument_1);
! 5761: liberation(s_etat_processus, s_objet_argument_2);
! 5762:
! 5763: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 5764: return;
! 5765: }
! 5766:
! 5767: liberation(s_etat_processus, s_objet_argument_1);
! 5768: liberation(s_etat_processus, s_objet_argument_2);
! 5769:
! 5770: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 5771: s_objet_resultat) == d_erreur)
! 5772: {
! 5773: return;
! 5774: }
! 5775:
! 5776: return;
! 5777: }
! 5778:
! 5779:
! 5780: /*
! 5781: ================================================================================
! 5782: Fonction 'mant'
! 5783: ================================================================================
! 5784: Entrées :
! 5785: --------------------------------------------------------------------------------
! 5786: Sorties :
! 5787: --------------------------------------------------------------------------------
! 5788: Effets de bord : néant
! 5789: ================================================================================
! 5790: */
! 5791:
! 5792: void
! 5793: instruction_mant(struct_processus *s_etat_processus)
! 5794: {
! 5795: real8 base_reelle;
! 5796: real8 reduction_reelle;
! 5797:
! 5798: integer4 erreur;
! 5799:
! 5800: integer8 base_entiere;
! 5801: integer8 exposant;
! 5802: integer8 reduction_entiere;
! 5803:
! 5804: struct_liste_chainee *l_element_courant;
! 5805: struct_liste_chainee *l_element_precedent;
! 5806:
! 5807: struct_objet *s_copie_argument;
! 5808: struct_objet *s_objet_argument;
! 5809: struct_objet *s_objet_resultat;
! 5810:
! 5811: (*s_etat_processus).erreur_execution = d_ex;
! 5812:
! 5813: if ((*s_etat_processus).affichage_arguments == 'Y')
! 5814: {
! 5815: printf("\n MANT ");
! 5816:
! 5817: if ((*s_etat_processus).langue == 'F')
! 5818: {
! 5819: printf("(mantisse)\n\n");
! 5820: }
! 5821: else
! 5822: {
! 5823: printf("(mantissa)\n\n");
! 5824: }
! 5825:
! 5826: printf(" 1: %s, %s\n", d_INT, d_REL);
! 5827: printf("-> 1: %s\n\n", d_REL);
! 5828:
! 5829: printf(" 1: %s, %s\n", d_NOM, d_ALG);
! 5830: printf("-> 1: %s\n\n", d_ALG);
! 5831:
! 5832: printf(" 1: %s\n", d_RPN);
! 5833: printf("-> 1: %s\n", d_RPN);
! 5834:
! 5835: return;
! 5836: }
! 5837: else if ((*s_etat_processus).test_instruction == 'Y')
! 5838: {
! 5839: (*s_etat_processus).nombre_arguments = 1;
! 5840: return;
! 5841: }
! 5842:
! 5843: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 5844: {
! 5845: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 5846: {
! 5847: return;
! 5848: }
! 5849: }
! 5850:
! 5851: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 5852: &s_objet_argument) == d_erreur)
! 5853: {
! 5854: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 5855: return;
! 5856: }
! 5857:
! 5858: /*
! 5859: --------------------------------------------------------------------------------
! 5860: Mantisse d'un entier
! 5861: --------------------------------------------------------------------------------
! 5862: */
! 5863:
! 5864: if ((*s_objet_argument).type == INT)
! 5865: {
! 5866: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
! 5867: {
! 5868: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5869: return;
! 5870: }
! 5871:
! 5872: exposant = (integer8) floor(log10((*((integer8 *)
! 5873: (*s_objet_argument).objet))));
! 5874:
! 5875: base_entiere = 10;
! 5876: f77puissanceii_(&base_entiere, &exposant, &reduction_entiere);
! 5877:
! 5878: (*((real8 *) (*s_objet_resultat).objet)) = ((real8)
! 5879: (*((integer8 *) (*s_objet_argument).objet))) /
! 5880: reduction_entiere;
! 5881: }
! 5882:
! 5883: /*
! 5884: --------------------------------------------------------------------------------
! 5885: Mantisse d'un réel
! 5886: --------------------------------------------------------------------------------
! 5887: */
! 5888:
! 5889: else if ((*s_objet_argument).type == REL)
! 5890: {
! 5891: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
! 5892: {
! 5893: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5894: return;
! 5895: }
! 5896:
! 5897: exposant = (integer8) floor(log10((*((real8 *)
! 5898: (*s_objet_argument).objet))));
! 5899:
! 5900: base_reelle = 10;
! 5901: f77puissanceri_(&base_reelle, &exposant, &reduction_reelle, &erreur);
! 5902:
! 5903: if (erreur == -1)
! 5904: {
! 5905: if (test_cfsf(s_etat_processus, 59) == d_vrai)
! 5906: {
! 5907: liberation(s_etat_processus, s_objet_argument);
! 5908: liberation(s_etat_processus, s_objet_resultat);
! 5909:
! 5910: (*s_etat_processus).exception = d_ep_overflow;
! 5911: return;
! 5912: }
! 5913: else
! 5914: {
! 5915: reduction_reelle = ((double) 1) / ((double) 0);
! 5916: }
! 5917: }
! 5918:
! 5919: (*((real8 *) (*s_objet_resultat).objet)) =
! 5920: (*((real8 *) (*s_objet_argument).objet)) / reduction_reelle;
! 5921: }
! 5922:
! 5923: /*
! 5924: --------------------------------------------------------------------------------
! 5925: Mantisse d'un nom
! 5926: --------------------------------------------------------------------------------
! 5927: */
! 5928:
! 5929: else if ((*s_objet_argument).type == NOM)
! 5930: {
! 5931: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
! 5932: {
! 5933: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5934: return;
! 5935: }
! 5936:
! 5937: if (((*s_objet_resultat).objet =
! 5938: allocation_maillon(s_etat_processus)) == NULL)
! 5939: {
! 5940: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5941: return;
! 5942: }
! 5943:
! 5944: l_element_courant = (*s_objet_resultat).objet;
! 5945:
! 5946: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 5947: == NULL)
! 5948: {
! 5949: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5950: return;
! 5951: }
! 5952:
! 5953: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5954: .nombre_arguments = 0;
! 5955: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5956: .fonction = instruction_vers_niveau_superieur;
! 5957:
! 5958: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5959: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 5960: {
! 5961: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5962: return;
! 5963: }
! 5964:
! 5965: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5966: .nom_fonction, "<<");
! 5967:
! 5968: if (((*l_element_courant).suivant =
! 5969: allocation_maillon(s_etat_processus)) == NULL)
! 5970: {
! 5971: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5972: return;
! 5973: }
! 5974:
! 5975: l_element_courant = (*l_element_courant).suivant;
! 5976: (*l_element_courant).donnee = s_objet_argument;
! 5977:
! 5978: if (((*l_element_courant).suivant =
! 5979: allocation_maillon(s_etat_processus)) == NULL)
! 5980: {
! 5981: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5982: return;
! 5983: }
! 5984:
! 5985: l_element_courant = (*l_element_courant).suivant;
! 5986:
! 5987: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 5988: == NULL)
! 5989: {
! 5990: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5991: return;
! 5992: }
! 5993:
! 5994: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5995: .nombre_arguments = 1;
! 5996: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 5997: .fonction = instruction_mant;
! 5998:
! 5999: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6000: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
! 6001: {
! 6002: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6003: return;
! 6004: }
! 6005:
! 6006: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6007: .nom_fonction, "MANT");
! 6008:
! 6009: if (((*l_element_courant).suivant =
! 6010: allocation_maillon(s_etat_processus)) == NULL)
! 6011: {
! 6012: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6013: return;
! 6014: }
! 6015:
! 6016: l_element_courant = (*l_element_courant).suivant;
! 6017:
! 6018: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 6019: == NULL)
! 6020: {
! 6021: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6022: return;
! 6023: }
! 6024:
! 6025: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6026: .nombre_arguments = 0;
! 6027: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6028: .fonction = instruction_vers_niveau_inferieur;
! 6029:
! 6030: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6031: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 6032: {
! 6033: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6034: return;
! 6035: }
! 6036:
! 6037: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6038: .nom_fonction, ">>");
! 6039:
! 6040: (*l_element_courant).suivant = NULL;
! 6041: s_objet_argument = NULL;
! 6042: }
! 6043:
! 6044: /*
! 6045: --------------------------------------------------------------------------------
! 6046: Mantisse d'une expression
! 6047: --------------------------------------------------------------------------------
! 6048: */
! 6049:
! 6050: else if (((*s_objet_argument).type == ALG) ||
! 6051: ((*s_objet_argument).type == RPN))
! 6052: {
! 6053: if ((s_copie_argument = copie_objet(s_etat_processus,
! 6054: s_objet_argument, 'N')) == NULL)
! 6055: {
! 6056: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6057: return;
! 6058: }
! 6059:
! 6060: l_element_courant = (struct_liste_chainee *)
! 6061: (*s_copie_argument).objet;
! 6062: l_element_precedent = l_element_courant;
! 6063:
! 6064: while((*l_element_courant).suivant != NULL)
! 6065: {
! 6066: l_element_precedent = l_element_courant;
! 6067: l_element_courant = (*l_element_courant).suivant;
! 6068: }
! 6069:
! 6070: if (((*l_element_precedent).suivant =
! 6071: allocation_maillon(s_etat_processus)) == NULL)
! 6072: {
! 6073: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6074: return;
! 6075: }
! 6076:
! 6077: if (((*(*l_element_precedent).suivant).donnee =
! 6078: allocation(s_etat_processus, FCT)) == NULL)
! 6079: {
! 6080: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6081: return;
! 6082: }
! 6083:
! 6084: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 6085: .donnee).objet)).nombre_arguments = 1;
! 6086: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 6087: .donnee).objet)).fonction = instruction_mant;
! 6088:
! 6089: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 6090: .suivant).donnee).objet)).nom_fonction =
! 6091: malloc(5 * sizeof(unsigned char))) == NULL)
! 6092: {
! 6093: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6094: return;
! 6095: }
! 6096:
! 6097: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 6098: .suivant).donnee).objet)).nom_fonction, "MANT");
! 6099:
! 6100: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 6101:
! 6102: s_objet_resultat = s_copie_argument;
! 6103: }
! 6104:
! 6105: /*
! 6106: --------------------------------------------------------------------------------
! 6107: Fonction mantisse impossible à réaliser
! 6108: --------------------------------------------------------------------------------
! 6109: */
! 6110:
! 6111: else
! 6112: {
! 6113: liberation(s_etat_processus, s_objet_argument);
! 6114:
! 6115: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 6116: return;
! 6117: }
! 6118:
! 6119: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 6120: s_objet_resultat) == d_erreur)
! 6121: {
! 6122: return;
! 6123: }
! 6124:
! 6125: liberation(s_etat_processus, s_objet_argument);
! 6126:
! 6127: return;
! 6128: }
! 6129:
! 6130:
! 6131: /*
! 6132: ================================================================================
! 6133: Fonction 'mod'
! 6134: ================================================================================
! 6135: Entrées :
! 6136: --------------------------------------------------------------------------------
! 6137: Sorties :
! 6138: --------------------------------------------------------------------------------
! 6139: Effets de bord : néant
! 6140: ================================================================================
! 6141: */
! 6142:
! 6143: void
! 6144: instruction_mod(struct_processus *s_etat_processus)
! 6145: {
! 6146: struct_liste_chainee *l_element_courant;
! 6147: struct_liste_chainee *l_element_precedent;
! 6148:
! 6149: struct_objet *s_copie_argument_1;
! 6150: struct_objet *s_copie_argument_2;
! 6151: struct_objet *s_objet_argument_1;
! 6152: struct_objet *s_objet_argument_2;
! 6153: struct_objet *s_objet_resultat;
! 6154:
! 6155: unsigned long i;
! 6156: unsigned long j;
! 6157: unsigned long nombre_elements;
! 6158:
! 6159: (*s_etat_processus).erreur_execution = d_ex;
! 6160:
! 6161: if ((*s_etat_processus).affichage_arguments == 'Y')
! 6162: {
! 6163: printf("\n MOD ");
! 6164:
! 6165: if ((*s_etat_processus).langue == 'F')
! 6166: {
! 6167: printf("(modulo)\n\n");
! 6168: }
! 6169: else
! 6170: {
! 6171: printf("(modulo)\n\n");
! 6172: }
! 6173:
! 6174: printf(" 2: %s, %s\n", d_INT, d_REL);
! 6175: printf(" 1: %s, %s\n", d_INT, d_REL);
! 6176: printf("-> 1: %s, %s\n\n", d_INT, d_REL);
! 6177:
! 6178: printf(" 2: %s, %s, %s, %s, %s, %s\n",
! 6179: d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN);
! 6180: printf(" 1: %s, %s, %s, %s, %s, %s\n",
! 6181: d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN);
! 6182: printf("-> 1: %s, %s\n", d_ALG, d_RPN);
! 6183:
! 6184: return;
! 6185: }
! 6186: else if ((*s_etat_processus).test_instruction == 'Y')
! 6187: {
! 6188: (*s_etat_processus).nombre_arguments = 2;
! 6189: return;
! 6190: }
! 6191:
! 6192: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 6193: {
! 6194: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 6195: {
! 6196: return;
! 6197: }
! 6198: }
! 6199:
! 6200: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 6201: &s_objet_argument_1) == d_erreur)
! 6202: {
! 6203: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 6204: return;
! 6205: }
! 6206:
! 6207: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 6208: &s_objet_argument_2) == d_erreur)
! 6209: {
! 6210: liberation(s_etat_processus, s_objet_argument_1);
! 6211:
! 6212: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 6213: return;
! 6214: }
! 6215:
! 6216: /*
! 6217: --------------------------------------------------------------------------------
! 6218: MOD portant sur des valeurs numériques
! 6219: --------------------------------------------------------------------------------
! 6220: */
! 6221:
! 6222: if ((((*s_objet_argument_1).type == INT) ||
! 6223: ((*s_objet_argument_1).type == REL)) &&
! 6224: (((*s_objet_argument_2).type == INT) ||
! 6225: ((*s_objet_argument_2).type == REL)))
! 6226: {
! 6227: if ((*s_objet_argument_1).type == INT)
! 6228: {
! 6229: if ((*s_objet_argument_2).type == INT)
! 6230: {
! 6231: if ((s_objet_resultat = allocation(s_etat_processus, INT))
! 6232: == NULL)
! 6233: {
! 6234: (*s_etat_processus).erreur_systeme =
! 6235: d_es_allocation_memoire;
! 6236: return;
! 6237: }
! 6238:
! 6239: (*((integer8 *) (*s_objet_resultat).objet)) =
! 6240: (*((integer8 *) (*s_objet_argument_2).objet)) -
! 6241: ((*((integer8 *) (*s_objet_argument_1).objet)) *
! 6242: floor(((real8) (*((integer8 *) (*s_objet_argument_2)
! 6243: .objet))) / ((real8) (*((integer8 *)
! 6244: (*s_objet_argument_1).objet)))));
! 6245: }
! 6246: else
! 6247: {
! 6248: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 6249: == NULL)
! 6250: {
! 6251: (*s_etat_processus).erreur_systeme =
! 6252: d_es_allocation_memoire;
! 6253: return;
! 6254: }
! 6255:
! 6256: (*((real8 *) (*s_objet_resultat).objet)) =
! 6257: (*((real8 *) (*s_objet_argument_2).objet)) -
! 6258: ((*((integer8 *) (*s_objet_argument_1).objet)) *
! 6259: floor((*((real8 *) (*s_objet_argument_2)
! 6260: .objet)) / ((real8) (*((integer8 *)
! 6261: (*s_objet_argument_1).objet)))));
! 6262: }
! 6263: }
! 6264: else
! 6265: {
! 6266: if ((*s_objet_argument_2).type == INT)
! 6267: {
! 6268: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 6269: == NULL)
! 6270: {
! 6271: (*s_etat_processus).erreur_systeme =
! 6272: d_es_allocation_memoire;
! 6273: return;
! 6274: }
! 6275:
! 6276: (*((real8 *) (*s_objet_resultat).objet)) =
! 6277: (*((integer8 *) (*s_objet_argument_2).objet)) -
! 6278: ((*((real8 *) (*s_objet_argument_1).objet)) *
! 6279: floor(((real8) (*((integer8 *) (*s_objet_argument_2)
! 6280: .objet))) / (*((real8 *)
! 6281: (*s_objet_argument_1).objet))));
! 6282: }
! 6283: else
! 6284: {
! 6285: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 6286: == NULL)
! 6287: {
! 6288: (*s_etat_processus).erreur_systeme =
! 6289: d_es_allocation_memoire;
! 6290: return;
! 6291: }
! 6292:
! 6293: (*((real8 *) (*s_objet_resultat).objet)) =
! 6294: (*((real8 *) (*s_objet_argument_2).objet)) -
! 6295: ((*((real8 *) (*s_objet_argument_1).objet)) *
! 6296: floor((*((real8 *) (*s_objet_argument_2)
! 6297: .objet)) / (*((real8 *)
! 6298: (*s_objet_argument_1).objet))));
! 6299: }
! 6300: }
! 6301: }
! 6302:
! 6303: /*
! 6304: --------------------------------------------------------------------------------
! 6305: MOD portant sur des vecteurs
! 6306: --------------------------------------------------------------------------------
! 6307: */
! 6308:
! 6309: else if ((((*s_objet_argument_1).type == INT) ||
! 6310: ((*s_objet_argument_1).type == REL)) &&
! 6311: (((*s_objet_argument_2).type == VIN) ||
! 6312: ((*s_objet_argument_2).type == VRL)))
! 6313: {
! 6314: if ((*s_objet_argument_1).type == INT)
! 6315: {
! 6316: if ((*s_objet_argument_2).type == VIN)
! 6317: {
! 6318: if ((s_objet_resultat = allocation(s_etat_processus, VIN))
! 6319: == NULL)
! 6320: {
! 6321: (*s_etat_processus).erreur_systeme =
! 6322: d_es_allocation_memoire;
! 6323: return;
! 6324: }
! 6325:
! 6326: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 6327: (*((struct_vecteur *) (*s_objet_argument_2).objet))
! 6328: .taille;
! 6329:
! 6330: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 6331: malloc((*((struct_vecteur *) (*s_objet_resultat).objet))
! 6332: .taille * sizeof(integer8))) == NULL)
! 6333: {
! 6334: (*s_etat_processus).erreur_systeme =
! 6335: d_es_allocation_memoire;
! 6336: return;
! 6337: }
! 6338:
! 6339: for(i = 0; i < (*((struct_vecteur *) (*s_objet_resultat).objet))
! 6340: .taille; i++)
! 6341: {
! 6342: ((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
! 6343: .objet)).tableau)[i] = ((integer8 *)
! 6344: (*((struct_vecteur *) (*s_objet_argument_2).objet))
! 6345: .tableau)[i] - ((*((integer8 *)
! 6346: (*s_objet_argument_1).objet)) * floor(((real8)
! 6347: ((integer8 *) (*((struct_vecteur *)
! 6348: (*s_objet_argument_2).objet)).tableau)[i]) /
! 6349: ((real8) (*((integer8 *) (*s_objet_argument_1)
! 6350: .objet)))));
! 6351: }
! 6352: }
! 6353: else
! 6354: {
! 6355: if ((s_objet_resultat = allocation(s_etat_processus, VRL))
! 6356: == NULL)
! 6357: {
! 6358: (*s_etat_processus).erreur_systeme =
! 6359: d_es_allocation_memoire;
! 6360: return;
! 6361: }
! 6362:
! 6363: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 6364: (*((struct_vecteur *) (*s_objet_argument_2).objet))
! 6365: .taille;
! 6366:
! 6367: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 6368: malloc((*((struct_vecteur *) (*s_objet_resultat).objet))
! 6369: .taille * sizeof(real8))) == NULL)
! 6370: {
! 6371: (*s_etat_processus).erreur_systeme =
! 6372: d_es_allocation_memoire;
! 6373: return;
! 6374: }
! 6375:
! 6376: for(i = 0; i < (*((struct_vecteur *) (*s_objet_resultat).objet))
! 6377: .taille; i++)
! 6378: {
! 6379: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat)
! 6380: .objet)).tableau)[i] = ((real8 *)
! 6381: (*((struct_vecteur *) (*s_objet_argument_2).objet))
! 6382: .tableau)[i] - ((*((integer8 *)
! 6383: (*s_objet_argument_1).objet)) * floor(
! 6384: ((real8 *) (*((struct_vecteur *)
! 6385: (*s_objet_argument_2).objet)).tableau)[i] /
! 6386: ((real8) (*((integer8 *) (*s_objet_argument_1)
! 6387: .objet)))));
! 6388: }
! 6389: }
! 6390: }
! 6391: else
! 6392: {
! 6393: if ((*s_objet_argument_2).type == VIN)
! 6394: {
! 6395: if ((s_objet_resultat = allocation(s_etat_processus, VRL))
! 6396: == NULL)
! 6397: {
! 6398: (*s_etat_processus).erreur_systeme =
! 6399: d_es_allocation_memoire;
! 6400: return;
! 6401: }
! 6402:
! 6403: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 6404: (*((struct_vecteur *) (*s_objet_argument_2).objet))
! 6405: .taille;
! 6406:
! 6407: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 6408: malloc((*((struct_vecteur *) (*s_objet_resultat).objet))
! 6409: .taille * sizeof(real8))) == NULL)
! 6410: {
! 6411: (*s_etat_processus).erreur_systeme =
! 6412: d_es_allocation_memoire;
! 6413: return;
! 6414: }
! 6415:
! 6416: for(i = 0; i < (*((struct_vecteur *) (*s_objet_resultat).objet))
! 6417: .taille; i++)
! 6418: {
! 6419: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat)
! 6420: .objet)).tableau)[i] = ((integer8 *)
! 6421: (*((struct_vecteur *) (*s_objet_argument_2).objet))
! 6422: .tableau)[i] - ((*((real8 *)
! 6423: (*s_objet_argument_1).objet)) * floor(((real8)
! 6424: ((integer8 *) (*((struct_vecteur *)
! 6425: (*s_objet_argument_2).objet)).tableau)[i]) /
! 6426: (*((real8 *) (*s_objet_argument_1)
! 6427: .objet))));
! 6428: }
! 6429: }
! 6430: else
! 6431: {
! 6432: if ((s_objet_resultat = allocation(s_etat_processus, VRL))
! 6433: == NULL)
! 6434: {
! 6435: (*s_etat_processus).erreur_systeme =
! 6436: d_es_allocation_memoire;
! 6437: return;
! 6438: }
! 6439:
! 6440: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
! 6441: (*((struct_vecteur *) (*s_objet_argument_2).objet))
! 6442: .taille;
! 6443:
! 6444: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
! 6445: malloc((*((struct_vecteur *) (*s_objet_resultat).objet))
! 6446: .taille * sizeof(real8))) == NULL)
! 6447: {
! 6448: (*s_etat_processus).erreur_systeme =
! 6449: d_es_allocation_memoire;
! 6450: return;
! 6451: }
! 6452:
! 6453: for(i = 0; i < (*((struct_vecteur *) (*s_objet_resultat).objet))
! 6454: .taille; i++)
! 6455: {
! 6456: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat)
! 6457: .objet)).tableau)[i] = ((real8 *)
! 6458: (*((struct_vecteur *) (*s_objet_argument_2).objet))
! 6459: .tableau)[i] - ((*((real8 *)
! 6460: (*s_objet_argument_1).objet)) * floor(
! 6461: ((real8 *) (*((struct_vecteur *)
! 6462: (*s_objet_argument_2).objet)).tableau)[i] /
! 6463: (*((real8 *) (*s_objet_argument_1)
! 6464: .objet))));
! 6465: }
! 6466: }
! 6467: }
! 6468: }
! 6469:
! 6470: /*
! 6471: --------------------------------------------------------------------------------
! 6472: MOD portant sur des matrices
! 6473: --------------------------------------------------------------------------------
! 6474: */
! 6475:
! 6476: else if ((((*s_objet_argument_1).type == INT) ||
! 6477: ((*s_objet_argument_1).type == REL)) &&
! 6478: (((*s_objet_argument_2).type == MIN) ||
! 6479: ((*s_objet_argument_2).type == MRL)))
! 6480: {
! 6481: if ((*s_objet_argument_1).type == INT)
! 6482: {
! 6483: if ((*s_objet_argument_2).type == MIN)
! 6484: {
! 6485: if ((s_objet_resultat = allocation(s_etat_processus, MIN))
! 6486: == NULL)
! 6487: {
! 6488: (*s_etat_processus).erreur_systeme =
! 6489: d_es_allocation_memoire;
! 6490: return;
! 6491: }
! 6492:
! 6493: (*((struct_matrice *) (*s_objet_resultat).objet))
! 6494: .nombre_lignes = (*((struct_matrice *)
! 6495: (*s_objet_argument_2).objet)).nombre_lignes;
! 6496: (*((struct_matrice *) (*s_objet_resultat).objet))
! 6497: .nombre_colonnes = (*((struct_matrice *)
! 6498: (*s_objet_argument_2).objet)).nombre_colonnes;
! 6499:
! 6500: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 6501: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
! 6502: .nombre_lignes * sizeof(integer8 *))) == NULL)
! 6503: {
! 6504: (*s_etat_processus).erreur_systeme =
! 6505: d_es_allocation_memoire;
! 6506: return;
! 6507: }
! 6508:
! 6509: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
! 6510: .nombre_lignes; i++)
! 6511: {
! 6512: if ((((integer8 **) (*((struct_matrice *)
! 6513: (*s_objet_resultat).objet)).tableau)[i] =
! 6514: malloc((*((struct_matrice *) (*s_objet_resultat)
! 6515: .objet)).nombre_colonnes * sizeof(integer8)))
! 6516: == NULL)
! 6517: {
! 6518: (*s_etat_processus).erreur_systeme =
! 6519: d_es_allocation_memoire;
! 6520: return;
! 6521: }
! 6522:
! 6523: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat)
! 6524: .objet)).nombre_colonnes; j++)
! 6525: {
! 6526: ((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
! 6527: .objet)).tableau)[i][j] = ((integer8 **)
! 6528: (*((struct_matrice *) (*s_objet_argument_2)
! 6529: .objet)).tableau)[i][j] - ((*((integer8 *)
! 6530: (*s_objet_argument_1).objet)) * floor(((real8)
! 6531: ((integer8 **) (*((struct_matrice *)
! 6532: (*s_objet_argument_2).objet)).tableau)[i][j]) /
! 6533: ((real8) (*((integer8 *) (*s_objet_argument_1)
! 6534: .objet)))));
! 6535: }
! 6536: }
! 6537: }
! 6538: else
! 6539: {
! 6540: if ((s_objet_resultat = allocation(s_etat_processus, MRL))
! 6541: == NULL)
! 6542: {
! 6543: (*s_etat_processus).erreur_systeme =
! 6544: d_es_allocation_memoire;
! 6545: return;
! 6546: }
! 6547:
! 6548: (*((struct_matrice *) (*s_objet_resultat).objet))
! 6549: .nombre_lignes = (*((struct_matrice *)
! 6550: (*s_objet_argument_2).objet)).nombre_lignes;
! 6551: (*((struct_matrice *) (*s_objet_resultat).objet))
! 6552: .nombre_colonnes = (*((struct_matrice *)
! 6553: (*s_objet_argument_2).objet)).nombre_colonnes;
! 6554:
! 6555: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 6556: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
! 6557: .nombre_lignes * sizeof(real8 *))) == NULL)
! 6558: {
! 6559: (*s_etat_processus).erreur_systeme =
! 6560: d_es_allocation_memoire;
! 6561: return;
! 6562: }
! 6563:
! 6564: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
! 6565: .nombre_lignes; i++)
! 6566: {
! 6567: if ((((real8 **) (*((struct_matrice *)
! 6568: (*s_objet_resultat).objet)).tableau)[i] =
! 6569: malloc((*((struct_matrice *) (*s_objet_resultat)
! 6570: .objet)).nombre_colonnes * sizeof(real8)))
! 6571: == NULL)
! 6572: {
! 6573: (*s_etat_processus).erreur_systeme =
! 6574: d_es_allocation_memoire;
! 6575: return;
! 6576: }
! 6577:
! 6578: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat)
! 6579: .objet)).nombre_colonnes; j++)
! 6580: {
! 6581: ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
! 6582: .objet)).tableau)[i][j] = ((real8 **)
! 6583: (*((struct_matrice *) (*s_objet_argument_2)
! 6584: .objet)).tableau)[i][j] - ((*((integer8 *)
! 6585: (*s_objet_argument_1).objet)) * floor(
! 6586: ((real8 **) (*((struct_matrice *)
! 6587: (*s_objet_argument_2).objet)).tableau)[i][j] /
! 6588: ((real8) (*((integer8 *) (*s_objet_argument_1)
! 6589: .objet)))));
! 6590: }
! 6591: }
! 6592: }
! 6593: }
! 6594: else
! 6595: {
! 6596: if ((*s_objet_argument_2).type == MIN)
! 6597: {
! 6598: if ((s_objet_resultat = allocation(s_etat_processus, MRL))
! 6599: == NULL)
! 6600: {
! 6601: (*s_etat_processus).erreur_systeme =
! 6602: d_es_allocation_memoire;
! 6603: return;
! 6604: }
! 6605:
! 6606: (*((struct_matrice *) (*s_objet_resultat).objet))
! 6607: .nombre_lignes = (*((struct_matrice *)
! 6608: (*s_objet_argument_2).objet)).nombre_lignes;
! 6609: (*((struct_matrice *) (*s_objet_resultat).objet))
! 6610: .nombre_colonnes = (*((struct_matrice *)
! 6611: (*s_objet_argument_2).objet)).nombre_colonnes;
! 6612:
! 6613: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 6614: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
! 6615: .nombre_lignes * sizeof(real8 *))) == NULL)
! 6616: {
! 6617: (*s_etat_processus).erreur_systeme =
! 6618: d_es_allocation_memoire;
! 6619: return;
! 6620: }
! 6621:
! 6622: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
! 6623: .nombre_lignes; i++)
! 6624: {
! 6625: if ((((real8 **) (*((struct_matrice *)
! 6626: (*s_objet_resultat).objet)).tableau)[i] =
! 6627: malloc((*((struct_matrice *) (*s_objet_resultat)
! 6628: .objet)).nombre_colonnes * sizeof(real8)))
! 6629: == NULL)
! 6630: {
! 6631: (*s_etat_processus).erreur_systeme =
! 6632: d_es_allocation_memoire;
! 6633: return;
! 6634: }
! 6635:
! 6636: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat)
! 6637: .objet)).nombre_colonnes; j++)
! 6638: {
! 6639: ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
! 6640: .objet)).tableau)[i][j] = ((integer8 **)
! 6641: (*((struct_matrice *) (*s_objet_argument_2)
! 6642: .objet)).tableau)[i][j] - ((*((real8 *)
! 6643: (*s_objet_argument_1).objet)) * floor(((real8)
! 6644: ((integer8 **) (*((struct_matrice *)
! 6645: (*s_objet_argument_2).objet)).tableau)[i][j]) /
! 6646: (*((real8 *) (*s_objet_argument_1)
! 6647: .objet))));
! 6648: }
! 6649: }
! 6650: }
! 6651: else
! 6652: {
! 6653: if ((s_objet_resultat = allocation(s_etat_processus, MRL))
! 6654: == NULL)
! 6655: {
! 6656: (*s_etat_processus).erreur_systeme =
! 6657: d_es_allocation_memoire;
! 6658: return;
! 6659: }
! 6660:
! 6661: (*((struct_matrice *) (*s_objet_resultat).objet))
! 6662: .nombre_lignes = (*((struct_matrice *)
! 6663: (*s_objet_argument_2).objet)).nombre_lignes;
! 6664: (*((struct_matrice *) (*s_objet_resultat).objet))
! 6665: .nombre_colonnes = (*((struct_matrice *)
! 6666: (*s_objet_argument_2).objet)).nombre_colonnes;
! 6667:
! 6668: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 6669: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
! 6670: .nombre_lignes * sizeof(real8 *))) == NULL)
! 6671: {
! 6672: (*s_etat_processus).erreur_systeme =
! 6673: d_es_allocation_memoire;
! 6674: return;
! 6675: }
! 6676:
! 6677: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
! 6678: .nombre_lignes; i++)
! 6679: {
! 6680: if ((((real8 **) (*((struct_matrice *)
! 6681: (*s_objet_resultat).objet)).tableau)[i] =
! 6682: malloc((*((struct_matrice *) (*s_objet_resultat)
! 6683: .objet)).nombre_colonnes * sizeof(real8)))
! 6684: == NULL)
! 6685: {
! 6686: (*s_etat_processus).erreur_systeme =
! 6687: d_es_allocation_memoire;
! 6688: return;
! 6689: }
! 6690:
! 6691: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat)
! 6692: .objet)).nombre_colonnes; j++)
! 6693: {
! 6694: ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
! 6695: .objet)).tableau)[i][j] = ((real8 **)
! 6696: (*((struct_matrice *) (*s_objet_argument_2)
! 6697: .objet)).tableau)[i][j] - ((*((real8 *)
! 6698: (*s_objet_argument_1).objet)) * floor(
! 6699: ((real8 **) (*((struct_matrice *)
! 6700: (*s_objet_argument_2).objet)).tableau)[i][j] /
! 6701: (*((real8 *) (*s_objet_argument_1)
! 6702: .objet))));
! 6703: }
! 6704: }
! 6705: }
! 6706: }
! 6707: }
! 6708:
! 6709: /*
! 6710: --------------------------------------------------------------------------------
! 6711: MOD entre des arguments complexes
! 6712: --------------------------------------------------------------------------------
! 6713: */
! 6714:
! 6715: /*
! 6716: * Nom ou valeur numérique / Nom ou valeur numérique
! 6717: */
! 6718:
! 6719: else if ((((*s_objet_argument_1).type == NOM) &&
! 6720: (((*s_objet_argument_2).type == NOM) ||
! 6721: ((*s_objet_argument_2).type == INT) ||
! 6722: ((*s_objet_argument_2).type == REL))) ||
! 6723: (((*s_objet_argument_2).type == NOM) &&
! 6724: (((*s_objet_argument_1).type == INT) ||
! 6725: ((*s_objet_argument_1).type == REL))))
! 6726: {
! 6727: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
! 6728: {
! 6729: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6730: return;
! 6731: }
! 6732:
! 6733: if (((*s_objet_resultat).objet =
! 6734: allocation_maillon(s_etat_processus)) == NULL)
! 6735: {
! 6736: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6737: return;
! 6738: }
! 6739:
! 6740: l_element_courant = (*s_objet_resultat).objet;
! 6741:
! 6742: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 6743: == NULL)
! 6744: {
! 6745: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6746: return;
! 6747: }
! 6748:
! 6749: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6750: .nombre_arguments = 0;
! 6751: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6752: .fonction = instruction_vers_niveau_superieur;
! 6753:
! 6754: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6755: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 6756: {
! 6757: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6758: return;
! 6759: }
! 6760:
! 6761: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6762: .nom_fonction, "<<");
! 6763:
! 6764: if (((*l_element_courant).suivant =
! 6765: allocation_maillon(s_etat_processus)) == NULL)
! 6766: {
! 6767: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6768: return;
! 6769: }
! 6770:
! 6771: l_element_courant = (*l_element_courant).suivant;
! 6772: (*l_element_courant).donnee = s_objet_argument_2;
! 6773:
! 6774: if (((*l_element_courant).suivant =
! 6775: allocation_maillon(s_etat_processus)) == NULL)
! 6776: {
! 6777: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6778: return;
! 6779: }
! 6780:
! 6781: l_element_courant = (*l_element_courant).suivant;
! 6782: (*l_element_courant).donnee = s_objet_argument_1;
! 6783:
! 6784: if (((*l_element_courant).suivant =
! 6785: allocation_maillon(s_etat_processus)) == NULL)
! 6786: {
! 6787: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6788: return;
! 6789: }
! 6790:
! 6791: l_element_courant = (*l_element_courant).suivant;
! 6792:
! 6793: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 6794: == NULL)
! 6795: {
! 6796: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6797: return;
! 6798: }
! 6799:
! 6800: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6801: .nombre_arguments = 2;
! 6802: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6803: .fonction = instruction_mod;
! 6804:
! 6805: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6806: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
! 6807: {
! 6808: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6809: return;
! 6810: }
! 6811:
! 6812: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6813: .nom_fonction, "MOD");
! 6814:
! 6815: if (((*l_element_courant).suivant =
! 6816: allocation_maillon(s_etat_processus)) == NULL)
! 6817: {
! 6818: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6819: return;
! 6820: }
! 6821:
! 6822: l_element_courant = (*l_element_courant).suivant;
! 6823:
! 6824: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 6825: == NULL)
! 6826: {
! 6827: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6828: return;
! 6829: }
! 6830:
! 6831: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6832: .nombre_arguments = 0;
! 6833: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6834: .fonction = instruction_vers_niveau_inferieur;
! 6835:
! 6836: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6837: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 6838: {
! 6839: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6840: return;
! 6841: }
! 6842:
! 6843: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 6844: .nom_fonction, ">>");
! 6845:
! 6846: (*l_element_courant).suivant = NULL;
! 6847:
! 6848: s_objet_argument_1 = NULL;
! 6849: s_objet_argument_2 = NULL;
! 6850: }
! 6851:
! 6852: /*
! 6853: * Nom ou valeur numérique / Expression
! 6854: */
! 6855:
! 6856: else if (((((*s_objet_argument_1).type == ALG) ||
! 6857: ((*s_objet_argument_1).type == RPN))) &&
! 6858: (((*s_objet_argument_2).type == NOM) ||
! 6859: ((*s_objet_argument_2).type == INT) ||
! 6860: ((*s_objet_argument_2).type == REL)))
! 6861: {
! 6862: nombre_elements = 0;
! 6863: l_element_courant = (struct_liste_chainee *)
! 6864: (*s_objet_argument_1).objet;
! 6865:
! 6866: while(l_element_courant != NULL)
! 6867: {
! 6868: nombre_elements++;
! 6869: l_element_courant = (*l_element_courant).suivant;
! 6870: }
! 6871:
! 6872: if (nombre_elements == 2)
! 6873: {
! 6874: liberation(s_etat_processus, s_objet_argument_1);
! 6875: liberation(s_etat_processus, s_objet_argument_2);
! 6876:
! 6877: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 6878: return;
! 6879: }
! 6880:
! 6881: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 6882: s_objet_argument_1, 'N')) == NULL)
! 6883: {
! 6884: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6885: return;
! 6886: }
! 6887:
! 6888: l_element_courant = (struct_liste_chainee *)
! 6889: (*s_objet_resultat).objet;
! 6890: l_element_precedent = l_element_courant;
! 6891: l_element_courant = (*l_element_courant).suivant;
! 6892:
! 6893: if (((*l_element_precedent).suivant =
! 6894: allocation_maillon(s_etat_processus)) == NULL)
! 6895: {
! 6896: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6897: return;
! 6898: }
! 6899:
! 6900: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
! 6901: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 6902:
! 6903: while((*l_element_courant).suivant != NULL)
! 6904: {
! 6905: l_element_precedent = l_element_courant;
! 6906: l_element_courant = (*l_element_courant).suivant;
! 6907: }
! 6908:
! 6909: if (((*l_element_precedent).suivant =
! 6910: allocation_maillon(s_etat_processus)) == NULL)
! 6911: {
! 6912: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6913: return;
! 6914: }
! 6915:
! 6916: if (((*(*l_element_precedent).suivant).donnee =
! 6917: allocation(s_etat_processus, FCT)) == NULL)
! 6918: {
! 6919: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6920: return;
! 6921: }
! 6922:
! 6923: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 6924: .donnee).objet)).nombre_arguments = 2;
! 6925: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 6926: .donnee).objet)).fonction = instruction_mod;
! 6927:
! 6928: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 6929: .suivant).donnee).objet)).nom_fonction =
! 6930: malloc(4 * sizeof(unsigned char))) == NULL)
! 6931: {
! 6932: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6933: return;
! 6934: }
! 6935:
! 6936: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 6937: .suivant).donnee).objet)).nom_fonction, "MOD");
! 6938:
! 6939: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 6940:
! 6941: s_objet_argument_2 = NULL;
! 6942: }
! 6943:
! 6944: /*
! 6945: * Expression / Nom ou valeur numérique
! 6946: */
! 6947:
! 6948: else if ((((*s_objet_argument_1).type == NOM) ||
! 6949: ((*s_objet_argument_1).type == INT) ||
! 6950: ((*s_objet_argument_1).type == REL)) &&
! 6951: ((((*s_objet_argument_2).type == ALG) ||
! 6952: ((*s_objet_argument_2).type == RPN))))
! 6953: {
! 6954: nombre_elements = 0;
! 6955: l_element_courant = (struct_liste_chainee *)
! 6956: (*s_objet_argument_2).objet;
! 6957:
! 6958: while(l_element_courant != NULL)
! 6959: {
! 6960: nombre_elements++;
! 6961: l_element_courant = (*l_element_courant).suivant;
! 6962: }
! 6963:
! 6964: if (nombre_elements == 2)
! 6965: {
! 6966: liberation(s_etat_processus, s_objet_argument_1);
! 6967: liberation(s_etat_processus, s_objet_argument_2);
! 6968:
! 6969: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 6970: return;
! 6971: }
! 6972:
! 6973: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 6974: s_objet_argument_2, 'N')) == NULL)
! 6975: {
! 6976: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6977: return;
! 6978: }
! 6979:
! 6980: l_element_courant = (struct_liste_chainee *)
! 6981: (*s_objet_resultat).objet;
! 6982: l_element_precedent = l_element_courant;
! 6983:
! 6984: while((*l_element_courant).suivant != NULL)
! 6985: {
! 6986: l_element_precedent = l_element_courant;
! 6987: l_element_courant = (*l_element_courant).suivant;
! 6988: }
! 6989:
! 6990: if (((*l_element_precedent).suivant =
! 6991: allocation_maillon(s_etat_processus)) == NULL)
! 6992: {
! 6993: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 6994: return;
! 6995: }
! 6996:
! 6997: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
! 6998: l_element_precedent = (*l_element_precedent).suivant;
! 6999:
! 7000: if (((*l_element_precedent).suivant =
! 7001: allocation_maillon(s_etat_processus)) == NULL)
! 7002: {
! 7003: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 7004: return;
! 7005: }
! 7006:
! 7007: if (((*(*l_element_precedent).suivant).donnee =
! 7008: allocation(s_etat_processus, FCT)) == NULL)
! 7009: {
! 7010: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 7011: return;
! 7012: }
! 7013:
! 7014: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 7015: .donnee).objet)).nombre_arguments = 2;
! 7016: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 7017: .donnee).objet)).fonction = instruction_mod;
! 7018:
! 7019: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 7020: .suivant).donnee).objet)).nom_fonction =
! 7021: malloc(4 * sizeof(unsigned char))) == NULL)
! 7022: {
! 7023: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 7024: return;
! 7025: }
! 7026:
! 7027: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 7028: .suivant).donnee).objet)).nom_fonction, "MOD");
! 7029:
! 7030: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 7031:
! 7032: s_objet_argument_1 = NULL;
! 7033: }
! 7034:
! 7035: /*
! 7036: * Expression / Expression
! 7037: */
! 7038:
! 7039: else if ((((*s_objet_argument_1).type == ALG) &&
! 7040: ((*s_objet_argument_2).type == ALG)) ||
! 7041: (((*s_objet_argument_1).type == RPN) &&
! 7042: ((*s_objet_argument_2).type == RPN)))
! 7043: {
! 7044: nombre_elements = 0;
! 7045: l_element_courant = (struct_liste_chainee *)
! 7046: (*s_objet_argument_1).objet;
! 7047:
! 7048: while(l_element_courant != NULL)
! 7049: {
! 7050: nombre_elements++;
! 7051: l_element_courant = (*l_element_courant).suivant;
! 7052: }
! 7053:
! 7054: if (nombre_elements == 2)
! 7055: {
! 7056: liberation(s_etat_processus, s_objet_argument_1);
! 7057: liberation(s_etat_processus, s_objet_argument_2);
! 7058:
! 7059: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 7060: return;
! 7061: }
! 7062:
! 7063: nombre_elements = 0;
! 7064: l_element_courant = (struct_liste_chainee *)
! 7065: (*s_objet_argument_2).objet;
! 7066:
! 7067: while(l_element_courant != NULL)
! 7068: {
! 7069: nombre_elements++;
! 7070: l_element_courant = (*l_element_courant).suivant;
! 7071: }
! 7072:
! 7073: if (nombre_elements == 2)
! 7074: {
! 7075: liberation(s_etat_processus, s_objet_argument_1);
! 7076: liberation(s_etat_processus, s_objet_argument_2);
! 7077:
! 7078: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 7079: return;
! 7080: }
! 7081:
! 7082: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
! 7083: s_objet_argument_1, 'N')) == NULL)
! 7084: {
! 7085: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 7086: return;
! 7087: }
! 7088:
! 7089: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
! 7090: s_objet_argument_2, 'N')) == NULL)
! 7091: {
! 7092: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 7093: return;
! 7094: }
! 7095:
! 7096: l_element_courant = (struct_liste_chainee *)
! 7097: (*s_copie_argument_1).objet;
! 7098: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
! 7099: (*s_copie_argument_1).objet)).suivant;
! 7100:
! 7101: liberation(s_etat_processus, (*l_element_courant).donnee);
! 7102: free(l_element_courant);
! 7103:
! 7104: l_element_courant = (struct_liste_chainee *)
! 7105: (*s_copie_argument_2).objet;
! 7106: l_element_precedent = l_element_courant;
! 7107: s_objet_resultat = s_copie_argument_2;
! 7108:
! 7109: while((*l_element_courant).suivant != NULL)
! 7110: {
! 7111: l_element_precedent = l_element_courant;
! 7112: l_element_courant = (*l_element_courant).suivant;
! 7113: }
! 7114:
! 7115: liberation(s_etat_processus, (*l_element_courant).donnee);
! 7116: free(l_element_courant);
! 7117:
! 7118: (*l_element_precedent).suivant = (struct_liste_chainee *)
! 7119: (*s_copie_argument_1).objet;
! 7120: free(s_copie_argument_1);
! 7121:
! 7122: l_element_courant = (*l_element_precedent).suivant;
! 7123: while((*l_element_courant).suivant != NULL)
! 7124: {
! 7125: l_element_precedent = l_element_courant;
! 7126: l_element_courant = (*l_element_courant).suivant;
! 7127: }
! 7128:
! 7129: if (((*l_element_precedent).suivant =
! 7130: allocation_maillon(s_etat_processus)) == NULL)
! 7131: {
! 7132: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 7133: return;
! 7134: }
! 7135:
! 7136: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 7137: l_element_courant = (*l_element_precedent).suivant;
! 7138:
! 7139: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 7140: == NULL)
! 7141: {
! 7142: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 7143: return;
! 7144: }
! 7145:
! 7146: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 7147: .nombre_arguments = 2;
! 7148: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 7149: .fonction = instruction_mod;
! 7150:
! 7151: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 7152: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
! 7153: {
! 7154: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 7155: return;
! 7156: }
! 7157:
! 7158: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 7159: .nom_fonction, "MOD");
! 7160: }
! 7161:
! 7162: /*
! 7163: --------------------------------------------------------------------------------
! 7164: Arguments incorrects
! 7165: --------------------------------------------------------------------------------
! 7166: */
! 7167:
! 7168: else
! 7169: {
! 7170: liberation(s_etat_processus, s_objet_argument_1);
! 7171: liberation(s_etat_processus, s_objet_argument_2);
! 7172:
! 7173: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 7174: return;
! 7175: }
! 7176:
! 7177: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 7178: s_objet_resultat) == d_erreur)
! 7179: {
! 7180: return;
! 7181: }
! 7182:
! 7183: liberation(s_etat_processus, s_objet_argument_1);
! 7184: liberation(s_etat_processus, s_objet_argument_2);
! 7185:
! 7186: return;
! 7187: }
! 7188:
! 7189: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_m1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src