![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 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