![]() ![]() | ![]() |
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 'p->r' 29: ================================================================================ 30: Entrées : pointeur sur une structure struct_processus 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_p_vers_r(struct_processus *s_etat_processus) 40: { 41: double angle; 42: 43: struct_liste_chainee *l_element_courant; 44: struct_liste_chainee *l_element_precedent; 45: 46: struct_objet *s_copie_argument; 47: struct_objet *s_objet_argument; 48: struct_objet *s_objet_resultat; 49: 50: (*s_etat_processus).erreur_execution = d_ex; 51: 52: if ((*s_etat_processus).affichage_arguments == 'Y') 53: { 54: printf("\n P->R "); 55: 56: if ((*s_etat_processus).langue == 'F') 57: { 58: printf("(coordonnées polaires vers cartésiennes)\n\n"); 59: } 60: else 61: { 62: printf("(polar to cartesian coordinates)\n\n"); 63: } 64: 65: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL); 66: printf("-> 1: %s\n\n", d_CPL); 67: 68: printf(" 1: %s, %s\n", d_NOM, d_ALG); 69: printf("-> 1: %s\n\n", d_ALG); 70: 71: printf(" 1: %s\n", d_RPN); 72: printf("-> 1: %s\n", d_RPN); 73: 74: return; 75: } 76: else if ((*s_etat_processus).test_instruction == 'Y') 77: { 78: (*s_etat_processus).nombre_arguments = -1; 79: return; 80: } 81: 82: if (test_cfsf(s_etat_processus, 31) == d_vrai) 83: { 84: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 85: { 86: return; 87: } 88: } 89: 90: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 91: &s_objet_argument) == d_erreur) 92: { 93: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 94: return; 95: } 96: 97: /* 98: -------------------------------------------------------------------------------- 99: Conversion d'un entier ou d'un réel 100: -------------------------------------------------------------------------------- 101: */ 102: 103: if (((*s_objet_argument).type == INT) || 104: ((*s_objet_argument).type == REL)) 105: { 106: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) 107: { 108: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 109: return; 110: } 111: 112: if ((*s_objet_argument).type == INT) 113: { 114: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle 115: = (*((integer8 *) (*s_objet_argument).objet)); 116: } 117: else 118: { 119: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle 120: = (*((real8 *) (*s_objet_argument).objet)); 121: } 122: 123: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_imaginaire 124: = 0; 125: } 126: 127: /* 128: -------------------------------------------------------------------------------- 129: Conversion d'un complexe 130: -------------------------------------------------------------------------------- 131: */ 132: 133: else if ((*s_objet_argument).type == CPL) 134: { 135: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) 136: { 137: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 138: return; 139: } 140: 141: angle = (*((struct_complexe16 *) (*s_objet_argument).objet)) 142: .partie_imaginaire; 143: 144: if (test_cfsf(s_etat_processus, 60) == d_faux) 145: { 146: conversion_degres_vers_radians(&angle); 147: } 148: 149: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle = 150: (*((struct_complexe16 *) (*s_objet_argument).objet)) 151: .partie_reelle * cos(angle); 152: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_imaginaire = 153: (*((struct_complexe16 *) (*s_objet_argument).objet)) 154: .partie_reelle * sin(angle); 155: } 156: 157: /* 158: -------------------------------------------------------------------------------- 159: Conversion d'un nom 160: -------------------------------------------------------------------------------- 161: */ 162: 163: else if ((*s_objet_argument).type == NOM) 164: { 165: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL) 166: { 167: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 168: return; 169: } 170: 171: if (((*s_objet_resultat).objet = 172: allocation_maillon(s_etat_processus)) == NULL) 173: { 174: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 175: return; 176: } 177: 178: l_element_courant = (*s_objet_resultat).objet; 179: 180: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 181: == NULL) 182: { 183: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 184: return; 185: } 186: 187: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 188: .nombre_arguments = 0; 189: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 190: .fonction = instruction_vers_niveau_superieur; 191: 192: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 193: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 194: { 195: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 196: return; 197: } 198: 199: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 200: .nom_fonction, "<<"); 201: 202: if (((*l_element_courant).suivant = 203: allocation_maillon(s_etat_processus)) == NULL) 204: { 205: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 206: return; 207: } 208: 209: l_element_courant = (*l_element_courant).suivant; 210: (*l_element_courant).donnee = s_objet_argument; 211: 212: if (((*l_element_courant).suivant = 213: allocation_maillon(s_etat_processus)) == NULL) 214: { 215: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 216: return; 217: } 218: 219: l_element_courant = (*l_element_courant).suivant; 220: 221: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 222: == NULL) 223: { 224: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 225: return; 226: } 227: 228: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 229: .nombre_arguments = 1; 230: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 231: .fonction = instruction_p_vers_r; 232: 233: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 234: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) 235: { 236: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 237: return; 238: } 239: 240: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 241: .nom_fonction, "P->R"); 242: 243: if (((*l_element_courant).suivant = 244: allocation_maillon(s_etat_processus)) == NULL) 245: { 246: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 247: return; 248: } 249: 250: l_element_courant = (*l_element_courant).suivant; 251: 252: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 253: == NULL) 254: { 255: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 256: return; 257: } 258: 259: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 260: .nombre_arguments = 0; 261: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 262: .fonction = instruction_vers_niveau_inferieur; 263: 264: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 265: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 266: { 267: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 268: return; 269: } 270: 271: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 272: .nom_fonction, ">>"); 273: 274: (*l_element_courant).suivant = NULL; 275: s_objet_argument = NULL; 276: } 277: 278: /* 279: -------------------------------------------------------------------------------- 280: Conversion d'une expression 281: -------------------------------------------------------------------------------- 282: */ 283: 284: else if (((*s_objet_argument).type == ALG) || 285: ((*s_objet_argument).type == RPN)) 286: { 287: if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument, 288: 'N')) == NULL) 289: { 290: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 291: return; 292: } 293: 294: l_element_courant = (struct_liste_chainee *) 295: (*s_copie_argument).objet; 296: l_element_precedent = l_element_courant; 297: 298: while((*l_element_courant).suivant != NULL) 299: { 300: l_element_precedent = l_element_courant; 301: l_element_courant = (*l_element_courant).suivant; 302: } 303: 304: if (((*l_element_precedent).suivant = 305: allocation_maillon(s_etat_processus)) == NULL) 306: { 307: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 308: return; 309: } 310: 311: if (((*(*l_element_precedent).suivant).donnee = 312: allocation(s_etat_processus, FCT)) == NULL) 313: { 314: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 315: return; 316: } 317: 318: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 319: .donnee).objet)).nombre_arguments = 1; 320: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 321: .donnee).objet)).fonction = instruction_p_vers_r; 322: 323: if (((*((struct_fonction *) (*(*(*l_element_precedent) 324: .suivant).donnee).objet)).nom_fonction = 325: malloc(5 * sizeof(unsigned char))) == NULL) 326: { 327: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 328: return; 329: } 330: 331: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 332: .suivant).donnee).objet)).nom_fonction, "P->R"); 333: 334: (*(*l_element_precedent).suivant).suivant = l_element_courant; 335: 336: s_objet_resultat = s_copie_argument; 337: } 338: 339: /* 340: -------------------------------------------------------------------------------- 341: Réalisation impossible de la fonction P->R 342: -------------------------------------------------------------------------------- 343: */ 344: 345: else 346: { 347: liberation(s_etat_processus, s_objet_argument); 348: 349: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 350: return; 351: } 352: 353: liberation(s_etat_processus, s_objet_argument); 354: 355: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 356: s_objet_resultat) == d_erreur) 357: { 358: return; 359: } 360: 361: return; 362: } 363: 364: 365: /* 366: ================================================================================ 367: Fonction 'put' 368: ================================================================================ 369: Entrées : pointeur sur une structure struct_processus 370: -------------------------------------------------------------------------------- 371: Sorties : 372: -------------------------------------------------------------------------------- 373: Effets de bord : néant 374: ================================================================================ 375: */ 376: 377: void 378: instruction_put(struct_processus *s_etat_processus) 379: { 380: logical1 variable_partagee; 381: 382: struct_liste_chainee *l_element_courant; 383: 384: struct_objet *s_copie_3; 385: struct_objet *s_copie_4; 386: struct_objet *s_objet_1; 387: struct_objet *s_objet_2; 388: struct_objet *s_objet_3; 389: struct_objet *s_objet_4; 390: struct_objet *s_objet_element; 391: 392: unsigned long i; 393: unsigned long indice_i; 394: unsigned long indice_j; 395: unsigned long j; 396: unsigned long nombre_dimensions; 397: 398: void *tampon; 399: 400: (*s_etat_processus).erreur_execution = d_ex; 401: 402: if ((*s_etat_processus).affichage_arguments == 'Y') 403: { 404: printf("\n PUT "); 405: 406: if ((*s_etat_processus).langue == 'F') 407: { 408: printf("(change un élément)\n\n"); 409: } 410: else 411: { 412: printf("(change element)\n\n"); 413: } 414: 415: printf(" 3: %s, %s, %s\n", d_VIN, d_VRL, d_VCX); 416: printf(" 2: %s\n", d_LST); 417: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL); 418: printf("-> 1: %s, %s, %s\n\n", d_VIN, d_VRL, d_VCX); 419: 420: printf(" 3: %s, %s, %s\n", d_MIN, d_MRL, d_MCX); 421: printf(" 2: %s\n", d_LST); 422: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL); 423: printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX); 424: 425: printf(" 3: %s\n", d_LST); 426: printf(" 2: %s\n", d_INT); 427: printf(" 1: %s, %s, %s, %s, %s, %s,\n" 428: " %s, %s, %s, %s, %s,\n" 429: " %s, %s, %s, %s, %s,\n" 430: " %s, %s, %s, %s,\n" 431: " %s, %s\n", 432: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 433: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, 434: d_SQL, d_SLB, d_PRC, d_MTX); 435: printf("-> 1: %s\n\n", d_LST); 436: 437: printf(" 3: %s\n", d_TAB); 438: printf(" 2: %s\n", d_LST); 439: printf(" 1: %s, %s, %s, %s, %s, %s,\n" 440: " %s, %s, %s, %s, %s,\n" 441: " %s, %s, %s, %s, %s,\n" 442: " %s, %s, %s, %s,\n" 443: " %s, %s\n", 444: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 445: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, 446: d_SQL, d_SLB, d_PRC, d_MTX); 447: printf("-> 1: %s\n\n", d_TAB); 448: 449: printf(" 3: %s\n", d_NOM); 450: printf(" 2: %s, %s\n", d_LST, d_INT); 451: printf(" 1: %s, %s, %s, %s, %s, %s,\n" 452: " %s, %s, %s, %s, %s,\n" 453: " %s, %s, %s, %s, %s,\n" 454: " %s, %s, %s, %s,\n" 455: " %s, %s\n", 456: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 457: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, 458: d_SQL, d_SLB, d_PRC, d_MTX); 459: 460: return; 461: } 462: else if ((*s_etat_processus).test_instruction == 'Y') 463: { 464: (*s_etat_processus).nombre_arguments = -1; 465: return; 466: } 467: 468: if (test_cfsf(s_etat_processus, 31) == d_vrai) 469: { 470: if (empilement_pile_last(s_etat_processus, 3) == d_erreur) 471: { 472: return; 473: } 474: } 475: 476: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 477: &s_objet_1) == d_erreur) 478: { 479: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 480: return; 481: } 482: 483: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 484: &s_objet_2) == d_erreur) 485: { 486: liberation(s_etat_processus, s_objet_1); 487: 488: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 489: return; 490: } 491: 492: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 493: &s_objet_3) == d_erreur) 494: { 495: liberation(s_etat_processus, s_objet_1); 496: liberation(s_etat_processus, s_objet_2); 497: 498: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 499: return; 500: } 501: 502: /* 503: -------------------------------------------------------------------------------- 504: Traitement des éléments des vecteurs 505: -------------------------------------------------------------------------------- 506: */ 507: 508: if (((*s_objet_3).type == VIN) || 509: ((*s_objet_3).type == VRL) || 510: ((*s_objet_3).type == VCX)) 511: { 512: if ((*s_objet_2).type != LST) 513: { 514: liberation(s_etat_processus, s_objet_1); 515: liberation(s_etat_processus, s_objet_2); 516: liberation(s_etat_processus, s_objet_3); 517: 518: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 519: return; 520: } 521: 522: l_element_courant = (*s_objet_2).objet; 523: nombre_dimensions = 0; 524: 525: while(l_element_courant != NULL) 526: { 527: nombre_dimensions++; 528: l_element_courant = (*l_element_courant).suivant; 529: } 530: 531: if (nombre_dimensions != 1) 532: { 533: liberation(s_etat_processus, s_objet_1); 534: liberation(s_etat_processus, s_objet_2); 535: liberation(s_etat_processus, s_objet_3); 536: 537: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 538: return; 539: } 540: 541: l_element_courant = (*s_objet_2).objet; 542: 543: if ((*(*l_element_courant).donnee).type != INT) 544: { 545: liberation(s_etat_processus, s_objet_1); 546: liberation(s_etat_processus, s_objet_2); 547: liberation(s_etat_processus, s_objet_3); 548: 549: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 550: return; 551: } 552: 553: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0) 554: { 555: liberation(s_etat_processus, s_objet_1); 556: liberation(s_etat_processus, s_objet_2); 557: liberation(s_etat_processus, s_objet_3); 558: 559: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 560: return; 561: } 562: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) > 563: (integer8) (*((struct_vecteur *) (*s_objet_3).objet)).taille) 564: { 565: liberation(s_etat_processus, s_objet_1); 566: liberation(s_etat_processus, s_objet_2); 567: liberation(s_etat_processus, s_objet_3); 568: 569: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 570: return; 571: } 572: 573: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet)); 574: 575: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'Q')) == NULL) 576: { 577: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 578: return; 579: } 580: 581: liberation(s_etat_processus, s_objet_3); 582: s_objet_3 = s_copie_3; 583: 584: if ((*s_objet_3).type == VIN) 585: { 586: /* 587: * Vecteur d'entiers 588: */ 589: 590: if ((*s_objet_1).type == INT) 591: { 592: /* 593: * Aucune conversion de type 594: */ 595: 596: ((integer8 *) (*((struct_vecteur *) (*s_objet_3).objet)) 597: .tableau)[indice_i - 1] = (*((integer8 *) 598: (*s_objet_1).objet)); 599: } 600: else if ((*s_objet_1).type == REL) 601: { 602: /* 603: * Conversion du vecteur en vecteur réel 604: */ 605: 606: tampon = (void *) ((integer8 *) (*((struct_vecteur *) 607: (*s_objet_3).objet)).tableau); 608: 609: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'R'; 610: (*s_objet_3).type = VRL; 611: 612: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau 613: = malloc((*((struct_vecteur *) 614: (*s_objet_3).objet)).taille * sizeof(real8))) 615: == NULL) 616: { 617: (*s_etat_processus).erreur_systeme = 618: d_es_allocation_memoire; 619: return; 620: } 621: 622: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet)) 623: .taille; i++) 624: { 625: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet)) 626: .tableau)[i] = (real8) (((integer8 *) tampon)[i]); 627: } 628: 629: free((integer8 *) tampon); 630: 631: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet)) 632: .tableau)[indice_i - 1] = (*((real8 *) 633: (*s_objet_1).objet)); 634: } 635: else if ((*s_objet_1).type == CPL) 636: { 637: /* 638: * Conversion du vecteur en vecteur complexe 639: */ 640: 641: tampon = (void *) ((integer8 *) (*((struct_vecteur *) 642: (*s_objet_3).objet)).tableau); 643: 644: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'C'; 645: (*s_objet_3).type = VCX; 646: 647: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau 648: = malloc((*((struct_vecteur *) 649: (*s_objet_3).objet)).taille * 650: sizeof(struct_complexe16))) == NULL) 651: { 652: (*s_etat_processus).erreur_systeme = 653: d_es_allocation_memoire; 654: return; 655: } 656: 657: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet)) 658: .taille; i++) 659: { 660: ((struct_complexe16 *) (*((struct_vecteur *) 661: (*s_objet_3).objet)).tableau)[i].partie_reelle = 662: (real8) (((integer8 *) tampon)[i]); 663: ((struct_complexe16 *) (*((struct_vecteur *) 664: (*s_objet_3).objet)).tableau)[i] 665: .partie_imaginaire = (real8) 0; 666: } 667: 668: free((integer8 *) tampon); 669: 670: ((struct_complexe16 *) (*((struct_vecteur *) 671: (*s_objet_3).objet)).tableau)[indice_i - 1] 672: .partie_reelle = (*((struct_complexe16 *) 673: (*s_objet_1).objet)).partie_reelle; 674: ((struct_complexe16 *) (*((struct_vecteur *) 675: (*s_objet_3).objet)).tableau)[indice_i - 1] 676: .partie_imaginaire = (*((struct_complexe16 *) 677: (*s_objet_1).objet)).partie_imaginaire; 678: } 679: else 680: { 681: liberation(s_etat_processus, s_objet_1); 682: liberation(s_etat_processus, s_objet_2); 683: liberation(s_etat_processus, s_objet_3); 684: 685: (*s_etat_processus).erreur_execution = 686: d_ex_erreur_type_argument; 687: return; 688: } 689: } 690: else if ((*s_objet_3).type == VRL) 691: { 692: /* 693: * Vecteur de réels 694: */ 695: 696: if ((*s_objet_1).type == INT) 697: { 698: /* 699: * Conversion de l'élément à insérer en réel 700: */ 701: 702: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet)) 703: .tableau)[indice_i - 1] = (real8) (*((integer8 *) 704: (*s_objet_1).objet)); 705: } 706: else if ((*s_objet_1).type == REL) 707: { 708: /* 709: * Aucune conversion de type 710: */ 711: 712: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet)) 713: .tableau)[indice_i - 1] = (*((real8 *) 714: (*s_objet_1).objet)); 715: } 716: else if ((*s_objet_1).type == CPL) 717: { 718: /* 719: * Conversion du vecteur en vecteur complexe 720: */ 721: 722: tampon = (void *) ((integer8 *) (*((struct_vecteur *) 723: (*s_objet_3).objet)).tableau); 724: 725: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'C'; 726: (*s_objet_3).type = VCX; 727: 728: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau 729: = malloc((*((struct_vecteur *) 730: (*s_objet_3).objet)).taille * 731: sizeof(struct_complexe16))) == NULL) 732: { 733: (*s_etat_processus).erreur_systeme = 734: d_es_allocation_memoire; 735: return; 736: } 737: 738: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet)) 739: .taille; i++) 740: { 741: ((struct_complexe16 *) (*((struct_vecteur *) 742: (*s_objet_3).objet)).tableau)[i].partie_reelle = 743: ((real8 *) tampon)[i]; 744: ((struct_complexe16 *) (*((struct_vecteur *) 745: (*s_objet_3).objet)).tableau)[i] 746: .partie_imaginaire = (real8) 0; 747: } 748: 749: free((real8 *) tampon); 750: 751: ((struct_complexe16 *) (*((struct_vecteur *) 752: (*s_objet_3).objet)).tableau)[indice_i - 1] 753: .partie_reelle = (*((struct_complexe16 *) 754: (*s_objet_1).objet)).partie_reelle; 755: ((struct_complexe16 *) (*((struct_vecteur *) 756: (*s_objet_3).objet)).tableau)[indice_i - 1] 757: .partie_imaginaire = (*((struct_complexe16 *) 758: (*s_objet_1).objet)).partie_imaginaire; 759: } 760: else 761: { 762: liberation(s_etat_processus, s_objet_1); 763: liberation(s_etat_processus, s_objet_2); 764: liberation(s_etat_processus, s_objet_3); 765: 766: (*s_etat_processus).erreur_execution = 767: d_ex_erreur_type_argument; 768: return; 769: } 770: } 771: else 772: { 773: /* 774: * Vecteur de complexes 775: */ 776: 777: if ((*s_objet_1).type == INT) 778: { 779: /* 780: * Conversion de l'élément à insérer en complexe 781: */ 782: 783: ((struct_complexe16 *) (*((struct_vecteur *) 784: (*s_objet_3).objet)).tableau)[indice_i - 1] 785: .partie_reelle = (real8) (*((integer8 *) 786: (*s_objet_1).objet)); 787: ((struct_complexe16 *) (*((struct_vecteur *) 788: (*s_objet_3).objet)).tableau)[indice_i - 1] 789: .partie_imaginaire = (real8) 0; 790: } 791: else if ((*s_objet_1).type == REL) 792: { 793: /* 794: * Conversion de l'élément à insérer en complexe 795: */ 796: 797: ((struct_complexe16 *) (*((struct_vecteur *) 798: (*s_objet_3).objet)).tableau)[indice_i - 1] 799: .partie_reelle = (*((real8 *) (*s_objet_1).objet)); 800: ((struct_complexe16 *) (*((struct_vecteur *) 801: (*s_objet_3).objet)).tableau)[indice_i - 1] 802: .partie_imaginaire = (real8) 0; 803: } 804: else if ((*s_objet_1).type == CPL) 805: { 806: /* 807: * Aucune conversion de type 808: */ 809: 810: ((struct_complexe16 *) (*((struct_vecteur *) 811: (*s_objet_3).objet)).tableau)[indice_i - 1] 812: .partie_reelle = (*((struct_complexe16 *) 813: (*s_objet_1).objet)).partie_reelle; 814: ((struct_complexe16 *) (*((struct_vecteur *) 815: (*s_objet_3).objet)).tableau)[indice_i - 1] 816: .partie_imaginaire = (*((struct_complexe16 *) 817: (*s_objet_1).objet)).partie_imaginaire; 818: } 819: else 820: { 821: liberation(s_etat_processus, s_objet_1); 822: liberation(s_etat_processus, s_objet_2); 823: liberation(s_etat_processus, s_objet_3); 824: 825: (*s_etat_processus).erreur_execution = 826: d_ex_erreur_type_argument; 827: return; 828: } 829: } 830: 831: liberation(s_etat_processus, s_objet_1); 832: liberation(s_etat_processus, s_objet_2); 833: 834: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 835: s_objet_3) == d_erreur) 836: { 837: return; 838: } 839: } 840: 841: /* 842: -------------------------------------------------------------------------------- 843: Traitement des éléments des matrices 844: -------------------------------------------------------------------------------- 845: */ 846: 847: else if (((*s_objet_3).type == MIN) || 848: ((*s_objet_3).type == MRL) || 849: ((*s_objet_3).type == MCX)) 850: { 851: if ((*s_objet_2).type != LST) 852: { 853: liberation(s_etat_processus, s_objet_1); 854: liberation(s_etat_processus, s_objet_2); 855: liberation(s_etat_processus, s_objet_3); 856: 857: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 858: return; 859: } 860: 861: l_element_courant = (*s_objet_2).objet; 862: nombre_dimensions = 0; 863: 864: while(l_element_courant != NULL) 865: { 866: nombre_dimensions++; 867: l_element_courant = (*l_element_courant).suivant; 868: } 869: 870: if (nombre_dimensions != 2) 871: { 872: liberation(s_etat_processus, s_objet_1); 873: liberation(s_etat_processus, s_objet_2); 874: liberation(s_etat_processus, s_objet_3); 875: 876: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 877: return; 878: } 879: 880: l_element_courant = (*s_objet_2).objet; 881: 882: indice_i = 0; 883: indice_j = 0; 884: 885: while(l_element_courant != NULL) 886: { 887: if ((*(*l_element_courant).donnee).type != INT) 888: { 889: liberation(s_etat_processus, s_objet_1); 890: liberation(s_etat_processus, s_objet_2); 891: liberation(s_etat_processus, s_objet_3); 892: 893: (*s_etat_processus).erreur_execution = 894: d_ex_erreur_type_argument; 895: return; 896: } 897: 898: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0) 899: { 900: liberation(s_etat_processus, s_objet_1); 901: liberation(s_etat_processus, s_objet_2); 902: liberation(s_etat_processus, s_objet_3); 903: 904: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 905: return; 906: } 907: 908: if (indice_i == 0) 909: { 910: indice_i = (*((integer8 *) 911: (*(*l_element_courant).donnee).objet)); 912: } 913: else 914: { 915: indice_j = (*((integer8 *) 916: (*(*l_element_courant).donnee).objet)); 917: } 918: 919: l_element_courant = (*l_element_courant).suivant; 920: } 921: 922: if ((indice_i > (*((struct_matrice *) (*s_objet_3).objet)) 923: .nombre_lignes) || (indice_j > (*((struct_matrice *) 924: (*s_objet_3).objet)).nombre_colonnes)) 925: { 926: liberation(s_etat_processus, s_objet_1); 927: liberation(s_etat_processus, s_objet_2); 928: liberation(s_etat_processus, s_objet_3); 929: 930: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 931: return; 932: } 933: 934: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'Q')) == NULL) 935: { 936: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 937: return; 938: } 939: 940: liberation(s_etat_processus, s_objet_3); 941: s_objet_3 = s_copie_3; 942: 943: if ((*s_objet_3).type == MIN) 944: { 945: /* 946: * Matrice d'entiers 947: */ 948: 949: if ((*s_objet_1).type == INT) 950: { 951: /* 952: * Aucune conversion de type 953: */ 954: 955: ((integer8 **) (*((struct_matrice *) (*s_objet_3).objet)) 956: .tableau)[indice_i - 1][indice_j - 1] = 957: (*((integer8 *) (*s_objet_1).objet)); 958: } 959: else if ((*s_objet_1).type == REL) 960: { 961: /* 962: * Conversion de la matrice en matrice réelle 963: */ 964: 965: tampon = (void *) ((integer8 **) (*((struct_matrice *) 966: (*s_objet_3).objet)).tableau); 967: 968: (*((struct_matrice *) (*s_objet_3).objet)).type = 'R'; 969: (*s_objet_3).type = MRL; 970: 971: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau 972: = malloc((*((struct_matrice *) 973: (*s_objet_3).objet)).nombre_lignes * sizeof(real8 *))) 974: == NULL) 975: { 976: (*s_etat_processus).erreur_systeme = 977: d_es_allocation_memoire; 978: return; 979: } 980: 981: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet)) 982: .nombre_lignes; i++) 983: { 984: if ((((real8 **) (*((struct_matrice *) 985: (*s_objet_3).objet)).tableau)[i] 986: = malloc((*((struct_matrice *) 987: (*s_objet_3).objet)).nombre_colonnes * 988: sizeof(real8))) == NULL) 989: { 990: (*s_etat_processus).erreur_systeme = 991: d_es_allocation_memoire; 992: return; 993: } 994: 995: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet)) 996: .nombre_colonnes; j++) 997: { 998: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet)) 999: .tableau)[i][j] = (real8) (((integer8 **) 1000: tampon)[i][j]); 1001: } 1002: 1003: free(((integer8 **) tampon)[i]); 1004: } 1005: 1006: free((integer8 **) tampon); 1007: 1008: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet)) 1009: .tableau)[indice_i - 1][indice_j - 1] = (*((real8 *) 1010: (*s_objet_1).objet)); 1011: } 1012: else if ((*s_objet_1).type == CPL) 1013: { 1014: /* 1015: * Conversion de la matrice en matrice complexe 1016: */ 1017: 1018: tampon = (void *) ((integer8 **) (*((struct_matrice *) 1019: (*s_objet_3).objet)).tableau); 1020: 1021: (*((struct_matrice *) (*s_objet_3).objet)).type = 'C'; 1022: (*s_objet_3).type = MCX; 1023: 1024: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau 1025: = malloc((*((struct_matrice *) 1026: (*s_objet_3).objet)).nombre_lignes * 1027: sizeof(struct_complexe16 *))) == NULL) 1028: { 1029: (*s_etat_processus).erreur_systeme = 1030: d_es_allocation_memoire; 1031: return; 1032: } 1033: 1034: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet)) 1035: .nombre_lignes; i++) 1036: { 1037: if ((((struct_complexe16 **) (*((struct_matrice *) 1038: (*s_objet_3).objet)).tableau)[i] 1039: = malloc((*((struct_matrice *) 1040: (*s_objet_3).objet)).nombre_colonnes * 1041: sizeof(struct_complexe16))) == NULL) 1042: { 1043: (*s_etat_processus).erreur_systeme = 1044: d_es_allocation_memoire; 1045: return; 1046: } 1047: 1048: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet)) 1049: .nombre_colonnes; j++) 1050: { 1051: ((struct_complexe16 **) (*((struct_matrice *) 1052: (*s_objet_3).objet)).tableau)[i][j] 1053: .partie_reelle = (real8) (((integer8 **) 1054: tampon)[i][j]); 1055: ((struct_complexe16 **) (*((struct_matrice *) 1056: (*s_objet_3).objet)).tableau)[i][j] 1057: .partie_imaginaire = (real8) 0; 1058: } 1059: 1060: free(((integer8 **) tampon)[i]); 1061: } 1062: 1063: free((integer8 **) tampon); 1064: 1065: ((struct_complexe16 **) (*((struct_matrice *) 1066: (*s_objet_3).objet)).tableau)[indice_i - 1] 1067: [indice_j - 1].partie_reelle = (*((struct_complexe16 *) 1068: (*s_objet_1).objet)).partie_reelle; 1069: ((struct_complexe16 **) (*((struct_matrice *) 1070: (*s_objet_3).objet)).tableau)[indice_i - 1] 1071: [indice_j - 1].partie_imaginaire = 1072: (*((struct_complexe16 *) 1073: (*s_objet_1).objet)).partie_imaginaire; 1074: } 1075: else 1076: { 1077: liberation(s_etat_processus, s_objet_1); 1078: liberation(s_etat_processus, s_objet_2); 1079: liberation(s_etat_processus, s_objet_3); 1080: 1081: (*s_etat_processus).erreur_execution = 1082: d_ex_erreur_type_argument; 1083: return; 1084: } 1085: } 1086: else if ((*s_objet_3).type == MRL) 1087: { 1088: /* 1089: * Matrice de réels 1090: */ 1091: 1092: if ((*s_objet_1).type == INT) 1093: { 1094: /* 1095: * Conversion de l'élément à insérer en réel 1096: */ 1097: 1098: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet)) 1099: .tableau)[indice_i - 1][indice_j - 1] = 1100: (real8) (*((integer8 *) (*s_objet_1).objet)); 1101: } 1102: else if ((*s_objet_1).type == REL) 1103: { 1104: /* 1105: * Aucune conversion de type 1106: */ 1107: 1108: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet)) 1109: .tableau)[indice_i - 1][indice_j - 1] = (*((real8 *) 1110: (*s_objet_1).objet)); 1111: } 1112: else if ((*s_objet_1).type == CPL) 1113: { 1114: /* 1115: * Conversion de la matrice en matrice complexe 1116: */ 1117: 1118: tampon = (void *) ((real8 **) (*((struct_matrice *) 1119: (*s_objet_3).objet)).tableau); 1120: 1121: (*((struct_matrice *) (*s_objet_3).objet)).type = 'C'; 1122: (*s_objet_3).type = MCX; 1123: 1124: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau 1125: = malloc((*((struct_matrice *) 1126: (*s_objet_3).objet)).nombre_lignes * 1127: sizeof(struct_complexe16 *))) == NULL) 1128: { 1129: (*s_etat_processus).erreur_systeme = 1130: d_es_allocation_memoire; 1131: return; 1132: } 1133: 1134: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet)) 1135: .nombre_lignes; i++) 1136: { 1137: if ((((struct_complexe16 **) (*((struct_matrice *) 1138: (*s_objet_3).objet)).tableau)[i] 1139: = malloc((*((struct_matrice *) 1140: (*s_objet_3).objet)).nombre_colonnes * 1141: sizeof(struct_complexe16))) == NULL) 1142: { 1143: (*s_etat_processus).erreur_systeme = 1144: d_es_allocation_memoire; 1145: return; 1146: } 1147: 1148: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet)) 1149: .nombre_colonnes; j++) 1150: { 1151: ((struct_complexe16 **) (*((struct_matrice *) 1152: (*s_objet_3).objet)).tableau)[i][j] 1153: .partie_reelle = (((real8 **) 1154: tampon)[i][j]); 1155: ((struct_complexe16 **) (*((struct_matrice *) 1156: (*s_objet_3).objet)).tableau)[i][j] 1157: .partie_imaginaire = (real8) 0; 1158: } 1159: 1160: free(((integer8 **) tampon)[i]); 1161: } 1162: 1163: free((integer8 **) tampon); 1164: 1165: ((struct_complexe16 **) (*((struct_matrice *) 1166: (*s_objet_3).objet)).tableau)[indice_i - 1] 1167: [indice_j - 1].partie_reelle = (*((struct_complexe16 *) 1168: (*s_objet_1).objet)).partie_reelle; 1169: ((struct_complexe16 **) (*((struct_matrice *) 1170: (*s_objet_3).objet)).tableau)[indice_i - 1] 1171: [indice_j - 1].partie_imaginaire = 1172: (*((struct_complexe16 *) 1173: (*s_objet_1).objet)).partie_imaginaire; 1174: } 1175: else 1176: { 1177: liberation(s_etat_processus, s_objet_1); 1178: liberation(s_etat_processus, s_objet_2); 1179: liberation(s_etat_processus, s_objet_3); 1180: 1181: (*s_etat_processus).erreur_execution = 1182: d_ex_erreur_type_argument; 1183: return; 1184: } 1185: } 1186: else 1187: { 1188: /* 1189: * Matrice de complexes 1190: */ 1191: 1192: if ((*s_objet_1).type == INT) 1193: { 1194: /* 1195: * Conversion de l'élément à insérer en complexe 1196: */ 1197: 1198: ((struct_complexe16 **) (*((struct_matrice *) 1199: (*s_objet_3).objet)).tableau)[indice_i - 1] 1200: [indice_j - 1].partie_reelle = (real8) (*((integer8 *) 1201: (*s_objet_1).objet)); 1202: ((struct_complexe16 **) (*((struct_matrice *) 1203: (*s_objet_3).objet)).tableau)[indice_i - 1] 1204: [indice_j - 1].partie_imaginaire = (real8) 0; 1205: } 1206: else if ((*s_objet_1).type == REL) 1207: { 1208: /* 1209: * Conversion de l'élément à insérer en complexe 1210: */ 1211: 1212: ((struct_complexe16 **) (*((struct_matrice *) 1213: (*s_objet_3).objet)).tableau)[indice_i - 1] 1214: [indice_j - 1].partie_reelle = 1215: (*((real8 *) (*s_objet_1).objet)); 1216: ((struct_complexe16 **) (*((struct_matrice *) 1217: (*s_objet_3).objet)).tableau)[indice_i - 1] 1218: [indice_j - 1].partie_imaginaire = (real8) 0; 1219: } 1220: else if ((*s_objet_1).type == CPL) 1221: { 1222: /* 1223: * Aucune conversion de type 1224: */ 1225: 1226: ((struct_complexe16 **) (*((struct_matrice *) 1227: (*s_objet_3).objet)).tableau)[indice_i - 1] 1228: [indice_j - 1].partie_reelle = (*((struct_complexe16 *) 1229: (*s_objet_1).objet)).partie_reelle; 1230: ((struct_complexe16 **) (*((struct_matrice *) 1231: (*s_objet_3).objet)).tableau)[indice_i - 1] 1232: [indice_j - 1].partie_imaginaire = 1233: (*((struct_complexe16 *) 1234: (*s_objet_1).objet)).partie_imaginaire; 1235: } 1236: else 1237: { 1238: liberation(s_etat_processus, s_objet_1); 1239: liberation(s_etat_processus, s_objet_2); 1240: liberation(s_etat_processus, s_objet_3); 1241: 1242: (*s_etat_processus).erreur_execution = 1243: d_ex_erreur_type_argument; 1244: return; 1245: } 1246: } 1247: 1248: liberation(s_etat_processus, s_objet_1); 1249: liberation(s_etat_processus, s_objet_2); 1250: 1251: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1252: s_objet_3) == d_erreur) 1253: { 1254: return; 1255: } 1256: } 1257: 1258: /* 1259: -------------------------------------------------------------------------------- 1260: Traitement des éléments des listes 1261: -------------------------------------------------------------------------------- 1262: */ 1263: 1264: else if ((*s_objet_3).type == LST) 1265: { 1266: if ((*s_objet_2).type != INT) 1267: { 1268: liberation(s_etat_processus, s_objet_1); 1269: liberation(s_etat_processus, s_objet_2); 1270: liberation(s_etat_processus, s_objet_3); 1271: 1272: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1273: return; 1274: } 1275: 1276: indice_i = (*((integer8 *) (*s_objet_2).objet)); 1277: indice_j = 1; 1278: 1279: if ((*s_objet_3).nombre_occurrences > 1) 1280: { 1281: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'N')) 1282: == NULL) 1283: { 1284: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1285: return; 1286: } 1287: 1288: liberation(s_etat_processus, s_objet_3); 1289: s_objet_3 = s_copie_3; 1290: } 1291: 1292: l_element_courant = (*s_objet_3).objet; 1293: 1294: while((l_element_courant != NULL) && (indice_j != indice_i)) 1295: { 1296: l_element_courant = (*l_element_courant).suivant; 1297: indice_j++; 1298: } 1299: 1300: if (l_element_courant != NULL) 1301: { 1302: liberation(s_etat_processus, (*l_element_courant).donnee); 1303: (*l_element_courant).donnee = s_objet_1; 1304: } 1305: else 1306: { 1307: liberation(s_etat_processus, s_objet_1); 1308: liberation(s_etat_processus, s_objet_2); 1309: liberation(s_etat_processus, s_objet_3); 1310: 1311: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 1312: return; 1313: } 1314: 1315: liberation(s_etat_processus, s_objet_2); 1316: 1317: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1318: s_objet_3) == d_erreur) 1319: { 1320: return; 1321: } 1322: } 1323: 1324: /* 1325: -------------------------------------------------------------------------------- 1326: Traitement des éléments des tables 1327: -------------------------------------------------------------------------------- 1328: */ 1329: 1330: else if ((*s_objet_3).type == TBL) 1331: { 1332: if ((*s_objet_2).type != LST) 1333: { 1334: liberation(s_etat_processus, s_objet_1); 1335: liberation(s_etat_processus, s_objet_2); 1336: liberation(s_etat_processus, s_objet_3); 1337: 1338: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1339: return; 1340: } 1341: 1342: if ((*s_objet_3).nombre_occurrences > 1) 1343: { 1344: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'N')) 1345: == NULL) 1346: { 1347: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1348: return; 1349: } 1350: 1351: liberation(s_etat_processus, s_objet_3); 1352: s_objet_3 = s_copie_3; 1353: } 1354: 1355: s_objet_element = s_objet_3; 1356: l_element_courant = (*s_objet_2).objet; 1357: indice_i = 0; 1358: 1359: while(l_element_courant != NULL) 1360: { 1361: if ((*(*l_element_courant).donnee).type != INT) 1362: { 1363: liberation(s_etat_processus, s_objet_1); 1364: liberation(s_etat_processus, s_objet_2); 1365: liberation(s_etat_processus, s_objet_3); 1366: 1367: (*s_etat_processus).erreur_execution = 1368: d_ex_erreur_type_argument; 1369: return; 1370: } 1371: 1372: if ((*s_objet_element).type != TBL) 1373: { 1374: liberation(s_etat_processus, s_objet_1); 1375: liberation(s_etat_processus, s_objet_2); 1376: liberation(s_etat_processus, s_objet_3); 1377: 1378: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 1379: return; 1380: } 1381: 1382: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet)); 1383: 1384: if ((indice_i < 1) || (indice_i > (*((struct_tableau *) 1385: (*s_objet_element).objet)).nombre_elements)) 1386: { 1387: liberation(s_etat_processus, s_objet_1); 1388: liberation(s_etat_processus, s_objet_2); 1389: liberation(s_etat_processus, s_objet_3); 1390: 1391: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 1392: return; 1393: } 1394: 1395: if ((*l_element_courant).suivant != NULL) 1396: { 1397: s_objet_element = (*((struct_tableau *) (*s_objet_element) 1398: .objet)).elements[indice_i - 1]; 1399: } 1400: 1401: l_element_courant = (*l_element_courant).suivant; 1402: } 1403: 1404: liberation(s_etat_processus, (*((struct_tableau *) 1405: (*s_objet_element).objet)).elements[indice_i - 1]); 1406: (*((struct_tableau *) (*s_objet_element).objet)).elements[indice_i - 1] 1407: = s_objet_1; 1408: 1409: liberation(s_etat_processus, s_objet_2); 1410: 1411: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1412: s_objet_3) == d_erreur) 1413: { 1414: return; 1415: } 1416: } 1417: 1418: /* 1419: -------------------------------------------------------------------------------- 1420: Traitement des noms 1421: -------------------------------------------------------------------------------- 1422: */ 1423: 1424: else if ((*s_objet_3).type == NOM) 1425: { 1426: variable_partagee = d_faux; 1427: 1428: if (recherche_variable(s_etat_processus, (*((struct_nom *) 1429: (*s_objet_3).objet)).nom) == d_faux) 1430: { 1431: (*s_etat_processus).erreur_systeme = d_es; 1432: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; 1433: 1434: liberation(s_etat_processus, s_objet_1); 1435: liberation(s_etat_processus, s_objet_2); 1436: liberation(s_etat_processus, s_objet_3); 1437: 1438: return; 1439: } 1440: 1441: if ((*(*s_etat_processus).pointeur_variable_courante) 1442: .variable_verrouillee == d_vrai) 1443: { 1444: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee; 1445: 1446: liberation(s_etat_processus, s_objet_1); 1447: liberation(s_etat_processus, s_objet_2); 1448: liberation(s_etat_processus, s_objet_3); 1449: 1450: return; 1451: } 1452: 1453: s_objet_4 = (*(*s_etat_processus).pointeur_variable_courante).objet; 1454: 1455: if (s_objet_4 == NULL) 1456: { 1457: if (pthread_mutex_lock(&((*(*s_etat_processus) 1458: .s_liste_variables_partagees).mutex)) != 0) 1459: { 1460: (*s_etat_processus).erreur_systeme = d_es_processus; 1461: return; 1462: } 1463: 1464: if (recherche_variable_partagee(s_etat_processus, 1465: (*(*s_etat_processus).pointeur_variable_courante).nom, 1466: (*(*s_etat_processus).pointeur_variable_courante) 1467: .variable_partagee, (*(*s_etat_processus) 1468: .pointeur_variable_courante).origine) == d_faux) 1469: { 1470: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1471: .s_liste_variables_partagees).mutex)) != 0) 1472: { 1473: (*s_etat_processus).erreur_systeme = d_es_processus; 1474: return; 1475: } 1476: 1477: (*s_etat_processus).erreur_systeme = d_es; 1478: (*s_etat_processus).erreur_execution = 1479: d_ex_variable_non_definie; 1480: 1481: liberation(s_etat_processus, s_objet_1); 1482: liberation(s_etat_processus, s_objet_2); 1483: liberation(s_etat_processus, s_objet_3); 1484: 1485: return; 1486: } 1487: 1488: s_objet_4 = (*(*s_etat_processus).s_liste_variables_partagees) 1489: .table[(*(*s_etat_processus).s_liste_variables_partagees) 1490: .position_variable].objet; 1491: variable_partagee = d_vrai; 1492: } 1493: 1494: if (((*s_objet_4).type == VIN) || 1495: ((*s_objet_4).type == VRL) || 1496: ((*s_objet_4).type == VCX)) 1497: { 1498: if ((*s_objet_2).type != LST) 1499: { 1500: if (variable_partagee == d_vrai) 1501: { 1502: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1503: .s_liste_variables_partagees).mutex)) != 0) 1504: { 1505: (*s_etat_processus).erreur_systeme = d_es_processus; 1506: return; 1507: } 1508: } 1509: 1510: liberation(s_etat_processus, s_objet_1); 1511: liberation(s_etat_processus, s_objet_2); 1512: liberation(s_etat_processus, s_objet_3); 1513: 1514: (*s_etat_processus).erreur_execution = 1515: d_ex_erreur_type_argument; 1516: return; 1517: } 1518: 1519: l_element_courant = (*s_objet_2).objet; 1520: nombre_dimensions = 0; 1521: 1522: while(l_element_courant != NULL) 1523: { 1524: nombre_dimensions++; 1525: l_element_courant = (*l_element_courant).suivant; 1526: } 1527: 1528: if (nombre_dimensions != 1) 1529: { 1530: if (variable_partagee == d_vrai) 1531: { 1532: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1533: .s_liste_variables_partagees).mutex)) != 0) 1534: { 1535: (*s_etat_processus).erreur_systeme = d_es_processus; 1536: return; 1537: } 1538: } 1539: 1540: liberation(s_etat_processus, s_objet_1); 1541: liberation(s_etat_processus, s_objet_2); 1542: liberation(s_etat_processus, s_objet_3); 1543: 1544: (*s_etat_processus).erreur_execution = 1545: d_ex_dimensions_invalides; 1546: return; 1547: } 1548: 1549: l_element_courant = (*s_objet_2).objet; 1550: 1551: if ((*(*l_element_courant).donnee).type != INT) 1552: { 1553: if (variable_partagee == d_vrai) 1554: { 1555: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1556: .s_liste_variables_partagees).mutex)) != 0) 1557: { 1558: (*s_etat_processus).erreur_systeme = d_es_processus; 1559: return; 1560: } 1561: } 1562: 1563: liberation(s_etat_processus, s_objet_1); 1564: liberation(s_etat_processus, s_objet_2); 1565: liberation(s_etat_processus, s_objet_3); 1566: 1567: (*s_etat_processus).erreur_execution = 1568: d_ex_erreur_type_argument; 1569: return; 1570: } 1571: 1572: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0) 1573: { 1574: if (variable_partagee == d_vrai) 1575: { 1576: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1577: .s_liste_variables_partagees).mutex)) != 0) 1578: { 1579: (*s_etat_processus).erreur_systeme = d_es_processus; 1580: return; 1581: } 1582: } 1583: 1584: liberation(s_etat_processus, s_objet_1); 1585: liberation(s_etat_processus, s_objet_2); 1586: liberation(s_etat_processus, s_objet_3); 1587: 1588: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1589: return; 1590: } 1591: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) > 1592: (integer8) (*((struct_vecteur *) (*s_objet_4).objet)) 1593: .taille) 1594: { 1595: if (variable_partagee == d_vrai) 1596: { 1597: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1598: .s_liste_variables_partagees).mutex)) != 0) 1599: { 1600: (*s_etat_processus).erreur_systeme = d_es_processus; 1601: return; 1602: } 1603: } 1604: 1605: liberation(s_etat_processus, s_objet_1); 1606: liberation(s_etat_processus, s_objet_2); 1607: liberation(s_etat_processus, s_objet_3); 1608: 1609: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 1610: return; 1611: } 1612: 1613: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet)); 1614: 1615: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'Q')) 1616: == NULL) 1617: { 1618: if (variable_partagee == d_vrai) 1619: { 1620: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1621: .s_liste_variables_partagees).mutex)) != 0) 1622: { 1623: (*s_etat_processus).erreur_systeme = d_es_processus; 1624: return; 1625: } 1626: } 1627: 1628: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1629: return; 1630: } 1631: 1632: liberation(s_etat_processus, s_objet_4); 1633: s_objet_4 = s_copie_4; 1634: 1635: if ((*s_objet_4).type == VIN) 1636: { 1637: /* 1638: * Vecteur d'entiers 1639: */ 1640: 1641: if ((*s_objet_1).type == INT) 1642: { 1643: /* 1644: * Aucune conversion de type 1645: */ 1646: 1647: ((integer8 *) (*((struct_vecteur *) (*s_objet_4).objet)) 1648: .tableau)[indice_i - 1] = (*((integer8 *) 1649: (*s_objet_1).objet)); 1650: } 1651: else if ((*s_objet_1).type == REL) 1652: { 1653: /* 1654: * Conversion du vecteur en vecteur réel 1655: */ 1656: 1657: tampon = (void *) ((integer8 *) (*((struct_vecteur *) 1658: (*s_objet_4).objet)).tableau); 1659: 1660: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'R'; 1661: (*s_objet_4).type = VRL; 1662: 1663: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau 1664: = malloc((*((struct_vecteur *) 1665: (*s_objet_4).objet)).taille * sizeof(real8))) 1666: == NULL) 1667: { 1668: if (variable_partagee == d_vrai) 1669: { 1670: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1671: .s_liste_variables_partagees).mutex)) != 0) 1672: { 1673: (*s_etat_processus).erreur_systeme = 1674: d_es_processus; 1675: return; 1676: } 1677: } 1678: 1679: (*s_etat_processus).erreur_systeme = 1680: d_es_allocation_memoire; 1681: return; 1682: } 1683: 1684: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet)) 1685: .taille; i++) 1686: { 1687: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet)) 1688: .tableau)[i] = (real8) (((integer8 *) 1689: tampon)[i]); 1690: } 1691: 1692: free((integer8 *) tampon); 1693: 1694: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet)) 1695: .tableau)[indice_i - 1] = (*((real8 *) 1696: (*s_objet_1).objet)); 1697: } 1698: else if ((*s_objet_1).type == CPL) 1699: { 1700: /* 1701: * Conversion du vecteur en vecteur complexe 1702: */ 1703: 1704: tampon = (void *) ((integer8 *) (*((struct_vecteur *) 1705: (*s_objet_4).objet)).tableau); 1706: 1707: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'C'; 1708: (*s_objet_4).type = VCX; 1709: 1710: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau 1711: = malloc((*((struct_vecteur *) 1712: (*s_objet_4).objet)).taille * 1713: sizeof(struct_complexe16))) == NULL) 1714: { 1715: if (variable_partagee == d_vrai) 1716: { 1717: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1718: .s_liste_variables_partagees).mutex)) != 0) 1719: { 1720: (*s_etat_processus).erreur_systeme = 1721: d_es_processus; 1722: return; 1723: } 1724: } 1725: 1726: (*s_etat_processus).erreur_systeme = 1727: d_es_allocation_memoire; 1728: return; 1729: } 1730: 1731: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet)) 1732: .taille; i++) 1733: { 1734: ((struct_complexe16 *) (*((struct_vecteur *) 1735: (*s_objet_4).objet)).tableau)[i].partie_reelle = 1736: (real8) (((integer8 *) tampon)[i]); 1737: ((struct_complexe16 *) (*((struct_vecteur *) 1738: (*s_objet_4).objet)).tableau)[i] 1739: .partie_imaginaire = (real8) 0; 1740: } 1741: 1742: free((integer8 *) tampon); 1743: 1744: ((struct_complexe16 *) (*((struct_vecteur *) 1745: (*s_objet_4).objet)).tableau)[indice_i - 1] 1746: .partie_reelle = (*((struct_complexe16 *) 1747: (*s_objet_1).objet)).partie_reelle; 1748: ((struct_complexe16 *) (*((struct_vecteur *) 1749: (*s_objet_4).objet)).tableau)[indice_i - 1] 1750: .partie_imaginaire = (*((struct_complexe16 *) 1751: (*s_objet_1).objet)).partie_imaginaire; 1752: } 1753: else 1754: { 1755: if (variable_partagee == d_vrai) 1756: { 1757: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1758: .s_liste_variables_partagees).mutex)) != 0) 1759: { 1760: (*s_etat_processus).erreur_systeme = 1761: d_es_processus; 1762: return; 1763: } 1764: } 1765: 1766: liberation(s_etat_processus, s_objet_1); 1767: liberation(s_etat_processus, s_objet_2); 1768: liberation(s_etat_processus, s_objet_3); 1769: 1770: (*s_etat_processus).erreur_execution = 1771: d_ex_erreur_type_argument; 1772: return; 1773: } 1774: } 1775: else if ((*s_objet_4).type == VRL) 1776: { 1777: /* 1778: * Vecteur de réels 1779: */ 1780: 1781: if ((*s_objet_1).type == INT) 1782: { 1783: /* 1784: * Conversion de l'élément à insérer en réel 1785: */ 1786: 1787: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet)) 1788: .tableau)[indice_i - 1] = (real8) (*((integer8 *) 1789: (*s_objet_1).objet)); 1790: } 1791: else if ((*s_objet_1).type == REL) 1792: { 1793: /* 1794: * Aucune conversion de type 1795: */ 1796: 1797: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet)) 1798: .tableau)[indice_i - 1] = (*((real8 *) 1799: (*s_objet_1).objet)); 1800: } 1801: else if ((*s_objet_1).type == CPL) 1802: { 1803: /* 1804: * Conversion du vecteur en vecteur complexe 1805: */ 1806: 1807: tampon = (void *) ((integer8 *) (*((struct_vecteur *) 1808: (*s_objet_4).objet)).tableau); 1809: 1810: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'C'; 1811: (*s_objet_4).type = VCX; 1812: 1813: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau 1814: = malloc((*((struct_vecteur *) 1815: (*s_objet_4).objet)).taille * 1816: sizeof(struct_complexe16))) == NULL) 1817: { 1818: if (variable_partagee == d_vrai) 1819: { 1820: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1821: .s_liste_variables_partagees).mutex)) != 0) 1822: { 1823: (*s_etat_processus).erreur_systeme = 1824: d_es_processus; 1825: return; 1826: } 1827: } 1828: 1829: (*s_etat_processus).erreur_systeme = 1830: d_es_allocation_memoire; 1831: return; 1832: } 1833: 1834: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet)) 1835: .taille; i++) 1836: { 1837: ((struct_complexe16 *) (*((struct_vecteur *) 1838: (*s_objet_4).objet)).tableau)[i].partie_reelle = 1839: ((real8 *) tampon)[i]; 1840: ((struct_complexe16 *) (*((struct_vecteur *) 1841: (*s_objet_4).objet)).tableau)[i] 1842: .partie_imaginaire = (real8) 0; 1843: } 1844: 1845: free((real8 *) tampon); 1846: 1847: ((struct_complexe16 *) (*((struct_vecteur *) 1848: (*s_objet_4).objet)).tableau)[indice_i - 1] 1849: .partie_reelle = (*((struct_complexe16 *) 1850: (*s_objet_1).objet)).partie_reelle; 1851: ((struct_complexe16 *) (*((struct_vecteur *) 1852: (*s_objet_4).objet)).tableau)[indice_i - 1] 1853: .partie_imaginaire = (*((struct_complexe16 *) 1854: (*s_objet_1).objet)).partie_imaginaire; 1855: } 1856: else 1857: { 1858: if (variable_partagee == d_vrai) 1859: { 1860: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1861: .s_liste_variables_partagees).mutex)) != 0) 1862: { 1863: (*s_etat_processus).erreur_systeme = 1864: d_es_processus; 1865: return; 1866: } 1867: } 1868: 1869: liberation(s_etat_processus, s_objet_1); 1870: liberation(s_etat_processus, s_objet_2); 1871: liberation(s_etat_processus, s_objet_3); 1872: 1873: (*s_etat_processus).erreur_execution = 1874: d_ex_erreur_type_argument; 1875: return; 1876: } 1877: } 1878: else 1879: { 1880: /* 1881: * Vecteur de complexes 1882: */ 1883: 1884: if ((*s_objet_1).type == INT) 1885: { 1886: /* 1887: * Conversion de l'élément à insérer en complexe 1888: */ 1889: 1890: ((struct_complexe16 *) (*((struct_vecteur *) 1891: (*s_objet_4).objet)).tableau)[indice_i - 1] 1892: .partie_reelle = (real8) (*((integer8 *) 1893: (*s_objet_1).objet)); 1894: ((struct_complexe16 *) (*((struct_vecteur *) 1895: (*s_objet_4).objet)).tableau)[indice_i - 1] 1896: .partie_imaginaire = (real8) 0; 1897: } 1898: else if ((*s_objet_1).type == REL) 1899: { 1900: /* 1901: * Conversion de l'élément à insérer en complexe 1902: */ 1903: 1904: ((struct_complexe16 *) (*((struct_vecteur *) 1905: (*s_objet_4).objet)).tableau)[indice_i - 1] 1906: .partie_reelle = (*((real8 *) (*s_objet_1).objet)); 1907: ((struct_complexe16 *) (*((struct_vecteur *) 1908: (*s_objet_4).objet)).tableau)[indice_i - 1] 1909: .partie_imaginaire = (real8) 0; 1910: } 1911: else if ((*s_objet_1).type == CPL) 1912: { 1913: /* 1914: * Aucune conversion de type 1915: */ 1916: 1917: ((struct_complexe16 *) (*((struct_vecteur *) 1918: (*s_objet_4).objet)).tableau)[indice_i - 1] 1919: .partie_reelle = (*((struct_complexe16 *) 1920: (*s_objet_1).objet)).partie_reelle; 1921: ((struct_complexe16 *) (*((struct_vecteur *) 1922: (*s_objet_4).objet)).tableau)[indice_i - 1] 1923: .partie_imaginaire = (*((struct_complexe16 *) 1924: (*s_objet_1).objet)).partie_imaginaire; 1925: } 1926: else 1927: { 1928: if (variable_partagee == d_vrai) 1929: { 1930: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1931: .s_liste_variables_partagees).mutex)) != 0) 1932: { 1933: (*s_etat_processus).erreur_systeme = 1934: d_es_processus; 1935: return; 1936: } 1937: } 1938: 1939: liberation(s_etat_processus, s_objet_1); 1940: liberation(s_etat_processus, s_objet_2); 1941: liberation(s_etat_processus, s_objet_3); 1942: 1943: (*s_etat_processus).erreur_execution = 1944: d_ex_erreur_type_argument; 1945: return; 1946: } 1947: } 1948: 1949: if (variable_partagee == d_faux) 1950: { 1951: (*(*s_etat_processus).pointeur_variable_courante).objet = 1952: s_objet_4; 1953: } 1954: else 1955: { 1956: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL; 1957: (*(*s_etat_processus).s_liste_variables_partagees).table 1958: [(*(*s_etat_processus).s_liste_variables_partagees) 1959: .position_variable].objet = s_objet_4; 1960: 1961: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1962: .s_liste_variables_partagees).mutex)) != 0) 1963: { 1964: (*s_etat_processus).erreur_systeme = d_es_processus; 1965: return; 1966: } 1967: } 1968: 1969: liberation(s_etat_processus, s_objet_1); 1970: liberation(s_etat_processus, s_objet_2); 1971: liberation(s_etat_processus, s_objet_3); 1972: } 1973: else if (((*s_objet_4).type == MIN) || 1974: ((*s_objet_4).type == MRL) || 1975: ((*s_objet_4).type == MCX)) 1976: { 1977: if ((*s_objet_2).type != LST) 1978: { 1979: if (variable_partagee == d_vrai) 1980: { 1981: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1982: .s_liste_variables_partagees).mutex)) != 0) 1983: { 1984: (*s_etat_processus).erreur_systeme = d_es_processus; 1985: return; 1986: } 1987: } 1988: 1989: liberation(s_etat_processus, s_objet_1); 1990: liberation(s_etat_processus, s_objet_2); 1991: liberation(s_etat_processus, s_objet_3); 1992: 1993: (*s_etat_processus).erreur_execution = 1994: d_ex_erreur_type_argument; 1995: return; 1996: } 1997: 1998: l_element_courant = (*s_objet_2).objet; 1999: nombre_dimensions = 0; 2000: 2001: while(l_element_courant != NULL) 2002: { 2003: nombre_dimensions++; 2004: l_element_courant = (*l_element_courant).suivant; 2005: } 2006: 2007: if (nombre_dimensions != 2) 2008: { 2009: if (variable_partagee == d_vrai) 2010: { 2011: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2012: .s_liste_variables_partagees).mutex)) != 0) 2013: { 2014: (*s_etat_processus).erreur_systeme = d_es_processus; 2015: return; 2016: } 2017: } 2018: 2019: liberation(s_etat_processus, s_objet_1); 2020: liberation(s_etat_processus, s_objet_2); 2021: liberation(s_etat_processus, s_objet_3); 2022: 2023: (*s_etat_processus).erreur_execution = 2024: d_ex_dimensions_invalides; 2025: return; 2026: } 2027: 2028: l_element_courant = (*s_objet_2).objet; 2029: 2030: indice_i = 0; 2031: indice_j = 0; 2032: 2033: while(l_element_courant != NULL) 2034: { 2035: if ((*(*l_element_courant).donnee).type != INT) 2036: { 2037: if (variable_partagee == d_vrai) 2038: { 2039: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2040: .s_liste_variables_partagees).mutex)) != 0) 2041: { 2042: (*s_etat_processus).erreur_systeme = d_es_processus; 2043: return; 2044: } 2045: } 2046: 2047: liberation(s_etat_processus, s_objet_1); 2048: liberation(s_etat_processus, s_objet_2); 2049: liberation(s_etat_processus, s_objet_3); 2050: 2051: (*s_etat_processus).erreur_execution = 2052: d_ex_erreur_type_argument; 2053: return; 2054: } 2055: 2056: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) 2057: <= 0) 2058: { 2059: if (variable_partagee == d_vrai) 2060: { 2061: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2062: .s_liste_variables_partagees).mutex)) != 0) 2063: { 2064: (*s_etat_processus).erreur_systeme = d_es_processus; 2065: return; 2066: } 2067: } 2068: 2069: liberation(s_etat_processus, s_objet_1); 2070: liberation(s_etat_processus, s_objet_2); 2071: liberation(s_etat_processus, s_objet_3); 2072: 2073: (*s_etat_processus).erreur_execution = 2074: d_ex_argument_invalide; 2075: return; 2076: } 2077: 2078: if (indice_i == 0) 2079: { 2080: indice_i = (*((integer8 *) 2081: (*(*l_element_courant).donnee).objet)); 2082: } 2083: else 2084: { 2085: indice_j = (*((integer8 *) 2086: (*(*l_element_courant).donnee).objet)); 2087: } 2088: 2089: l_element_courant = (*l_element_courant).suivant; 2090: } 2091: 2092: if ((indice_i > (*((struct_matrice *) (*s_objet_4).objet)) 2093: .nombre_lignes) || (indice_j > (*((struct_matrice *) 2094: (*s_objet_4).objet)).nombre_colonnes)) 2095: { 2096: if (variable_partagee == d_vrai) 2097: { 2098: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2099: .s_liste_variables_partagees).mutex)) != 0) 2100: { 2101: (*s_etat_processus).erreur_systeme = d_es_processus; 2102: return; 2103: } 2104: } 2105: 2106: liberation(s_etat_processus, s_objet_1); 2107: liberation(s_etat_processus, s_objet_2); 2108: liberation(s_etat_processus, s_objet_3); 2109: 2110: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 2111: return; 2112: } 2113: 2114: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'Q')) 2115: == NULL) 2116: { 2117: if (variable_partagee == d_vrai) 2118: { 2119: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2120: .s_liste_variables_partagees).mutex)) != 0) 2121: { 2122: (*s_etat_processus).erreur_systeme = d_es_processus; 2123: return; 2124: } 2125: } 2126: 2127: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2128: return; 2129: } 2130: 2131: liberation(s_etat_processus, s_objet_4); 2132: s_objet_4 = s_copie_4; 2133: 2134: if ((*s_objet_4).type == MIN) 2135: { 2136: /* 2137: * Matrice d'entiers 2138: */ 2139: 2140: if ((*s_objet_1).type == INT) 2141: { 2142: /* 2143: * Aucune conversion de type 2144: */ 2145: 2146: ((integer8 **) (*((struct_matrice *) (*s_objet_4).objet)) 2147: .tableau)[indice_i - 1][indice_j - 1] = 2148: (*((integer8 *) (*s_objet_1).objet)); 2149: } 2150: else if ((*s_objet_1).type == REL) 2151: { 2152: /* 2153: * Conversion de la matrice en matrice réelle 2154: */ 2155: 2156: tampon = (void *) ((integer8 **) (*((struct_matrice *) 2157: (*s_objet_4).objet)).tableau); 2158: 2159: (*((struct_matrice *) (*s_objet_4).objet)).type = 'R'; 2160: (*s_objet_4).type = MRL; 2161: 2162: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau 2163: = malloc((*((struct_matrice *) 2164: (*s_objet_4).objet)).nombre_lignes * 2165: sizeof(real8 *))) == NULL) 2166: { 2167: if (variable_partagee == d_vrai) 2168: { 2169: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2170: .s_liste_variables_partagees).mutex)) != 0) 2171: { 2172: (*s_etat_processus).erreur_systeme = 2173: d_es_processus; 2174: return; 2175: } 2176: } 2177: 2178: (*s_etat_processus).erreur_systeme = 2179: d_es_allocation_memoire; 2180: return; 2181: } 2182: 2183: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet)) 2184: .nombre_lignes; i++) 2185: { 2186: if ((((real8 **) (*((struct_matrice *) 2187: (*s_objet_4).objet)).tableau)[i] 2188: = malloc((*((struct_matrice *) 2189: (*s_objet_4).objet)).nombre_colonnes * 2190: sizeof(real8))) == NULL) 2191: { 2192: if (variable_partagee == d_vrai) 2193: { 2194: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2195: .s_liste_variables_partagees).mutex)) 2196: != 0) 2197: { 2198: (*s_etat_processus).erreur_systeme = 2199: d_es_processus; 2200: return; 2201: } 2202: } 2203: 2204: (*s_etat_processus).erreur_systeme = 2205: d_es_allocation_memoire; 2206: return; 2207: } 2208: 2209: for(j = 0; j < (*((struct_matrice *) 2210: (*s_objet_4).objet)).nombre_colonnes; j++) 2211: { 2212: ((real8 **) (*((struct_matrice *) (*s_objet_4) 2213: .objet)).tableau)[i][j] = (real8) 2214: (((integer8 **) tampon)[i][j]); 2215: } 2216: 2217: free(((integer8 **) tampon)[i]); 2218: } 2219: 2220: free((integer8 **) tampon); 2221: 2222: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet)) 2223: .tableau)[indice_i - 1][indice_j - 1] = 2224: (*((real8 *) (*s_objet_1).objet)); 2225: } 2226: else if ((*s_objet_1).type == CPL) 2227: { 2228: /* 2229: * Conversion de la matrice en matrice complexe 2230: */ 2231: 2232: tampon = (void *) ((integer8 **) (*((struct_matrice *) 2233: (*s_objet_4).objet)).tableau); 2234: 2235: (*((struct_matrice *) (*s_objet_4).objet)).type = 'C'; 2236: (*s_objet_4).type = MCX; 2237: 2238: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau 2239: = malloc((*((struct_matrice *) 2240: (*s_objet_4).objet)).nombre_lignes * 2241: sizeof(struct_complexe16 *))) == NULL) 2242: { 2243: if (variable_partagee == d_vrai) 2244: { 2245: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2246: .s_liste_variables_partagees).mutex)) != 0) 2247: { 2248: (*s_etat_processus).erreur_systeme = 2249: d_es_processus; 2250: return; 2251: } 2252: } 2253: 2254: (*s_etat_processus).erreur_systeme = 2255: d_es_allocation_memoire; 2256: return; 2257: } 2258: 2259: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet)) 2260: .nombre_lignes; i++) 2261: { 2262: if ((((struct_complexe16 **) (*((struct_matrice *) 2263: (*s_objet_4).objet)).tableau)[i] 2264: = malloc((*((struct_matrice *) 2265: (*s_objet_4).objet)).nombre_colonnes * 2266: sizeof(struct_complexe16))) == NULL) 2267: { 2268: if (variable_partagee == d_vrai) 2269: { 2270: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2271: .s_liste_variables_partagees).mutex)) 2272: != 0) 2273: { 2274: (*s_etat_processus).erreur_systeme = 2275: d_es_processus; 2276: return; 2277: } 2278: } 2279: 2280: (*s_etat_processus).erreur_systeme = 2281: d_es_allocation_memoire; 2282: return; 2283: } 2284: 2285: for(j = 0; j < (*((struct_matrice *) 2286: (*s_objet_4).objet)).nombre_colonnes; j++) 2287: { 2288: ((struct_complexe16 **) (*((struct_matrice *) 2289: (*s_objet_4).objet)).tableau)[i][j] 2290: .partie_reelle = (real8) (((integer8 **) 2291: tampon)[i][j]); 2292: ((struct_complexe16 **) (*((struct_matrice *) 2293: (*s_objet_4).objet)).tableau)[i][j] 2294: .partie_imaginaire = (real8) 0; 2295: } 2296: 2297: free(((integer8 **) tampon)[i]); 2298: } 2299: 2300: free((integer8 **) tampon); 2301: 2302: ((struct_complexe16 **) (*((struct_matrice *) 2303: (*s_objet_4).objet)).tableau)[indice_i - 1] 2304: [indice_j - 1].partie_reelle = 2305: (*((struct_complexe16 *) 2306: (*s_objet_1).objet)).partie_reelle; 2307: ((struct_complexe16 **) (*((struct_matrice *) 2308: (*s_objet_4).objet)).tableau)[indice_i - 1] 2309: [indice_j - 1].partie_imaginaire = 2310: (*((struct_complexe16 *) 2311: (*s_objet_1).objet)).partie_imaginaire; 2312: } 2313: else 2314: { 2315: if (variable_partagee == d_vrai) 2316: { 2317: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2318: .s_liste_variables_partagees).mutex)) != 0) 2319: { 2320: (*s_etat_processus).erreur_systeme = 2321: d_es_processus; 2322: return; 2323: } 2324: } 2325: 2326: liberation(s_etat_processus, s_objet_1); 2327: liberation(s_etat_processus, s_objet_2); 2328: liberation(s_etat_processus, s_objet_3); 2329: 2330: (*s_etat_processus).erreur_execution = 2331: d_ex_erreur_type_argument; 2332: return; 2333: } 2334: } 2335: else if ((*s_objet_4).type == MRL) 2336: { 2337: /* 2338: * Matrice de réels 2339: */ 2340: 2341: if ((*s_objet_1).type == INT) 2342: { 2343: /* 2344: * Conversion de l'élément à insérer en réel 2345: */ 2346: 2347: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet)) 2348: .tableau)[indice_i - 1][indice_j - 1] = 2349: (real8) (*((integer8 *) (*s_objet_1).objet)); 2350: } 2351: else if ((*s_objet_1).type == REL) 2352: { 2353: /* 2354: * Aucune conversion de type 2355: */ 2356: 2357: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet)) 2358: .tableau)[indice_i - 1][indice_j - 1] = 2359: (*((real8 *) (*s_objet_1).objet)); 2360: } 2361: else if ((*s_objet_1).type == CPL) 2362: { 2363: /* 2364: * Conversion de la matrice en matrice complexe 2365: */ 2366: 2367: tampon = (void *) ((real8 **) (*((struct_matrice *) 2368: (*s_objet_4).objet)).tableau); 2369: 2370: (*((struct_matrice *) (*s_objet_4).objet)).type = 'C'; 2371: (*s_objet_4).type = MCX; 2372: 2373: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau 2374: = malloc((*((struct_matrice *) 2375: (*s_objet_4).objet)).nombre_lignes * 2376: sizeof(struct_complexe16 *))) == NULL) 2377: { 2378: if (variable_partagee == d_vrai) 2379: { 2380: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2381: .s_liste_variables_partagees).mutex)) 2382: != 0) 2383: { 2384: (*s_etat_processus).erreur_systeme = 2385: d_es_processus; 2386: return; 2387: } 2388: } 2389: 2390: (*s_etat_processus).erreur_systeme = 2391: d_es_allocation_memoire; 2392: return; 2393: } 2394: 2395: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet)) 2396: .nombre_lignes; i++) 2397: { 2398: if ((((struct_complexe16 **) (*((struct_matrice *) 2399: (*s_objet_4).objet)).tableau)[i] 2400: = malloc((*((struct_matrice *) 2401: (*s_objet_4).objet)).nombre_colonnes * 2402: sizeof(struct_complexe16))) == NULL) 2403: { 2404: if (variable_partagee == d_vrai) 2405: { 2406: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2407: .s_liste_variables_partagees).mutex)) 2408: != 0) 2409: { 2410: (*s_etat_processus).erreur_systeme = 2411: d_es_processus; 2412: return; 2413: } 2414: } 2415: 2416: (*s_etat_processus).erreur_systeme = 2417: d_es_allocation_memoire; 2418: return; 2419: } 2420: 2421: for(j = 0; j < (*((struct_matrice *) 2422: (*s_objet_4).objet)).nombre_colonnes; j++) 2423: { 2424: ((struct_complexe16 **) (*((struct_matrice *) 2425: (*s_objet_4).objet)).tableau)[i][j] 2426: .partie_reelle = (((real8 **) 2427: tampon)[i][j]); 2428: ((struct_complexe16 **) (*((struct_matrice *) 2429: (*s_objet_4).objet)).tableau)[i][j] 2430: .partie_imaginaire = (real8) 0; 2431: } 2432: 2433: free(((integer8 **) tampon)[i]); 2434: } 2435: 2436: free((integer8 **) tampon); 2437: 2438: ((struct_complexe16 **) (*((struct_matrice *) 2439: (*s_objet_4).objet)).tableau)[indice_i - 1] 2440: [indice_j - 1].partie_reelle = 2441: (*((struct_complexe16 *) 2442: (*s_objet_1).objet)).partie_reelle; 2443: ((struct_complexe16 **) (*((struct_matrice *) 2444: (*s_objet_4).objet)).tableau)[indice_i - 1] 2445: [indice_j - 1].partie_imaginaire = 2446: (*((struct_complexe16 *) 2447: (*s_objet_1).objet)).partie_imaginaire; 2448: } 2449: else 2450: { 2451: if (variable_partagee == d_vrai) 2452: { 2453: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2454: .s_liste_variables_partagees).mutex)) != 0) 2455: { 2456: (*s_etat_processus).erreur_systeme = 2457: d_es_processus; 2458: return; 2459: } 2460: } 2461: 2462: liberation(s_etat_processus, s_objet_1); 2463: liberation(s_etat_processus, s_objet_2); 2464: liberation(s_etat_processus, s_objet_3); 2465: 2466: (*s_etat_processus).erreur_execution = 2467: d_ex_erreur_type_argument; 2468: return; 2469: } 2470: } 2471: else 2472: { 2473: /* 2474: * Matrice de complexes 2475: */ 2476: 2477: if ((*s_objet_1).type == INT) 2478: { 2479: /* 2480: * Conversion de l'élément à insérer en complexe 2481: */ 2482: 2483: ((struct_complexe16 **) (*((struct_matrice *) 2484: (*s_objet_4).objet)).tableau)[indice_i - 1] 2485: [indice_j - 1].partie_reelle = (real8) 2486: (*((integer8 *) (*s_objet_1).objet)); 2487: ((struct_complexe16 **) (*((struct_matrice *) 2488: (*s_objet_4).objet)).tableau)[indice_i - 1] 2489: [indice_j - 1].partie_imaginaire = (real8) 0; 2490: } 2491: else if ((*s_objet_1).type == REL) 2492: { 2493: /* 2494: * Conversion de l'élément à insérer en complexe 2495: */ 2496: 2497: ((struct_complexe16 **) (*((struct_matrice *) 2498: (*s_objet_4).objet)).tableau)[indice_i - 1] 2499: [indice_j - 1].partie_reelle = 2500: (*((real8 *) (*s_objet_1).objet)); 2501: ((struct_complexe16 **) (*((struct_matrice *) 2502: (*s_objet_4).objet)).tableau)[indice_i - 1] 2503: [indice_j - 1].partie_imaginaire = (real8) 0; 2504: } 2505: else if ((*s_objet_1).type == CPL) 2506: { 2507: /* 2508: * Aucune conversion de type 2509: */ 2510: 2511: ((struct_complexe16 **) (*((struct_matrice *) 2512: (*s_objet_4).objet)).tableau)[indice_i - 1] 2513: [indice_j - 1].partie_reelle = 2514: (*((struct_complexe16 *) 2515: (*s_objet_1).objet)).partie_reelle; 2516: ((struct_complexe16 **) (*((struct_matrice *) 2517: (*s_objet_4).objet)).tableau)[indice_i - 1] 2518: [indice_j - 1].partie_imaginaire = 2519: (*((struct_complexe16 *) 2520: (*s_objet_1).objet)).partie_imaginaire; 2521: } 2522: else 2523: { 2524: if (variable_partagee == d_vrai) 2525: { 2526: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2527: .s_liste_variables_partagees).mutex)) != 0) 2528: { 2529: (*s_etat_processus).erreur_systeme = 2530: d_es_processus; 2531: return; 2532: } 2533: } 2534: 2535: liberation(s_etat_processus, s_objet_1); 2536: liberation(s_etat_processus, s_objet_2); 2537: liberation(s_etat_processus, s_objet_3); 2538: 2539: (*s_etat_processus).erreur_execution = 2540: d_ex_erreur_type_argument; 2541: return; 2542: } 2543: } 2544: 2545: if (variable_partagee == d_faux) 2546: { 2547: (*(*s_etat_processus).pointeur_variable_courante).objet = 2548: s_objet_4; 2549: } 2550: else 2551: { 2552: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL; 2553: (*(*s_etat_processus).s_liste_variables_partagees).table 2554: [(*(*s_etat_processus).s_liste_variables_partagees) 2555: .position_variable].objet = s_objet_4; 2556: 2557: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2558: .s_liste_variables_partagees).mutex)) 2559: != 0) 2560: { 2561: (*s_etat_processus).erreur_systeme = 2562: d_es_processus; 2563: return; 2564: } 2565: } 2566: 2567: liberation(s_etat_processus, s_objet_1); 2568: liberation(s_etat_processus, s_objet_2); 2569: liberation(s_etat_processus, s_objet_3); 2570: } 2571: else if ((*s_objet_4).type == LST) 2572: { 2573: if ((*s_objet_2).type != INT) 2574: { 2575: if (variable_partagee == d_vrai) 2576: { 2577: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2578: .s_liste_variables_partagees).mutex)) 2579: != 0) 2580: { 2581: (*s_etat_processus).erreur_systeme = 2582: d_es_processus; 2583: return; 2584: } 2585: } 2586: 2587: liberation(s_etat_processus, s_objet_1); 2588: liberation(s_etat_processus, s_objet_2); 2589: liberation(s_etat_processus, s_objet_3); 2590: 2591: (*s_etat_processus).erreur_execution = 2592: d_ex_erreur_type_argument; 2593: return; 2594: } 2595: 2596: indice_i = (*((integer8 *) (*s_objet_2).objet)); 2597: indice_j = 1; 2598: 2599: if ((*s_objet_4).nombre_occurrences > 1) 2600: { 2601: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'N')) 2602: == NULL) 2603: { 2604: if (variable_partagee == d_vrai) 2605: { 2606: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2607: .s_liste_variables_partagees).mutex)) 2608: != 0) 2609: { 2610: (*s_etat_processus).erreur_systeme = 2611: d_es_processus; 2612: return; 2613: } 2614: } 2615: 2616: (*s_etat_processus).erreur_systeme = 2617: d_es_allocation_memoire; 2618: return; 2619: } 2620: 2621: liberation(s_etat_processus, s_objet_4); 2622: s_objet_4 = s_copie_4; 2623: } 2624: 2625: l_element_courant = (*s_objet_4).objet; 2626: 2627: while((l_element_courant != NULL) && (indice_j != indice_i)) 2628: { 2629: l_element_courant = (*l_element_courant).suivant; 2630: indice_j++; 2631: } 2632: 2633: if (l_element_courant != NULL) 2634: { 2635: liberation(s_etat_processus, (*l_element_courant).donnee); 2636: (*l_element_courant).donnee = s_objet_1; 2637: } 2638: else 2639: { 2640: if (variable_partagee == d_vrai) 2641: { 2642: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2643: .s_liste_variables_partagees).mutex)) != 0) 2644: { 2645: (*s_etat_processus).erreur_systeme = 2646: d_es_processus; 2647: return; 2648: } 2649: } 2650: 2651: liberation(s_etat_processus, s_objet_1); 2652: liberation(s_etat_processus, s_objet_2); 2653: liberation(s_etat_processus, s_objet_3); 2654: 2655: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 2656: return; 2657: } 2658: 2659: if (variable_partagee == d_faux) 2660: { 2661: (*(*s_etat_processus).pointeur_variable_courante).objet = 2662: s_objet_4; 2663: } 2664: else 2665: { 2666: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL; 2667: (*(*s_etat_processus).s_liste_variables_partagees).table 2668: [(*(*s_etat_processus).s_liste_variables_partagees) 2669: .position_variable].objet = s_objet_4; 2670: 2671: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2672: .s_liste_variables_partagees).mutex)) != 0) 2673: { 2674: (*s_etat_processus).erreur_systeme = 2675: d_es_processus; 2676: return; 2677: } 2678: } 2679: 2680: liberation(s_etat_processus, s_objet_2); 2681: liberation(s_etat_processus, s_objet_3); 2682: } 2683: else if ((*s_objet_4).type == TBL) 2684: { 2685: if ((*s_objet_2).type != LST) 2686: { 2687: if (variable_partagee == d_vrai) 2688: { 2689: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2690: .s_liste_variables_partagees).mutex)) != 0) 2691: { 2692: (*s_etat_processus).erreur_systeme = 2693: d_es_processus; 2694: return; 2695: } 2696: } 2697: 2698: liberation(s_etat_processus, s_objet_1); 2699: liberation(s_etat_processus, s_objet_2); 2700: liberation(s_etat_processus, s_objet_3); 2701: 2702: (*s_etat_processus).erreur_execution = 2703: d_ex_erreur_type_argument; 2704: return; 2705: } 2706: 2707: if ((*s_objet_4).nombre_occurrences > 1) 2708: { 2709: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'N')) 2710: == NULL) 2711: { 2712: if (variable_partagee == d_vrai) 2713: { 2714: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2715: .s_liste_variables_partagees).mutex)) != 0) 2716: { 2717: (*s_etat_processus).erreur_systeme = 2718: d_es_processus; 2719: return; 2720: } 2721: } 2722: 2723: (*s_etat_processus).erreur_systeme = 2724: d_es_allocation_memoire; 2725: return; 2726: } 2727: 2728: liberation(s_etat_processus, s_objet_4); 2729: s_objet_4 = s_copie_4; 2730: } 2731: 2732: s_objet_element = s_objet_4; 2733: l_element_courant = (*s_objet_2).objet; 2734: indice_i = 0; 2735: 2736: while(l_element_courant != NULL) 2737: { 2738: if ((*(*l_element_courant).donnee).type != INT) 2739: { 2740: if (variable_partagee == d_vrai) 2741: { 2742: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2743: .s_liste_variables_partagees).mutex)) != 0) 2744: { 2745: (*s_etat_processus).erreur_systeme = 2746: d_es_processus; 2747: return; 2748: } 2749: } 2750: 2751: liberation(s_etat_processus, s_objet_1); 2752: liberation(s_etat_processus, s_objet_2); 2753: liberation(s_etat_processus, s_objet_3); 2754: 2755: (*s_etat_processus).erreur_execution = 2756: d_ex_erreur_type_argument; 2757: return; 2758: } 2759: 2760: if ((*s_objet_element).type != TBL) 2761: { 2762: if (variable_partagee == d_vrai) 2763: { 2764: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2765: .s_liste_variables_partagees).mutex)) != 0) 2766: { 2767: (*s_etat_processus).erreur_systeme = 2768: d_es_processus; 2769: return; 2770: } 2771: } 2772: 2773: liberation(s_etat_processus, s_objet_1); 2774: liberation(s_etat_processus, s_objet_2); 2775: liberation(s_etat_processus, s_objet_3); 2776: 2777: (*s_etat_processus).erreur_execution = 2778: d_ex_element_inexistant; 2779: return; 2780: } 2781: 2782: indice_i = (*((integer8 *) (*(*l_element_courant) 2783: .donnee).objet)); 2784: 2785: if ((indice_i < 1) || (indice_i > (*((struct_tableau *) 2786: (*s_objet_element).objet)).nombre_elements)) 2787: { 2788: if (variable_partagee == d_vrai) 2789: { 2790: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2791: .s_liste_variables_partagees).mutex)) != 0) 2792: { 2793: (*s_etat_processus).erreur_systeme = 2794: d_es_processus; 2795: return; 2796: } 2797: } 2798: 2799: liberation(s_etat_processus, s_objet_1); 2800: liberation(s_etat_processus, s_objet_2); 2801: liberation(s_etat_processus, s_objet_3); 2802: 2803: (*s_etat_processus).erreur_execution = 2804: d_ex_element_inexistant; 2805: return; 2806: } 2807: 2808: if ((*l_element_courant).suivant != NULL) 2809: { 2810: s_objet_element = (*((struct_tableau *) (*s_objet_element) 2811: .objet)).elements[indice_i - 1]; 2812: } 2813: 2814: l_element_courant = (*l_element_courant).suivant; 2815: } 2816: 2817: liberation(s_etat_processus, (*((struct_tableau *) 2818: (*s_objet_element).objet)).elements[indice_i - 1]); 2819: (*((struct_tableau *) (*s_objet_element).objet)).elements 2820: [indice_i - 1] = s_objet_1; 2821: 2822: if (variable_partagee == d_faux) 2823: { 2824: (*(*s_etat_processus).pointeur_variable_courante).objet = 2825: s_objet_4; 2826: } 2827: else 2828: { 2829: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL; 2830: (*(*s_etat_processus).s_liste_variables_partagees).table 2831: [(*(*s_etat_processus).s_liste_variables_partagees) 2832: .position_variable].objet = s_objet_4; 2833: 2834: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2835: .s_liste_variables_partagees).mutex)) != 0) 2836: { 2837: (*s_etat_processus).erreur_systeme = 2838: d_es_processus; 2839: return; 2840: } 2841: } 2842: 2843: liberation(s_etat_processus, s_objet_2); 2844: } 2845: else 2846: { 2847: if (variable_partagee == d_vrai) 2848: { 2849: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2850: .s_liste_variables_partagees).mutex)) != 0) 2851: { 2852: (*s_etat_processus).erreur_systeme = 2853: d_es_processus; 2854: return; 2855: } 2856: } 2857: 2858: liberation(s_etat_processus, s_objet_1); 2859: liberation(s_etat_processus, s_objet_2); 2860: liberation(s_etat_processus, s_objet_3); 2861: 2862: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 2863: return; 2864: } 2865: } 2866: 2867: /* 2868: -------------------------------------------------------------------------------- 2869: Arguments incompatibles 2870: -------------------------------------------------------------------------------- 2871: */ 2872: 2873: else 2874: { 2875: liberation(s_etat_processus, s_objet_1); 2876: liberation(s_etat_processus, s_objet_2); 2877: liberation(s_etat_processus, s_objet_3); 2878: 2879: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 2880: return; 2881: } 2882: 2883: return; 2884: } 2885: 2886: 2887: /* 2888: ================================================================================ 2889: Fonction 'puti' 2890: ================================================================================ 2891: Entrées : pointeur sur une structure struct_processus 2892: -------------------------------------------------------------------------------- 2893: Sorties : 2894: -------------------------------------------------------------------------------- 2895: Effets de bord : néant 2896: ================================================================================ 2897: */ 2898: 2899: void 2900: instruction_puti(struct_processus *s_etat_processus) 2901: { 2902: logical1 variable_partagee; 2903: 2904: struct_liste_chainee *l_element_courant; 2905: 2906: struct_objet *s_copie_2; 2907: struct_objet *s_copie_3; 2908: struct_objet *s_copie_4; 2909: struct_objet *s_objet_1; 2910: struct_objet *s_objet_2; 2911: struct_objet *s_objet_3; 2912: struct_objet *s_objet_4; 2913: 2914: unsigned long i; 2915: unsigned long indice_i; 2916: unsigned long indice_j; 2917: unsigned long j; 2918: unsigned long nombre_dimensions; 2919: unsigned long nombre_elements; 2920: 2921: void *tampon; 2922: 2923: (*s_etat_processus).erreur_execution = d_ex; 2924: 2925: if ((*s_etat_processus).affichage_arguments == 'Y') 2926: { 2927: printf("\n PUTI "); 2928: 2929: if ((*s_etat_processus).langue == 'F') 2930: { 2931: printf("(change un élément)\n\n"); 2932: } 2933: else 2934: { 2935: printf("(change element)\n\n"); 2936: } 2937: 2938: printf(" 3: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM); 2939: printf(" 2: %s\n", d_LST); 2940: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL); 2941: printf("-> 2: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM); 2942: printf(" 1: %s\n\n", d_LST); 2943: 2944: printf(" 3: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM); 2945: printf(" 2: %s\n", d_LST); 2946: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL); 2947: printf("-> 2: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM); 2948: printf(" 1: %s\n\n", d_LST); 2949: 2950: printf(" 3: %s, %s\n", d_LST, d_NOM); 2951: printf(" 2: %s\n", d_INT); 2952: printf(" 1: %s, %s, %s, %s, %s, %s,\n" 2953: " %s, %s, %s, %s, %s,\n" 2954: " %s, %s, %s, %s, %s,\n" 2955: " %s, %s, %s, %s,\n" 2956: " %s, %s\n", 2957: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 2958: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, 2959: d_SQL, d_SLB, d_PRC, d_MTX); 2960: printf("-> 2: %s, %s\n", d_LST, d_NOM); 2961: printf(" 1: %s\n", d_INT); 2962: 2963: return; 2964: } 2965: else if ((*s_etat_processus).test_instruction == 'Y') 2966: { 2967: (*s_etat_processus).nombre_arguments = -1; 2968: return; 2969: } 2970: 2971: if (test_cfsf(s_etat_processus, 31) == d_vrai) 2972: { 2973: if (empilement_pile_last(s_etat_processus, 3) == d_erreur) 2974: { 2975: return; 2976: } 2977: } 2978: 2979: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2980: &s_objet_1) == d_erreur) 2981: { 2982: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 2983: return; 2984: } 2985: 2986: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2987: &s_objet_2) == d_erreur) 2988: { 2989: liberation(s_etat_processus, s_objet_1); 2990: 2991: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 2992: return; 2993: } 2994: 2995: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2996: &s_objet_3) == d_erreur) 2997: { 2998: liberation(s_etat_processus, s_objet_1); 2999: liberation(s_etat_processus, s_objet_2); 3000: 3001: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 3002: return; 3003: } 3004: 3005: if ((s_copie_2 = copie_objet(s_etat_processus, s_objet_2, 'O')) == NULL) 3006: { 3007: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3008: return; 3009: } 3010: 3011: liberation(s_etat_processus, s_objet_2); 3012: s_objet_2 = s_copie_2; 3013: 3014: /* 3015: -------------------------------------------------------------------------------- 3016: Traitement des éléments des vecteurs 3017: -------------------------------------------------------------------------------- 3018: */ 3019: 3020: if (((*s_objet_3).type == VIN) || 3021: ((*s_objet_3).type == VRL) || 3022: ((*s_objet_3).type == VCX)) 3023: { 3024: if ((*s_objet_2).type != LST) 3025: { 3026: liberation(s_etat_processus, s_objet_1); 3027: liberation(s_etat_processus, s_objet_2); 3028: liberation(s_etat_processus, s_objet_3); 3029: 3030: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 3031: return; 3032: } 3033: 3034: l_element_courant = (*s_objet_2).objet; 3035: nombre_dimensions = 0; 3036: 3037: while(l_element_courant != NULL) 3038: { 3039: nombre_dimensions++; 3040: l_element_courant = (*l_element_courant).suivant; 3041: } 3042: 3043: if (nombre_dimensions != 1) 3044: { 3045: liberation(s_etat_processus, s_objet_1); 3046: liberation(s_etat_processus, s_objet_2); 3047: liberation(s_etat_processus, s_objet_3); 3048: 3049: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 3050: return; 3051: } 3052: 3053: l_element_courant = (*s_objet_2).objet; 3054: 3055: if ((*(*l_element_courant).donnee).type != INT) 3056: { 3057: liberation(s_etat_processus, s_objet_1); 3058: liberation(s_etat_processus, s_objet_2); 3059: liberation(s_etat_processus, s_objet_3); 3060: 3061: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 3062: return; 3063: } 3064: 3065: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0) 3066: { 3067: liberation(s_etat_processus, s_objet_1); 3068: liberation(s_etat_processus, s_objet_2); 3069: liberation(s_etat_processus, s_objet_3); 3070: 3071: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 3072: return; 3073: } 3074: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) > 3075: (integer8) (*((struct_vecteur *) (*s_objet_3).objet)).taille) 3076: { 3077: liberation(s_etat_processus, s_objet_1); 3078: liberation(s_etat_processus, s_objet_2); 3079: liberation(s_etat_processus, s_objet_3); 3080: 3081: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 3082: return; 3083: } 3084: 3085: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet)); 3086: 3087: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'Q')) == NULL) 3088: { 3089: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3090: return; 3091: } 3092: 3093: liberation(s_etat_processus, s_objet_3); 3094: s_objet_3 = s_copie_3; 3095: 3096: if ((*s_objet_3).type == VIN) 3097: { 3098: /* 3099: * Vecteur d'entiers 3100: */ 3101: 3102: if ((*s_objet_1).type == INT) 3103: { 3104: /* 3105: * Aucune conversion de type 3106: */ 3107: 3108: ((integer8 *) (*((struct_vecteur *) (*s_objet_3).objet)) 3109: .tableau)[indice_i - 1] = (*((integer8 *) 3110: (*s_objet_1).objet)); 3111: } 3112: else if ((*s_objet_1).type == REL) 3113: { 3114: /* 3115: * Conversion du vecteur en vecteur réel 3116: */ 3117: 3118: tampon = (void *) ((integer8 *) (*((struct_vecteur *) 3119: (*s_objet_3).objet)).tableau); 3120: 3121: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'R'; 3122: (*s_objet_3).type = VRL; 3123: 3124: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau 3125: = malloc((*((struct_vecteur *) 3126: (*s_objet_3).objet)).taille * sizeof(real8))) 3127: == NULL) 3128: { 3129: (*s_etat_processus).erreur_systeme = 3130: d_es_allocation_memoire; 3131: return; 3132: } 3133: 3134: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet)) 3135: .taille; i++) 3136: { 3137: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet)) 3138: .tableau)[i] = (real8) (((integer8 *) tampon)[i]); 3139: } 3140: 3141: free((integer8 *) tampon); 3142: 3143: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet)) 3144: .tableau)[indice_i - 1] = (*((real8 *) 3145: (*s_objet_1).objet)); 3146: } 3147: else if ((*s_objet_1).type == CPL) 3148: { 3149: /* 3150: * Conversion du vecteur en vecteur complexe 3151: */ 3152: 3153: tampon = (void *) ((integer8 *) (*((struct_vecteur *) 3154: (*s_objet_3).objet)).tableau); 3155: 3156: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'C'; 3157: (*s_objet_3).type = VCX; 3158: 3159: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau 3160: = malloc((*((struct_vecteur *) 3161: (*s_objet_3).objet)).taille * 3162: sizeof(struct_complexe16))) == NULL) 3163: { 3164: (*s_etat_processus).erreur_systeme = 3165: d_es_allocation_memoire; 3166: return; 3167: } 3168: 3169: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet)) 3170: .taille; i++) 3171: { 3172: ((struct_complexe16 *) (*((struct_vecteur *) 3173: (*s_objet_3).objet)).tableau)[i].partie_reelle = 3174: (real8) (((integer8 *) tampon)[i]); 3175: ((struct_complexe16 *) (*((struct_vecteur *) 3176: (*s_objet_3).objet)).tableau)[i] 3177: .partie_imaginaire = (real8) 0; 3178: } 3179: 3180: free((integer8 *) tampon); 3181: 3182: ((struct_complexe16 *) (*((struct_vecteur *) 3183: (*s_objet_3).objet)).tableau)[indice_i - 1] 3184: .partie_reelle = (*((struct_complexe16 *) 3185: (*s_objet_1).objet)).partie_reelle; 3186: ((struct_complexe16 *) (*((struct_vecteur *) 3187: (*s_objet_3).objet)).tableau)[indice_i - 1] 3188: .partie_imaginaire = (*((struct_complexe16 *) 3189: (*s_objet_1).objet)).partie_imaginaire; 3190: } 3191: else 3192: { 3193: liberation(s_etat_processus, s_objet_1); 3194: liberation(s_etat_processus, s_objet_2); 3195: liberation(s_etat_processus, s_objet_3); 3196: 3197: (*s_etat_processus).erreur_execution = 3198: d_ex_erreur_type_argument; 3199: return; 3200: } 3201: } 3202: else if ((*s_objet_3).type == VRL) 3203: { 3204: /* 3205: * Vecteur de réels 3206: */ 3207: 3208: if ((*s_objet_1).type == INT) 3209: { 3210: /* 3211: * Conversion de l'élément à insérer en réel 3212: */ 3213: 3214: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet)) 3215: .tableau)[indice_i - 1] = (real8) (*((integer8 *) 3216: (*s_objet_1).objet)); 3217: } 3218: else if ((*s_objet_1).type == REL) 3219: { 3220: /* 3221: * Aucune conversion de type 3222: */ 3223: 3224: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet)) 3225: .tableau)[indice_i - 1] = (*((real8 *) 3226: (*s_objet_1).objet)); 3227: } 3228: else if ((*s_objet_1).type == CPL) 3229: { 3230: /* 3231: * Conversion du vecteur en vecteur complexe 3232: */ 3233: 3234: tampon = (void *) ((integer8 *) (*((struct_vecteur *) 3235: (*s_objet_3).objet)).tableau); 3236: 3237: (*((struct_vecteur *) (*s_objet_3).objet)).type = 'C'; 3238: (*s_objet_3).type = VCX; 3239: 3240: if (((*((struct_vecteur *) (*s_objet_3).objet)).tableau 3241: = malloc((*((struct_vecteur *) 3242: (*s_objet_3).objet)).taille * 3243: sizeof(struct_complexe16))) == NULL) 3244: { 3245: (*s_etat_processus).erreur_systeme = 3246: d_es_allocation_memoire; 3247: return; 3248: } 3249: 3250: for(i = 0; i < (*((struct_vecteur *) (*s_objet_3).objet)) 3251: .taille; i++) 3252: { 3253: ((struct_complexe16 *) (*((struct_vecteur *) 3254: (*s_objet_3).objet)).tableau)[i].partie_reelle = 3255: ((real8 *) tampon)[i]; 3256: ((struct_complexe16 *) (*((struct_vecteur *) 3257: (*s_objet_3).objet)).tableau)[i] 3258: .partie_imaginaire = (real8) 0; 3259: } 3260: 3261: free((real8 *) tampon); 3262: 3263: ((struct_complexe16 *) (*((struct_vecteur *) 3264: (*s_objet_3).objet)).tableau)[indice_i - 1] 3265: .partie_reelle = (*((struct_complexe16 *) 3266: (*s_objet_1).objet)).partie_reelle; 3267: ((struct_complexe16 *) (*((struct_vecteur *) 3268: (*s_objet_3).objet)).tableau)[indice_i - 1] 3269: .partie_imaginaire = (*((struct_complexe16 *) 3270: (*s_objet_1).objet)).partie_imaginaire; 3271: } 3272: else 3273: { 3274: liberation(s_etat_processus, s_objet_1); 3275: liberation(s_etat_processus, s_objet_2); 3276: liberation(s_etat_processus, s_objet_3); 3277: 3278: (*s_etat_processus).erreur_execution = 3279: d_ex_erreur_type_argument; 3280: return; 3281: } 3282: } 3283: else 3284: { 3285: /* 3286: * Vecteur de complexes 3287: */ 3288: 3289: if ((*s_objet_1).type == INT) 3290: { 3291: /* 3292: * Conversion de l'élément à insérer en complexe 3293: */ 3294: 3295: ((struct_complexe16 *) (*((struct_vecteur *) 3296: (*s_objet_3).objet)).tableau)[indice_i - 1] 3297: .partie_reelle = (real8) (*((integer8 *) 3298: (*s_objet_1).objet)); 3299: ((struct_complexe16 *) (*((struct_vecteur *) 3300: (*s_objet_3).objet)).tableau)[indice_i - 1] 3301: .partie_imaginaire = (real8) 0; 3302: } 3303: else if ((*s_objet_1).type == REL) 3304: { 3305: /* 3306: * Conversion de l'élément à insérer en complexe 3307: */ 3308: 3309: ((struct_complexe16 *) (*((struct_vecteur *) 3310: (*s_objet_3).objet)).tableau)[indice_i - 1] 3311: .partie_reelle = (*((real8 *) (*s_objet_1).objet)); 3312: ((struct_complexe16 *) (*((struct_vecteur *) 3313: (*s_objet_3).objet)).tableau)[indice_i - 1] 3314: .partie_imaginaire = (real8) 0; 3315: } 3316: else if ((*s_objet_1).type == CPL) 3317: { 3318: /* 3319: * Aucune conversion de type 3320: */ 3321: 3322: ((struct_complexe16 *) (*((struct_vecteur *) 3323: (*s_objet_3).objet)).tableau)[indice_i - 1] 3324: .partie_reelle = (*((struct_complexe16 *) 3325: (*s_objet_1).objet)).partie_reelle; 3326: ((struct_complexe16 *) (*((struct_vecteur *) 3327: (*s_objet_3).objet)).tableau)[indice_i - 1] 3328: .partie_imaginaire = (*((struct_complexe16 *) 3329: (*s_objet_1).objet)).partie_imaginaire; 3330: } 3331: else 3332: { 3333: liberation(s_etat_processus, s_objet_1); 3334: liberation(s_etat_processus, s_objet_2); 3335: liberation(s_etat_processus, s_objet_3); 3336: 3337: (*s_etat_processus).erreur_execution = 3338: d_ex_erreur_type_argument; 3339: return; 3340: } 3341: } 3342: 3343: liberation(s_etat_processus, s_objet_1); 3344: 3345: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 3346: s_objet_3) == d_erreur) 3347: { 3348: return; 3349: } 3350: 3351: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = 3352: (indice_i % (*((struct_vecteur *) (*s_objet_3).objet)) 3353: .taille) + 1; 3354: 3355: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 3356: s_objet_2) == d_erreur) 3357: { 3358: return; 3359: } 3360: } 3361: 3362: /* 3363: -------------------------------------------------------------------------------- 3364: Traitement des éléments des matrices 3365: -------------------------------------------------------------------------------- 3366: */ 3367: 3368: else if (((*s_objet_3).type == MIN) || 3369: ((*s_objet_3).type == MRL) || 3370: ((*s_objet_3).type == MCX)) 3371: { 3372: if ((*s_objet_2).type != LST) 3373: { 3374: liberation(s_etat_processus, s_objet_1); 3375: liberation(s_etat_processus, s_objet_2); 3376: liberation(s_etat_processus, s_objet_3); 3377: 3378: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 3379: return; 3380: } 3381: 3382: l_element_courant = (*s_objet_2).objet; 3383: nombre_dimensions = 0; 3384: 3385: while(l_element_courant != NULL) 3386: { 3387: nombre_dimensions++; 3388: l_element_courant = (*l_element_courant).suivant; 3389: } 3390: 3391: if (nombre_dimensions != 2) 3392: { 3393: liberation(s_etat_processus, s_objet_1); 3394: liberation(s_etat_processus, s_objet_2); 3395: liberation(s_etat_processus, s_objet_3); 3396: 3397: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 3398: return; 3399: } 3400: 3401: l_element_courant = (*s_objet_2).objet; 3402: 3403: indice_i = 0; 3404: indice_j = 0; 3405: 3406: while(l_element_courant != NULL) 3407: { 3408: if ((*(*l_element_courant).donnee).type != INT) 3409: { 3410: liberation(s_etat_processus, s_objet_1); 3411: liberation(s_etat_processus, s_objet_2); 3412: liberation(s_etat_processus, s_objet_3); 3413: 3414: (*s_etat_processus).erreur_execution = 3415: d_ex_erreur_type_argument; 3416: return; 3417: } 3418: 3419: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0) 3420: { 3421: liberation(s_etat_processus, s_objet_1); 3422: liberation(s_etat_processus, s_objet_2); 3423: liberation(s_etat_processus, s_objet_3); 3424: 3425: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 3426: return; 3427: } 3428: 3429: if (indice_i == 0) 3430: { 3431: indice_i = (*((integer8 *) 3432: (*(*l_element_courant).donnee).objet)); 3433: } 3434: else 3435: { 3436: indice_j = (*((integer8 *) 3437: (*(*l_element_courant).donnee).objet)); 3438: } 3439: 3440: l_element_courant = (*l_element_courant).suivant; 3441: } 3442: 3443: if ((indice_i > (*((struct_matrice *) (*s_objet_3).objet)) 3444: .nombre_lignes) || (indice_j > (*((struct_matrice *) 3445: (*s_objet_3).objet)).nombre_colonnes)) 3446: { 3447: liberation(s_etat_processus, s_objet_1); 3448: liberation(s_etat_processus, s_objet_2); 3449: liberation(s_etat_processus, s_objet_3); 3450: 3451: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 3452: return; 3453: } 3454: 3455: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'Q')) == NULL) 3456: { 3457: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3458: return; 3459: } 3460: 3461: liberation(s_etat_processus, s_objet_3); 3462: s_objet_3 = s_copie_3; 3463: 3464: if ((*s_objet_3).type == MIN) 3465: { 3466: /* 3467: * Matrice d'entiers 3468: */ 3469: 3470: if ((*s_objet_1).type == INT) 3471: { 3472: /* 3473: * Aucune conversion de type 3474: */ 3475: 3476: ((integer8 **) (*((struct_matrice *) (*s_objet_3).objet)) 3477: .tableau)[indice_i - 1][indice_j - 1] = 3478: (*((integer8 *) (*s_objet_1).objet)); 3479: } 3480: else if ((*s_objet_1).type == REL) 3481: { 3482: /* 3483: * Conversion de la matrice en matrice réelle 3484: */ 3485: 3486: tampon = (void *) ((integer8 **) (*((struct_matrice *) 3487: (*s_objet_3).objet)).tableau); 3488: 3489: (*((struct_matrice *) (*s_objet_3).objet)).type = 'R'; 3490: (*s_objet_3).type = MRL; 3491: 3492: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau 3493: = malloc((*((struct_matrice *) 3494: (*s_objet_3).objet)).nombre_lignes * sizeof(real8 *))) 3495: == NULL) 3496: { 3497: (*s_etat_processus).erreur_systeme = 3498: d_es_allocation_memoire; 3499: return; 3500: } 3501: 3502: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet)) 3503: .nombre_lignes; i++) 3504: { 3505: if ((((real8 **) (*((struct_matrice *) 3506: (*s_objet_3).objet)).tableau)[i] 3507: = malloc((*((struct_matrice *) 3508: (*s_objet_3).objet)).nombre_colonnes * 3509: sizeof(real8))) == NULL) 3510: { 3511: (*s_etat_processus).erreur_systeme = 3512: d_es_allocation_memoire; 3513: return; 3514: } 3515: 3516: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet)) 3517: .nombre_colonnes; j++) 3518: { 3519: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet)) 3520: .tableau)[i][j] = (real8) (((integer8 **) 3521: tampon)[i][j]); 3522: } 3523: 3524: free(((integer8 **) tampon)[i]); 3525: } 3526: 3527: free((integer8 **) tampon); 3528: 3529: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet)) 3530: .tableau)[indice_i - 1][indice_j - 1] = (*((real8 *) 3531: (*s_objet_1).objet)); 3532: } 3533: else if ((*s_objet_1).type == CPL) 3534: { 3535: /* 3536: * Conversion de la matrice en matrice complexe 3537: */ 3538: 3539: tampon = (void *) ((integer8 **) (*((struct_matrice *) 3540: (*s_objet_3).objet)).tableau); 3541: 3542: (*((struct_matrice *) (*s_objet_3).objet)).type = 'C'; 3543: (*s_objet_3).type = MCX; 3544: 3545: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau 3546: = malloc((*((struct_matrice *) 3547: (*s_objet_3).objet)).nombre_lignes * 3548: sizeof(struct_complexe16 *))) == NULL) 3549: { 3550: (*s_etat_processus).erreur_systeme = 3551: d_es_allocation_memoire; 3552: return; 3553: } 3554: 3555: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet)) 3556: .nombre_lignes; i++) 3557: { 3558: if ((((struct_complexe16 **) (*((struct_matrice *) 3559: (*s_objet_3).objet)).tableau)[i] 3560: = malloc((*((struct_matrice *) 3561: (*s_objet_3).objet)).nombre_colonnes * 3562: sizeof(struct_complexe16))) == NULL) 3563: { 3564: (*s_etat_processus).erreur_systeme = 3565: d_es_allocation_memoire; 3566: return; 3567: } 3568: 3569: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet)) 3570: .nombre_colonnes; j++) 3571: { 3572: ((struct_complexe16 **) (*((struct_matrice *) 3573: (*s_objet_3).objet)).tableau)[i][j] 3574: .partie_reelle = (real8) (((integer8 **) 3575: tampon)[i][j]); 3576: ((struct_complexe16 **) (*((struct_matrice *) 3577: (*s_objet_3).objet)).tableau)[i][j] 3578: .partie_imaginaire = (real8) 0; 3579: } 3580: 3581: free(((integer8 **) tampon)[i]); 3582: } 3583: 3584: free((integer8 **) tampon); 3585: 3586: ((struct_complexe16 **) (*((struct_matrice *) 3587: (*s_objet_3).objet)).tableau)[indice_i - 1] 3588: [indice_j - 1].partie_reelle = (*((struct_complexe16 *) 3589: (*s_objet_1).objet)).partie_reelle; 3590: ((struct_complexe16 **) (*((struct_matrice *) 3591: (*s_objet_3).objet)).tableau)[indice_i - 1] 3592: [indice_j - 1].partie_imaginaire = 3593: (*((struct_complexe16 *) 3594: (*s_objet_1).objet)).partie_imaginaire; 3595: } 3596: else 3597: { 3598: liberation(s_etat_processus, s_objet_1); 3599: liberation(s_etat_processus, s_objet_2); 3600: liberation(s_etat_processus, s_objet_3); 3601: 3602: (*s_etat_processus).erreur_execution = 3603: d_ex_erreur_type_argument; 3604: return; 3605: } 3606: } 3607: else if ((*s_objet_3).type == MRL) 3608: { 3609: /* 3610: * Matrice de réels 3611: */ 3612: 3613: if ((*s_objet_1).type == INT) 3614: { 3615: /* 3616: * Conversion de l'élément à insérer en réel 3617: */ 3618: 3619: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet)) 3620: .tableau)[indice_i - 1][indice_j - 1] = 3621: (real8) (*((integer8 *) (*s_objet_1).objet)); 3622: } 3623: else if ((*s_objet_1).type == REL) 3624: { 3625: /* 3626: * Aucune conversion de type 3627: */ 3628: 3629: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet)) 3630: .tableau)[indice_i - 1][indice_j - 1] = (*((real8 *) 3631: (*s_objet_1).objet)); 3632: } 3633: else if ((*s_objet_1).type == CPL) 3634: { 3635: /* 3636: * Conversion de la matrice en matrice complexe 3637: */ 3638: 3639: tampon = (void *) ((real8 **) (*((struct_matrice *) 3640: (*s_objet_3).objet)).tableau); 3641: 3642: (*((struct_matrice *) (*s_objet_3).objet)).type = 'C'; 3643: (*s_objet_3).type = MCX; 3644: 3645: if (((*((struct_matrice *) (*s_objet_3).objet)).tableau 3646: = malloc((*((struct_matrice *) 3647: (*s_objet_3).objet)).nombre_lignes * 3648: sizeof(struct_complexe16 *))) == NULL) 3649: { 3650: (*s_etat_processus).erreur_systeme = 3651: d_es_allocation_memoire; 3652: return; 3653: } 3654: 3655: for(i = 0; i < (*((struct_matrice *) (*s_objet_3).objet)) 3656: .nombre_lignes; i++) 3657: { 3658: if ((((struct_complexe16 **) (*((struct_matrice *) 3659: (*s_objet_3).objet)).tableau)[i] 3660: = malloc((*((struct_matrice *) 3661: (*s_objet_3).objet)).nombre_colonnes * 3662: sizeof(struct_complexe16))) == NULL) 3663: { 3664: (*s_etat_processus).erreur_systeme = 3665: d_es_allocation_memoire; 3666: return; 3667: } 3668: 3669: for(j = 0; j < (*((struct_matrice *) (*s_objet_3).objet)) 3670: .nombre_colonnes; j++) 3671: { 3672: ((struct_complexe16 **) (*((struct_matrice *) 3673: (*s_objet_3).objet)).tableau)[i][j] 3674: .partie_reelle = (((real8 **) 3675: tampon)[i][j]); 3676: ((struct_complexe16 **) (*((struct_matrice *) 3677: (*s_objet_3).objet)).tableau)[i][j] 3678: .partie_imaginaire = (real8) 0; 3679: } 3680: 3681: free(((integer8 **) tampon)[i]); 3682: } 3683: 3684: free((integer8 **) tampon); 3685: 3686: ((struct_complexe16 **) (*((struct_matrice *) 3687: (*s_objet_3).objet)).tableau)[indice_i - 1] 3688: [indice_j - 1].partie_reelle = (*((struct_complexe16 *) 3689: (*s_objet_1).objet)).partie_reelle; 3690: ((struct_complexe16 **) (*((struct_matrice *) 3691: (*s_objet_3).objet)).tableau)[indice_i - 1] 3692: [indice_j - 1].partie_imaginaire = 3693: (*((struct_complexe16 *) 3694: (*s_objet_1).objet)).partie_imaginaire; 3695: } 3696: else 3697: { 3698: liberation(s_etat_processus, s_objet_1); 3699: liberation(s_etat_processus, s_objet_2); 3700: liberation(s_etat_processus, s_objet_3); 3701: 3702: (*s_etat_processus).erreur_execution = 3703: d_ex_erreur_type_argument; 3704: return; 3705: } 3706: } 3707: else 3708: { 3709: /* 3710: * Matrice de complexes 3711: */ 3712: 3713: if ((*s_objet_1).type == INT) 3714: { 3715: /* 3716: * Conversion de l'élément à insérer en complexe 3717: */ 3718: 3719: ((struct_complexe16 **) (*((struct_matrice *) 3720: (*s_objet_3).objet)).tableau)[indice_i - 1] 3721: [indice_j - 1].partie_reelle = (real8) (*((integer8 *) 3722: (*s_objet_1).objet)); 3723: ((struct_complexe16 **) (*((struct_matrice *) 3724: (*s_objet_3).objet)).tableau)[indice_i - 1] 3725: [indice_j - 1].partie_imaginaire = (real8) 0; 3726: } 3727: else if ((*s_objet_1).type == REL) 3728: { 3729: /* 3730: * Conversion de l'élément à insérer en complexe 3731: */ 3732: 3733: ((struct_complexe16 **) (*((struct_matrice *) 3734: (*s_objet_3).objet)).tableau)[indice_i - 1] 3735: [indice_j - 1].partie_reelle = 3736: (*((real8 *) (*s_objet_1).objet)); 3737: ((struct_complexe16 **) (*((struct_matrice *) 3738: (*s_objet_3).objet)).tableau)[indice_i - 1] 3739: [indice_j - 1].partie_imaginaire = (real8) 0; 3740: } 3741: else if ((*s_objet_1).type == CPL) 3742: { 3743: /* 3744: * Aucune conversion de type 3745: */ 3746: 3747: ((struct_complexe16 **) (*((struct_matrice *) 3748: (*s_objet_3).objet)).tableau)[indice_i - 1] 3749: [indice_j - 1].partie_reelle = (*((struct_complexe16 *) 3750: (*s_objet_1).objet)).partie_reelle; 3751: ((struct_complexe16 **) (*((struct_matrice *) 3752: (*s_objet_3).objet)).tableau)[indice_i - 1] 3753: [indice_j - 1].partie_imaginaire = 3754: (*((struct_complexe16 *) 3755: (*s_objet_1).objet)).partie_imaginaire; 3756: } 3757: else 3758: { 3759: liberation(s_etat_processus, s_objet_1); 3760: liberation(s_etat_processus, s_objet_2); 3761: liberation(s_etat_processus, s_objet_3); 3762: 3763: (*s_etat_processus).erreur_execution = 3764: d_ex_erreur_type_argument; 3765: return; 3766: } 3767: } 3768: 3769: liberation(s_etat_processus, s_objet_1); 3770: 3771: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 3772: s_objet_3) == d_erreur) 3773: { 3774: return; 3775: } 3776: 3777: if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *) 3778: (*s_objet_2).objet)).suivant).donnee).objet))) > (integer8) 3779: (*((struct_matrice *) (*s_objet_3).objet)).nombre_colonnes) 3780: { 3781: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_2) 3782: .objet)).suivant).donnee).objet)) = 1; 3783: 3784: if ((++(*((integer8 *) (*(*((struct_liste_chainee *) 3785: (*s_objet_2).objet)).donnee).objet))) > (integer8) 3786: (*((struct_matrice *) (*s_objet_3).objet)).nombre_lignes) 3787: { 3788: (*((integer8 *) (*(*((struct_liste_chainee *) 3789: (*s_objet_2).objet)).donnee).objet)) = 1; 3790: } 3791: } 3792: 3793: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 3794: s_objet_2) == d_erreur) 3795: { 3796: return; 3797: } 3798: } 3799: 3800: /* 3801: -------------------------------------------------------------------------------- 3802: Traitement des éléments des listes 3803: -------------------------------------------------------------------------------- 3804: */ 3805: 3806: else if ((*s_objet_3).type == LST) 3807: { 3808: if ((*s_objet_2).type != INT) 3809: { 3810: liberation(s_etat_processus, s_objet_1); 3811: liberation(s_etat_processus, s_objet_2); 3812: liberation(s_etat_processus, s_objet_3); 3813: 3814: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 3815: return; 3816: } 3817: 3818: indice_i = (*((integer8 *) (*s_objet_2).objet)); 3819: indice_j = 1; 3820: 3821: if ((*s_objet_3).nombre_occurrences > 1) 3822: { 3823: if ((s_copie_3 = copie_objet(s_etat_processus, s_objet_3, 'N')) 3824: == NULL) 3825: { 3826: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3827: return; 3828: } 3829: 3830: liberation(s_etat_processus, s_objet_3); 3831: s_objet_3 = s_copie_3; 3832: } 3833: 3834: l_element_courant = (*s_objet_3).objet; 3835: nombre_elements = 0; 3836: 3837: while(l_element_courant != NULL) 3838: { 3839: l_element_courant = (*l_element_courant).suivant; 3840: nombre_elements++; 3841: } 3842: 3843: l_element_courant = (*s_objet_3).objet; 3844: 3845: while((l_element_courant != NULL) && (indice_j != indice_i)) 3846: { 3847: l_element_courant = (*l_element_courant).suivant; 3848: indice_j++; 3849: } 3850: 3851: if (l_element_courant != NULL) 3852: { 3853: liberation(s_etat_processus, (*l_element_courant).donnee); 3854: (*l_element_courant).donnee = s_objet_1; 3855: } 3856: else 3857: { 3858: liberation(s_etat_processus, s_objet_1); 3859: liberation(s_etat_processus, s_objet_2); 3860: liberation(s_etat_processus, s_objet_3); 3861: 3862: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 3863: return; 3864: } 3865: 3866: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 3867: s_objet_3) == d_erreur) 3868: { 3869: return; 3870: } 3871: 3872: (*((integer8 *) (*s_objet_2).objet)) = 3873: (indice_i % nombre_elements) + 1; 3874: 3875: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 3876: s_objet_2) == d_erreur) 3877: { 3878: return; 3879: } 3880: } 3881: 3882: /* 3883: -------------------------------------------------------------------------------- 3884: Traitement des noms 3885: -------------------------------------------------------------------------------- 3886: */ 3887: 3888: else if ((*s_objet_3).type == NOM) 3889: { 3890: variable_partagee = d_faux; 3891: 3892: if (recherche_variable(s_etat_processus, (*((struct_nom *) 3893: (*s_objet_3).objet)).nom) == d_faux) 3894: { 3895: (*s_etat_processus).erreur_systeme = d_es; 3896: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; 3897: 3898: liberation(s_etat_processus, s_objet_1); 3899: liberation(s_etat_processus, s_objet_2); 3900: liberation(s_etat_processus, s_objet_3); 3901: 3902: return; 3903: } 3904: 3905: if ((*(*s_etat_processus).pointeur_variable_courante) 3906: .variable_verrouillee == d_vrai) 3907: { 3908: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee; 3909: 3910: liberation(s_etat_processus, s_objet_1); 3911: liberation(s_etat_processus, s_objet_2); 3912: liberation(s_etat_processus, s_objet_3); 3913: 3914: return; 3915: } 3916: 3917: s_objet_4 = (*(*s_etat_processus).pointeur_variable_courante).objet; 3918: 3919: if (s_objet_4 == NULL) 3920: { 3921: if (pthread_mutex_lock(&((*(*s_etat_processus) 3922: .s_liste_variables_partagees).mutex)) != 0) 3923: { 3924: (*s_etat_processus).erreur_systeme = d_es_processus; 3925: return; 3926: } 3927: 3928: if (recherche_variable_partagee(s_etat_processus, 3929: (*(*s_etat_processus).pointeur_variable_courante).nom, 3930: (*(*s_etat_processus).pointeur_variable_courante) 3931: .variable_partagee, (*(*s_etat_processus) 3932: .pointeur_variable_courante).origine) == d_faux) 3933: { 3934: if (pthread_mutex_unlock(&((*(*s_etat_processus) 3935: .s_liste_variables_partagees).mutex)) != 0) 3936: { 3937: (*s_etat_processus).erreur_systeme = d_es_processus; 3938: return; 3939: } 3940: 3941: (*s_etat_processus).erreur_systeme = d_es; 3942: (*s_etat_processus).erreur_execution = 3943: d_ex_variable_non_definie; 3944: 3945: liberation(s_etat_processus, s_objet_1); 3946: liberation(s_etat_processus, s_objet_2); 3947: liberation(s_etat_processus, s_objet_3); 3948: 3949: return; 3950: } 3951: 3952: s_objet_4 = (*(*s_etat_processus).s_liste_variables_partagees) 3953: .table[(*(*s_etat_processus).s_liste_variables_partagees) 3954: .position_variable].objet; 3955: variable_partagee = d_vrai; 3956: } 3957: 3958: if (((*s_objet_4).type == VIN) || 3959: ((*s_objet_4).type == VRL) || 3960: ((*s_objet_4).type == VCX)) 3961: { 3962: if ((*s_objet_2).type != LST) 3963: { 3964: if (variable_partagee == d_vrai) 3965: { 3966: if (pthread_mutex_unlock(&((*(*s_etat_processus) 3967: .s_liste_variables_partagees).mutex)) != 0) 3968: { 3969: (*s_etat_processus).erreur_systeme = d_es_processus; 3970: return; 3971: } 3972: } 3973: 3974: liberation(s_etat_processus, s_objet_1); 3975: liberation(s_etat_processus, s_objet_2); 3976: liberation(s_etat_processus, s_objet_3); 3977: 3978: (*s_etat_processus).erreur_execution = 3979: d_ex_erreur_type_argument; 3980: return; 3981: } 3982: 3983: l_element_courant = (*s_objet_2).objet; 3984: nombre_dimensions = 0; 3985: 3986: while(l_element_courant != NULL) 3987: { 3988: nombre_dimensions++; 3989: l_element_courant = (*l_element_courant).suivant; 3990: } 3991: 3992: if (nombre_dimensions != 1) 3993: { 3994: if (variable_partagee == d_vrai) 3995: { 3996: if (pthread_mutex_unlock(&((*(*s_etat_processus) 3997: .s_liste_variables_partagees).mutex)) != 0) 3998: { 3999: (*s_etat_processus).erreur_systeme = d_es_processus; 4000: return; 4001: } 4002: } 4003: 4004: liberation(s_etat_processus, s_objet_1); 4005: liberation(s_etat_processus, s_objet_2); 4006: liberation(s_etat_processus, s_objet_3); 4007: 4008: (*s_etat_processus).erreur_execution = 4009: d_ex_dimensions_invalides; 4010: return; 4011: } 4012: 4013: l_element_courant = (*s_objet_2).objet; 4014: 4015: if ((*(*l_element_courant).donnee).type != INT) 4016: { 4017: if (variable_partagee == d_vrai) 4018: { 4019: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4020: .s_liste_variables_partagees).mutex)) != 0) 4021: { 4022: (*s_etat_processus).erreur_systeme = d_es_processus; 4023: return; 4024: } 4025: } 4026: 4027: liberation(s_etat_processus, s_objet_1); 4028: liberation(s_etat_processus, s_objet_2); 4029: liberation(s_etat_processus, s_objet_3); 4030: 4031: (*s_etat_processus).erreur_execution = 4032: d_ex_erreur_type_argument; 4033: return; 4034: } 4035: 4036: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0) 4037: { 4038: if (variable_partagee == d_vrai) 4039: { 4040: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4041: .s_liste_variables_partagees).mutex)) != 0) 4042: { 4043: (*s_etat_processus).erreur_systeme = d_es_processus; 4044: return; 4045: } 4046: } 4047: 4048: liberation(s_etat_processus, s_objet_1); 4049: liberation(s_etat_processus, s_objet_2); 4050: liberation(s_etat_processus, s_objet_3); 4051: 4052: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 4053: return; 4054: } 4055: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) > 4056: (integer8) (*((struct_vecteur *) (*s_objet_4).objet)) 4057: .taille) 4058: { 4059: if (variable_partagee == d_vrai) 4060: { 4061: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4062: .s_liste_variables_partagees).mutex)) != 0) 4063: { 4064: (*s_etat_processus).erreur_systeme = d_es_processus; 4065: return; 4066: } 4067: } 4068: 4069: liberation(s_etat_processus, s_objet_1); 4070: liberation(s_etat_processus, s_objet_2); 4071: liberation(s_etat_processus, s_objet_3); 4072: 4073: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 4074: return; 4075: } 4076: 4077: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet)); 4078: 4079: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'Q')) 4080: == NULL) 4081: { 4082: if (variable_partagee == d_vrai) 4083: { 4084: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4085: .s_liste_variables_partagees).mutex)) != 0) 4086: { 4087: (*s_etat_processus).erreur_systeme = d_es_processus; 4088: return; 4089: } 4090: } 4091: 4092: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 4093: return; 4094: } 4095: 4096: liberation(s_etat_processus, s_objet_4); 4097: s_objet_4 = s_copie_4; 4098: 4099: if ((*s_objet_4).type == VIN) 4100: { 4101: /* 4102: * Vecteur d'entiers 4103: */ 4104: 4105: if ((*s_objet_1).type == INT) 4106: { 4107: /* 4108: * Aucune conversion de type 4109: */ 4110: 4111: ((integer8 *) (*((struct_vecteur *) (*s_objet_4).objet)) 4112: .tableau)[indice_i - 1] = (*((integer8 *) 4113: (*s_objet_1).objet)); 4114: } 4115: else if ((*s_objet_1).type == REL) 4116: { 4117: /* 4118: * Conversion du vecteur en vecteur réel 4119: */ 4120: 4121: tampon = (void *) ((integer8 *) (*((struct_vecteur *) 4122: (*s_objet_4).objet)).tableau); 4123: 4124: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'R'; 4125: (*s_objet_4).type = VRL; 4126: 4127: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau 4128: = malloc((*((struct_vecteur *) 4129: (*s_objet_4).objet)).taille * sizeof(real8))) 4130: == NULL) 4131: { 4132: if (variable_partagee == d_vrai) 4133: { 4134: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4135: .s_liste_variables_partagees).mutex)) != 0) 4136: { 4137: (*s_etat_processus).erreur_systeme = 4138: d_es_processus; 4139: return; 4140: } 4141: } 4142: 4143: (*s_etat_processus).erreur_systeme = 4144: d_es_allocation_memoire; 4145: return; 4146: } 4147: 4148: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet)) 4149: .taille; i++) 4150: { 4151: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet)) 4152: .tableau)[i] = (real8) (((integer8 *) 4153: tampon)[i]); 4154: } 4155: 4156: free((integer8 *) tampon); 4157: 4158: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet)) 4159: .tableau)[indice_i - 1] = (*((real8 *) 4160: (*s_objet_1).objet)); 4161: } 4162: else if ((*s_objet_1).type == CPL) 4163: { 4164: /* 4165: * Conversion du vecteur en vecteur complexe 4166: */ 4167: 4168: tampon = (void *) ((integer8 *) (*((struct_vecteur *) 4169: (*s_objet_4).objet)).tableau); 4170: 4171: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'C'; 4172: (*s_objet_4).type = VCX; 4173: 4174: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau 4175: = malloc((*((struct_vecteur *) 4176: (*s_objet_4).objet)).taille * 4177: sizeof(struct_complexe16))) == NULL) 4178: { 4179: if (variable_partagee == d_vrai) 4180: { 4181: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4182: .s_liste_variables_partagees).mutex)) != 0) 4183: { 4184: (*s_etat_processus).erreur_systeme = 4185: d_es_processus; 4186: return; 4187: } 4188: } 4189: 4190: (*s_etat_processus).erreur_systeme = 4191: d_es_allocation_memoire; 4192: return; 4193: } 4194: 4195: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet)) 4196: .taille; i++) 4197: { 4198: ((struct_complexe16 *) (*((struct_vecteur *) 4199: (*s_objet_4).objet)).tableau)[i].partie_reelle = 4200: (real8) (((integer8 *) tampon)[i]); 4201: ((struct_complexe16 *) (*((struct_vecteur *) 4202: (*s_objet_4).objet)).tableau)[i] 4203: .partie_imaginaire = (real8) 0; 4204: } 4205: 4206: free((integer8 *) tampon); 4207: 4208: ((struct_complexe16 *) (*((struct_vecteur *) 4209: (*s_objet_4).objet)).tableau)[indice_i - 1] 4210: .partie_reelle = (*((struct_complexe16 *) 4211: (*s_objet_1).objet)).partie_reelle; 4212: ((struct_complexe16 *) (*((struct_vecteur *) 4213: (*s_objet_4).objet)).tableau)[indice_i - 1] 4214: .partie_imaginaire = (*((struct_complexe16 *) 4215: (*s_objet_1).objet)).partie_imaginaire; 4216: } 4217: else 4218: { 4219: if (variable_partagee == d_vrai) 4220: { 4221: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4222: .s_liste_variables_partagees).mutex)) != 0) 4223: { 4224: (*s_etat_processus).erreur_systeme = 4225: d_es_processus; 4226: return; 4227: } 4228: } 4229: 4230: liberation(s_etat_processus, s_objet_1); 4231: liberation(s_etat_processus, s_objet_2); 4232: liberation(s_etat_processus, s_objet_3); 4233: 4234: (*s_etat_processus).erreur_execution = 4235: d_ex_erreur_type_argument; 4236: return; 4237: } 4238: } 4239: else if ((*s_objet_4).type == VRL) 4240: { 4241: /* 4242: * Vecteur de réels 4243: */ 4244: 4245: if ((*s_objet_1).type == INT) 4246: { 4247: /* 4248: * Conversion de l'élément à insérer en réel 4249: */ 4250: 4251: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet)) 4252: .tableau)[indice_i - 1] = (real8) (*((integer8 *) 4253: (*s_objet_1).objet)); 4254: } 4255: else if ((*s_objet_1).type == REL) 4256: { 4257: /* 4258: * Aucune conversion de type 4259: */ 4260: 4261: ((real8 *) (*((struct_vecteur *) (*s_objet_4).objet)) 4262: .tableau)[indice_i - 1] = (*((real8 *) 4263: (*s_objet_1).objet)); 4264: } 4265: else if ((*s_objet_1).type == CPL) 4266: { 4267: /* 4268: * Conversion du vecteur en vecteur complexe 4269: */ 4270: 4271: tampon = (void *) ((integer8 *) (*((struct_vecteur *) 4272: (*s_objet_4).objet)).tableau); 4273: 4274: (*((struct_vecteur *) (*s_objet_4).objet)).type = 'C'; 4275: (*s_objet_4).type = VCX; 4276: 4277: if (((*((struct_vecteur *) (*s_objet_4).objet)).tableau 4278: = malloc((*((struct_vecteur *) 4279: (*s_objet_4).objet)).taille * 4280: sizeof(struct_complexe16))) == NULL) 4281: { 4282: if (variable_partagee == d_vrai) 4283: { 4284: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4285: .s_liste_variables_partagees).mutex)) != 0) 4286: { 4287: (*s_etat_processus).erreur_systeme = 4288: d_es_processus; 4289: return; 4290: } 4291: } 4292: 4293: (*s_etat_processus).erreur_systeme = 4294: d_es_allocation_memoire; 4295: return; 4296: } 4297: 4298: for(i = 0; i < (*((struct_vecteur *) (*s_objet_4).objet)) 4299: .taille; i++) 4300: { 4301: ((struct_complexe16 *) (*((struct_vecteur *) 4302: (*s_objet_4).objet)).tableau)[i].partie_reelle = 4303: ((real8 *) tampon)[i]; 4304: ((struct_complexe16 *) (*((struct_vecteur *) 4305: (*s_objet_4).objet)).tableau)[i] 4306: .partie_imaginaire = (real8) 0; 4307: } 4308: 4309: free((real8 *) tampon); 4310: 4311: ((struct_complexe16 *) (*((struct_vecteur *) 4312: (*s_objet_4).objet)).tableau)[indice_i - 1] 4313: .partie_reelle = (*((struct_complexe16 *) 4314: (*s_objet_1).objet)).partie_reelle; 4315: ((struct_complexe16 *) (*((struct_vecteur *) 4316: (*s_objet_4).objet)).tableau)[indice_i - 1] 4317: .partie_imaginaire = (*((struct_complexe16 *) 4318: (*s_objet_1).objet)).partie_imaginaire; 4319: } 4320: else 4321: { 4322: if (variable_partagee == d_vrai) 4323: { 4324: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4325: .s_liste_variables_partagees).mutex)) != 0) 4326: { 4327: (*s_etat_processus).erreur_systeme = 4328: d_es_processus; 4329: return; 4330: } 4331: } 4332: 4333: liberation(s_etat_processus, s_objet_1); 4334: liberation(s_etat_processus, s_objet_2); 4335: liberation(s_etat_processus, s_objet_3); 4336: 4337: (*s_etat_processus).erreur_execution = 4338: d_ex_erreur_type_argument; 4339: return; 4340: } 4341: } 4342: else 4343: { 4344: /* 4345: * Vecteur de complexes 4346: */ 4347: 4348: if ((*s_objet_1).type == INT) 4349: { 4350: /* 4351: * Conversion de l'élément à insérer en complexe 4352: */ 4353: 4354: ((struct_complexe16 *) (*((struct_vecteur *) 4355: (*s_objet_4).objet)).tableau)[indice_i - 1] 4356: .partie_reelle = (real8) (*((integer8 *) 4357: (*s_objet_1).objet)); 4358: ((struct_complexe16 *) (*((struct_vecteur *) 4359: (*s_objet_4).objet)).tableau)[indice_i - 1] 4360: .partie_imaginaire = (real8) 0; 4361: } 4362: else if ((*s_objet_1).type == REL) 4363: { 4364: /* 4365: * Conversion de l'élément à insérer en complexe 4366: */ 4367: 4368: ((struct_complexe16 *) (*((struct_vecteur *) 4369: (*s_objet_4).objet)).tableau)[indice_i - 1] 4370: .partie_reelle = (*((real8 *) (*s_objet_1).objet)); 4371: ((struct_complexe16 *) (*((struct_vecteur *) 4372: (*s_objet_4).objet)).tableau)[indice_i - 1] 4373: .partie_imaginaire = (real8) 0; 4374: } 4375: else if ((*s_objet_1).type == CPL) 4376: { 4377: /* 4378: * Aucune conversion de type 4379: */ 4380: 4381: ((struct_complexe16 *) (*((struct_vecteur *) 4382: (*s_objet_4).objet)).tableau)[indice_i - 1] 4383: .partie_reelle = (*((struct_complexe16 *) 4384: (*s_objet_1).objet)).partie_reelle; 4385: ((struct_complexe16 *) (*((struct_vecteur *) 4386: (*s_objet_4).objet)).tableau)[indice_i - 1] 4387: .partie_imaginaire = (*((struct_complexe16 *) 4388: (*s_objet_1).objet)).partie_imaginaire; 4389: } 4390: else 4391: { 4392: if (variable_partagee == d_vrai) 4393: { 4394: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4395: .s_liste_variables_partagees).mutex)) != 0) 4396: { 4397: (*s_etat_processus).erreur_systeme = 4398: d_es_processus; 4399: return; 4400: } 4401: } 4402: 4403: liberation(s_etat_processus, s_objet_1); 4404: liberation(s_etat_processus, s_objet_2); 4405: liberation(s_etat_processus, s_objet_3); 4406: 4407: (*s_etat_processus).erreur_execution = 4408: d_ex_erreur_type_argument; 4409: return; 4410: } 4411: } 4412: 4413: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = 4414: (indice_i % (*((struct_vecteur *) (*s_objet_4).objet)) 4415: .taille) + 1; 4416: 4417: if (variable_partagee == d_faux) 4418: { 4419: (*(*s_etat_processus).pointeur_variable_courante).objet = 4420: s_objet_4; 4421: } 4422: else 4423: { 4424: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL; 4425: (*(*s_etat_processus).s_liste_variables_partagees) 4426: .table[(*(*s_etat_processus) 4427: .s_liste_variables_partagees).position_variable].objet 4428: = s_objet_4; 4429: 4430: if (variable_partagee == d_vrai) 4431: { 4432: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4433: .s_liste_variables_partagees).mutex)) != 0) 4434: { 4435: (*s_etat_processus).erreur_systeme = d_es_processus; 4436: return; 4437: } 4438: } 4439: } 4440: 4441: liberation(s_etat_processus, s_objet_1); 4442: } 4443: else if (((*s_objet_4).type == MIN) || 4444: ((*s_objet_4).type == MRL) || 4445: ((*s_objet_4).type == MCX)) 4446: { 4447: if ((*s_objet_2).type != LST) 4448: { 4449: if (variable_partagee == d_vrai) 4450: { 4451: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4452: .s_liste_variables_partagees).mutex)) != 0) 4453: { 4454: (*s_etat_processus).erreur_systeme = d_es_processus; 4455: return; 4456: } 4457: } 4458: 4459: liberation(s_etat_processus, s_objet_1); 4460: liberation(s_etat_processus, s_objet_2); 4461: liberation(s_etat_processus, s_objet_3); 4462: 4463: (*s_etat_processus).erreur_execution = 4464: d_ex_erreur_type_argument; 4465: return; 4466: } 4467: 4468: l_element_courant = (*s_objet_2).objet; 4469: nombre_dimensions = 0; 4470: 4471: while(l_element_courant != NULL) 4472: { 4473: nombre_dimensions++; 4474: l_element_courant = (*l_element_courant).suivant; 4475: } 4476: 4477: if (nombre_dimensions != 2) 4478: { 4479: if (variable_partagee == d_vrai) 4480: { 4481: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4482: .s_liste_variables_partagees).mutex)) != 0) 4483: { 4484: (*s_etat_processus).erreur_systeme = d_es_processus; 4485: return; 4486: } 4487: } 4488: 4489: liberation(s_etat_processus, s_objet_1); 4490: liberation(s_etat_processus, s_objet_2); 4491: liberation(s_etat_processus, s_objet_3); 4492: 4493: (*s_etat_processus).erreur_execution = 4494: d_ex_dimensions_invalides; 4495: return; 4496: } 4497: 4498: l_element_courant = (*s_objet_2).objet; 4499: 4500: indice_i = 0; 4501: indice_j = 0; 4502: 4503: while(l_element_courant != NULL) 4504: { 4505: if ((*(*l_element_courant).donnee).type != INT) 4506: { 4507: if (variable_partagee == d_vrai) 4508: { 4509: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4510: .s_liste_variables_partagees).mutex)) != 0) 4511: { 4512: (*s_etat_processus).erreur_systeme = d_es_processus; 4513: return; 4514: } 4515: } 4516: 4517: liberation(s_etat_processus, s_objet_1); 4518: liberation(s_etat_processus, s_objet_2); 4519: liberation(s_etat_processus, s_objet_3); 4520: 4521: (*s_etat_processus).erreur_execution = 4522: d_ex_erreur_type_argument; 4523: return; 4524: } 4525: 4526: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) 4527: <= 0) 4528: { 4529: if (variable_partagee == d_vrai) 4530: { 4531: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4532: .s_liste_variables_partagees).mutex)) != 0) 4533: { 4534: (*s_etat_processus).erreur_systeme = d_es_processus; 4535: return; 4536: } 4537: } 4538: 4539: liberation(s_etat_processus, s_objet_1); 4540: liberation(s_etat_processus, s_objet_2); 4541: liberation(s_etat_processus, s_objet_3); 4542: 4543: (*s_etat_processus).erreur_execution = 4544: d_ex_argument_invalide; 4545: return; 4546: } 4547: 4548: if (indice_i == 0) 4549: { 4550: indice_i = (*((integer8 *) 4551: (*(*l_element_courant).donnee).objet)); 4552: } 4553: else 4554: { 4555: indice_j = (*((integer8 *) 4556: (*(*l_element_courant).donnee).objet)); 4557: } 4558: 4559: l_element_courant = (*l_element_courant).suivant; 4560: } 4561: 4562: if ((indice_i > (*((struct_matrice *) (*s_objet_4).objet)) 4563: .nombre_lignes) || (indice_j > (*((struct_matrice *) 4564: (*s_objet_4).objet)).nombre_colonnes)) 4565: { 4566: if (variable_partagee == d_vrai) 4567: { 4568: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4569: .s_liste_variables_partagees).mutex)) != 0) 4570: { 4571: (*s_etat_processus).erreur_systeme = d_es_processus; 4572: return; 4573: } 4574: } 4575: 4576: liberation(s_etat_processus, s_objet_1); 4577: liberation(s_etat_processus, s_objet_2); 4578: liberation(s_etat_processus, s_objet_3); 4579: 4580: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 4581: return; 4582: } 4583: 4584: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'Q')) 4585: == NULL) 4586: { 4587: if (variable_partagee == d_vrai) 4588: { 4589: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4590: .s_liste_variables_partagees).mutex)) != 0) 4591: { 4592: (*s_etat_processus).erreur_systeme = d_es_processus; 4593: return; 4594: } 4595: } 4596: 4597: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 4598: return; 4599: } 4600: 4601: liberation(s_etat_processus, s_objet_4); 4602: s_objet_4 = s_copie_4; 4603: 4604: if ((*s_objet_4).type == MIN) 4605: { 4606: /* 4607: * Matrice d'entiers 4608: */ 4609: 4610: if ((*s_objet_1).type == INT) 4611: { 4612: /* 4613: * Aucune conversion de type 4614: */ 4615: 4616: ((integer8 **) (*((struct_matrice *) (*s_objet_4).objet)) 4617: .tableau)[indice_i - 1][indice_j - 1] = 4618: (*((integer8 *) (*s_objet_1).objet)); 4619: } 4620: else if ((*s_objet_1).type == REL) 4621: { 4622: /* 4623: * Conversion de la matrice en matrice réelle 4624: */ 4625: 4626: tampon = (void *) ((integer8 **) (*((struct_matrice *) 4627: (*s_objet_4).objet)).tableau); 4628: 4629: (*((struct_matrice *) (*s_objet_4).objet)).type = 'R'; 4630: (*s_objet_4).type = MRL; 4631: 4632: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau 4633: = malloc((*((struct_matrice *) 4634: (*s_objet_4).objet)).nombre_lignes * 4635: sizeof(real8 *))) == NULL) 4636: { 4637: if (variable_partagee == d_vrai) 4638: { 4639: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4640: .s_liste_variables_partagees).mutex)) != 0) 4641: { 4642: (*s_etat_processus).erreur_systeme = 4643: d_es_processus; 4644: return; 4645: } 4646: } 4647: 4648: (*s_etat_processus).erreur_systeme = 4649: d_es_allocation_memoire; 4650: return; 4651: } 4652: 4653: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet)) 4654: .nombre_lignes; i++) 4655: { 4656: if ((((real8 **) (*((struct_matrice *) 4657: (*s_objet_4).objet)).tableau)[i] 4658: = malloc((*((struct_matrice *) 4659: (*s_objet_4).objet)).nombre_colonnes * 4660: sizeof(real8))) == NULL) 4661: { 4662: if (variable_partagee == d_vrai) 4663: { 4664: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4665: .s_liste_variables_partagees).mutex)) 4666: != 0) 4667: { 4668: (*s_etat_processus).erreur_systeme = 4669: d_es_processus; 4670: return; 4671: } 4672: } 4673: 4674: (*s_etat_processus).erreur_systeme = 4675: d_es_allocation_memoire; 4676: return; 4677: } 4678: 4679: for(j = 0; j < (*((struct_matrice *) 4680: (*s_objet_4).objet)).nombre_colonnes; j++) 4681: { 4682: ((real8 **) (*((struct_matrice *) (*s_objet_4) 4683: .objet)).tableau)[i][j] = (real8) 4684: (((integer8 **) tampon)[i][j]); 4685: } 4686: 4687: free(((integer8 **) tampon)[i]); 4688: } 4689: 4690: free((integer8 **) tampon); 4691: 4692: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet)) 4693: .tableau)[indice_i - 1][indice_j - 1] = 4694: (*((real8 *) (*s_objet_1).objet)); 4695: } 4696: else if ((*s_objet_1).type == CPL) 4697: { 4698: /* 4699: * Conversion de la matrice en matrice complexe 4700: */ 4701: 4702: tampon = (void *) ((integer8 **) (*((struct_matrice *) 4703: (*s_objet_4).objet)).tableau); 4704: 4705: (*((struct_matrice *) (*s_objet_4).objet)).type = 'C'; 4706: (*s_objet_4).type = MCX; 4707: 4708: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau 4709: = malloc((*((struct_matrice *) 4710: (*s_objet_4).objet)).nombre_lignes * 4711: sizeof(struct_complexe16 *))) == NULL) 4712: { 4713: if (variable_partagee == d_vrai) 4714: { 4715: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4716: .s_liste_variables_partagees).mutex)) != 0) 4717: { 4718: (*s_etat_processus).erreur_systeme = 4719: d_es_processus; 4720: return; 4721: } 4722: } 4723: 4724: (*s_etat_processus).erreur_systeme = 4725: d_es_allocation_memoire; 4726: return; 4727: } 4728: 4729: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet)) 4730: .nombre_lignes; i++) 4731: { 4732: if ((((struct_complexe16 **) (*((struct_matrice *) 4733: (*s_objet_4).objet)).tableau)[i] 4734: = malloc((*((struct_matrice *) 4735: (*s_objet_4).objet)).nombre_colonnes * 4736: sizeof(struct_complexe16))) == NULL) 4737: { 4738: if (variable_partagee == d_vrai) 4739: { 4740: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4741: .s_liste_variables_partagees).mutex)) 4742: != 0) 4743: { 4744: (*s_etat_processus).erreur_systeme = 4745: d_es_processus; 4746: return; 4747: } 4748: } 4749: 4750: (*s_etat_processus).erreur_systeme = 4751: d_es_allocation_memoire; 4752: return; 4753: } 4754: 4755: for(j = 0; j < (*((struct_matrice *) 4756: (*s_objet_4).objet)).nombre_colonnes; j++) 4757: { 4758: ((struct_complexe16 **) (*((struct_matrice *) 4759: (*s_objet_4).objet)).tableau)[i][j] 4760: .partie_reelle = (real8) (((integer8 **) 4761: tampon)[i][j]); 4762: ((struct_complexe16 **) (*((struct_matrice *) 4763: (*s_objet_4).objet)).tableau)[i][j] 4764: .partie_imaginaire = (real8) 0; 4765: } 4766: 4767: free(((integer8 **) tampon)[i]); 4768: } 4769: 4770: free((integer8 **) tampon); 4771: 4772: ((struct_complexe16 **) (*((struct_matrice *) 4773: (*s_objet_4).objet)).tableau)[indice_i - 1] 4774: [indice_j - 1].partie_reelle = 4775: (*((struct_complexe16 *) 4776: (*s_objet_1).objet)).partie_reelle; 4777: ((struct_complexe16 **) (*((struct_matrice *) 4778: (*s_objet_4).objet)).tableau)[indice_i - 1] 4779: [indice_j - 1].partie_imaginaire = 4780: (*((struct_complexe16 *) 4781: (*s_objet_1).objet)).partie_imaginaire; 4782: } 4783: else 4784: { 4785: if (variable_partagee == d_vrai) 4786: { 4787: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4788: .s_liste_variables_partagees).mutex)) != 0) 4789: { 4790: (*s_etat_processus).erreur_systeme = 4791: d_es_processus; 4792: return; 4793: } 4794: } 4795: 4796: liberation(s_etat_processus, s_objet_1); 4797: liberation(s_etat_processus, s_objet_2); 4798: liberation(s_etat_processus, s_objet_3); 4799: 4800: (*s_etat_processus).erreur_execution = 4801: d_ex_erreur_type_argument; 4802: return; 4803: } 4804: } 4805: else if ((*s_objet_4).type == MRL) 4806: { 4807: /* 4808: * Matrice de réels 4809: */ 4810: 4811: if ((*s_objet_1).type == INT) 4812: { 4813: /* 4814: * Conversion de l'élément à insérer en réel 4815: */ 4816: 4817: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet)) 4818: .tableau)[indice_i - 1][indice_j - 1] = 4819: (real8) (*((integer8 *) (*s_objet_1).objet)); 4820: } 4821: else if ((*s_objet_1).type == REL) 4822: { 4823: /* 4824: * Aucune conversion de type 4825: */ 4826: 4827: ((real8 **) (*((struct_matrice *) (*s_objet_4).objet)) 4828: .tableau)[indice_i - 1][indice_j - 1] = 4829: (*((real8 *) (*s_objet_1).objet)); 4830: } 4831: else if ((*s_objet_1).type == CPL) 4832: { 4833: /* 4834: * Conversion de la matrice en matrice complexe 4835: */ 4836: 4837: tampon = (void *) ((real8 **) (*((struct_matrice *) 4838: (*s_objet_4).objet)).tableau); 4839: 4840: (*((struct_matrice *) (*s_objet_4).objet)).type = 'C'; 4841: (*s_objet_4).type = MCX; 4842: 4843: if (((*((struct_matrice *) (*s_objet_4).objet)).tableau 4844: = malloc((*((struct_matrice *) 4845: (*s_objet_4).objet)).nombre_lignes * 4846: sizeof(struct_complexe16 *))) == NULL) 4847: { 4848: if (variable_partagee == d_vrai) 4849: { 4850: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4851: .s_liste_variables_partagees).mutex)) != 0) 4852: { 4853: (*s_etat_processus).erreur_systeme = 4854: d_es_processus; 4855: return; 4856: } 4857: } 4858: 4859: (*s_etat_processus).erreur_systeme = 4860: d_es_allocation_memoire; 4861: return; 4862: } 4863: 4864: for(i = 0; i < (*((struct_matrice *) (*s_objet_4).objet)) 4865: .nombre_lignes; i++) 4866: { 4867: if ((((struct_complexe16 **) (*((struct_matrice *) 4868: (*s_objet_4).objet)).tableau)[i] 4869: = malloc((*((struct_matrice *) 4870: (*s_objet_4).objet)).nombre_colonnes * 4871: sizeof(struct_complexe16))) == NULL) 4872: { 4873: if (variable_partagee == d_vrai) 4874: { 4875: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4876: .s_liste_variables_partagees).mutex)) 4877: != 0) 4878: { 4879: (*s_etat_processus).erreur_systeme = 4880: d_es_processus; 4881: return; 4882: } 4883: } 4884: 4885: (*s_etat_processus).erreur_systeme = 4886: d_es_allocation_memoire; 4887: return; 4888: } 4889: 4890: for(j = 0; j < (*((struct_matrice *) 4891: (*s_objet_4).objet)).nombre_colonnes; j++) 4892: { 4893: ((struct_complexe16 **) (*((struct_matrice *) 4894: (*s_objet_4).objet)).tableau)[i][j] 4895: .partie_reelle = (((real8 **) 4896: tampon)[i][j]); 4897: ((struct_complexe16 **) (*((struct_matrice *) 4898: (*s_objet_4).objet)).tableau)[i][j] 4899: .partie_imaginaire = (real8) 0; 4900: } 4901: 4902: free(((integer8 **) tampon)[i]); 4903: } 4904: 4905: free((integer8 **) tampon); 4906: 4907: ((struct_complexe16 **) (*((struct_matrice *) 4908: (*s_objet_4).objet)).tableau)[indice_i - 1] 4909: [indice_j - 1].partie_reelle = 4910: (*((struct_complexe16 *) 4911: (*s_objet_1).objet)).partie_reelle; 4912: ((struct_complexe16 **) (*((struct_matrice *) 4913: (*s_objet_4).objet)).tableau)[indice_i - 1] 4914: [indice_j - 1].partie_imaginaire = 4915: (*((struct_complexe16 *) 4916: (*s_objet_1).objet)).partie_imaginaire; 4917: } 4918: else 4919: { 4920: if (variable_partagee == d_vrai) 4921: { 4922: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4923: .s_liste_variables_partagees).mutex)) 4924: != 0) 4925: { 4926: (*s_etat_processus).erreur_systeme = 4927: d_es_processus; 4928: return; 4929: } 4930: } 4931: 4932: liberation(s_etat_processus, s_objet_1); 4933: liberation(s_etat_processus, s_objet_2); 4934: liberation(s_etat_processus, s_objet_3); 4935: 4936: (*s_etat_processus).erreur_execution = 4937: d_ex_erreur_type_argument; 4938: return; 4939: } 4940: } 4941: else 4942: { 4943: /* 4944: * Matrice de complexes 4945: */ 4946: 4947: if ((*s_objet_1).type == INT) 4948: { 4949: /* 4950: * Conversion de l'élément à insérer en complexe 4951: */ 4952: 4953: ((struct_complexe16 **) (*((struct_matrice *) 4954: (*s_objet_4).objet)).tableau)[indice_i - 1] 4955: [indice_j - 1].partie_reelle = (real8) 4956: (*((integer8 *) (*s_objet_1).objet)); 4957: ((struct_complexe16 **) (*((struct_matrice *) 4958: (*s_objet_4).objet)).tableau)[indice_i - 1] 4959: [indice_j - 1].partie_imaginaire = (real8) 0; 4960: } 4961: else if ((*s_objet_1).type == REL) 4962: { 4963: /* 4964: * Conversion de l'élément à insérer en complexe 4965: */ 4966: 4967: ((struct_complexe16 **) (*((struct_matrice *) 4968: (*s_objet_4).objet)).tableau)[indice_i - 1] 4969: [indice_j - 1].partie_reelle = 4970: (*((real8 *) (*s_objet_1).objet)); 4971: ((struct_complexe16 **) (*((struct_matrice *) 4972: (*s_objet_4).objet)).tableau)[indice_i - 1] 4973: [indice_j - 1].partie_imaginaire = (real8) 0; 4974: } 4975: else if ((*s_objet_1).type == CPL) 4976: { 4977: /* 4978: * Aucune conversion de type 4979: */ 4980: 4981: ((struct_complexe16 **) (*((struct_matrice *) 4982: (*s_objet_4).objet)).tableau)[indice_i - 1] 4983: [indice_j - 1].partie_reelle = 4984: (*((struct_complexe16 *) 4985: (*s_objet_1).objet)).partie_reelle; 4986: ((struct_complexe16 **) (*((struct_matrice *) 4987: (*s_objet_4).objet)).tableau)[indice_i - 1] 4988: [indice_j - 1].partie_imaginaire = 4989: (*((struct_complexe16 *) 4990: (*s_objet_1).objet)).partie_imaginaire; 4991: } 4992: else 4993: { 4994: if (variable_partagee == d_vrai) 4995: { 4996: if (pthread_mutex_unlock(&((*(*s_etat_processus) 4997: .s_liste_variables_partagees).mutex)) 4998: != 0) 4999: { 5000: (*s_etat_processus).erreur_systeme = 5001: d_es_processus; 5002: return; 5003: } 5004: } 5005: 5006: liberation(s_etat_processus, s_objet_1); 5007: liberation(s_etat_processus, s_objet_2); 5008: liberation(s_etat_processus, s_objet_3); 5009: 5010: (*s_etat_processus).erreur_execution = 5011: d_ex_erreur_type_argument; 5012: return; 5013: } 5014: } 5015: 5016: if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *) 5017: (*s_objet_2).objet)).suivant).donnee).objet))) > (integer8) 5018: (*((struct_matrice *) (*s_objet_4).objet)).nombre_colonnes) 5019: { 5020: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_2) 5021: .objet)).suivant).donnee).objet)) = 1; 5022: 5023: if ((++(*((integer8 *) (*(*((struct_liste_chainee *) 5024: (*s_objet_2).objet)).donnee).objet))) > (integer8) 5025: (*((struct_matrice *) (*s_objet_4).objet)) 5026: .nombre_lignes) 5027: { 5028: (*((integer8 *) (*(*((struct_liste_chainee *) 5029: (*s_objet_2).objet)).donnee).objet)) = 1; 5030: } 5031: } 5032: 5033: if (variable_partagee == d_faux) 5034: { 5035: (*(*s_etat_processus).pointeur_variable_courante).objet = 5036: s_objet_4; 5037: } 5038: else 5039: { 5040: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL; 5041: (*(*s_etat_processus).s_liste_variables_partagees).table 5042: [(*(*s_etat_processus).s_liste_variables_partagees) 5043: .position_variable].objet = s_objet_4; 5044: 5045: if (variable_partagee == d_vrai) 5046: { 5047: if (pthread_mutex_unlock(&((*(*s_etat_processus) 5048: .s_liste_variables_partagees).mutex)) != 0) 5049: { 5050: (*s_etat_processus).erreur_systeme = 5051: d_es_processus; 5052: return; 5053: } 5054: } 5055: } 5056: 5057: liberation(s_etat_processus, s_objet_1); 5058: } 5059: else if ((*s_objet_4).type == LST) 5060: { 5061: if ((*s_objet_2).type != INT) 5062: { 5063: if (variable_partagee == d_vrai) 5064: { 5065: if (pthread_mutex_unlock(&((*(*s_etat_processus) 5066: .s_liste_variables_partagees).mutex)) != 0) 5067: { 5068: (*s_etat_processus).erreur_systeme = 5069: d_es_processus; 5070: return; 5071: } 5072: } 5073: 5074: liberation(s_etat_processus, s_objet_1); 5075: liberation(s_etat_processus, s_objet_2); 5076: liberation(s_etat_processus, s_objet_3); 5077: 5078: (*s_etat_processus).erreur_execution = 5079: d_ex_erreur_type_argument; 5080: return; 5081: } 5082: 5083: indice_i = (*((integer8 *) (*s_objet_2).objet)); 5084: indice_j = 1; 5085: 5086: if ((*s_objet_4).nombre_occurrences > 1) 5087: { 5088: if ((s_copie_4 = copie_objet(s_etat_processus, s_objet_4, 'N')) 5089: == NULL) 5090: { 5091: if (variable_partagee == d_vrai) 5092: { 5093: if (pthread_mutex_unlock(&((*(*s_etat_processus) 5094: .s_liste_variables_partagees).mutex)) != 0) 5095: { 5096: (*s_etat_processus).erreur_systeme = 5097: d_es_processus; 5098: return; 5099: } 5100: } 5101: 5102: (*s_etat_processus).erreur_systeme = 5103: d_es_allocation_memoire; 5104: return; 5105: } 5106: 5107: liberation(s_etat_processus, s_objet_4); 5108: s_objet_4 = s_copie_4; 5109: } 5110: 5111: l_element_courant = (*s_objet_4).objet; 5112: nombre_elements = 0; 5113: 5114: while(l_element_courant != NULL) 5115: { 5116: l_element_courant = (*l_element_courant).suivant; 5117: nombre_elements++; 5118: } 5119: 5120: l_element_courant = (*s_objet_4).objet; 5121: 5122: while((l_element_courant != NULL) && (indice_j != indice_i)) 5123: { 5124: l_element_courant = (*l_element_courant).suivant; 5125: indice_j++; 5126: } 5127: 5128: if (l_element_courant != NULL) 5129: { 5130: liberation(s_etat_processus, (*l_element_courant).donnee); 5131: (*l_element_courant).donnee = s_objet_1; 5132: } 5133: else 5134: { 5135: if (variable_partagee == d_vrai) 5136: { 5137: if (pthread_mutex_unlock(&((*(*s_etat_processus) 5138: .s_liste_variables_partagees).mutex)) != 0) 5139: { 5140: (*s_etat_processus).erreur_systeme = 5141: d_es_processus; 5142: return; 5143: } 5144: } 5145: 5146: liberation(s_etat_processus, s_objet_1); 5147: liberation(s_etat_processus, s_objet_2); 5148: liberation(s_etat_processus, s_objet_3); 5149: 5150: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 5151: return; 5152: } 5153: 5154: (*((integer8 *) (*s_objet_2).objet)) = 5155: (indice_i % nombre_elements) + 1; 5156: 5157: if (variable_partagee == d_faux) 5158: { 5159: (*(*s_etat_processus).pointeur_variable_courante).objet = 5160: s_objet_4; 5161: } 5162: else 5163: { 5164: (*(*s_etat_processus).pointeur_variable_courante).objet = NULL; 5165: (*(*s_etat_processus).s_liste_variables_partagees).table 5166: [(*(*s_etat_processus).s_liste_variables_partagees) 5167: .position_variable].objet = s_objet_4; 5168: 5169: if (variable_partagee == d_vrai) 5170: { 5171: if (pthread_mutex_unlock(&((*(*s_etat_processus) 5172: .s_liste_variables_partagees).mutex)) != 0) 5173: { 5174: (*s_etat_processus).erreur_systeme = 5175: d_es_processus; 5176: return; 5177: } 5178: } 5179: } 5180: } 5181: else 5182: { 5183: if (variable_partagee == d_vrai) 5184: { 5185: if (pthread_mutex_unlock(&((*(*s_etat_processus) 5186: .s_liste_variables_partagees).mutex)) != 0) 5187: { 5188: (*s_etat_processus).erreur_systeme = 5189: d_es_processus; 5190: return; 5191: } 5192: } 5193: 5194: liberation(s_etat_processus, s_objet_1); 5195: liberation(s_etat_processus, s_objet_2); 5196: liberation(s_etat_processus, s_objet_3); 5197: 5198: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 5199: return; 5200: } 5201: 5202: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 5203: s_objet_3) == d_erreur) 5204: { 5205: return; 5206: } 5207: 5208: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 5209: s_objet_2) == d_erreur) 5210: { 5211: return; 5212: } 5213: } 5214: 5215: /* 5216: -------------------------------------------------------------------------------- 5217: Arguments incompatibles 5218: -------------------------------------------------------------------------------- 5219: */ 5220: 5221: else 5222: { 5223: liberation(s_etat_processus, s_objet_1); 5224: liberation(s_etat_processus, s_objet_2); 5225: liberation(s_etat_processus, s_objet_3); 5226: 5227: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 5228: return; 5229: } 5230: 5231: return; 5232: } 5233: 5234: // vim: ts=4