![]() ![]() | ![]() |
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 'get' 29: ================================================================================ 30: Entrées : 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_get(struct_processus *s_etat_processus) 40: { 41: logical1 variable_partagee; 42: 43: struct_liste_chainee *l_element_courant; 44: 45: struct_objet *s_objet_1; 46: struct_objet *s_objet_2; 47: struct_objet *s_objet_3; 48: struct_objet *s_objet_element; 49: struct_objet *s_objet_resultat; 50: 51: unsigned long indice_i; 52: unsigned long indice_j; 53: unsigned long nombre_dimensions; 54: 55: (*s_etat_processus).erreur_execution = d_ex; 56: 57: if ((*s_etat_processus).affichage_arguments == 'Y') 58: { 59: printf("\n GET "); 60: 61: if ((*s_etat_processus).langue == 'F') 62: { 63: printf("(prend un élément)\n\n"); 64: } 65: else 66: { 67: printf("(get element)\n\n"); 68: } 69: 70: printf(" 2: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM); 71: printf(" 1: %s\n", d_LST); 72: printf("-> 1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL); 73: 74: printf(" 2: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM); 75: printf(" 1: %s\n", d_LST); 76: printf("-> 1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL); 77: 78: printf(" 2: %s, %s\n", d_TAB, d_NOM); 79: printf(" 1: %s\n", d_LST); 80: printf("-> 1: %s, %s, %s, %s, %s, %s,\n" 81: " %s, %s, %s, %s, %s,\n" 82: " %s, %s, %s, %s, %s,\n" 83: " %s, %s, %s, %s,\n" 84: " %s, %s\n\n", 85: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 86: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, 87: d_SQL, d_SLB, d_PRC, d_MTX); 88: 89: printf(" 2: %s, %s\n", d_LST, d_NOM); 90: printf(" 1: %s\n", d_INT); 91: printf("-> 1: %s, %s, %s, %s, %s, %s,\n" 92: " %s, %s, %s, %s, %s,\n" 93: " %s, %s, %s, %s, %s,\n" 94: " %s, %s, %s, %s,\n" 95: " %s, %s\n", 96: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 97: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, 98: d_SQL, d_SLB, d_PRC, d_MTX); 99: 100: return; 101: } 102: else if ((*s_etat_processus).test_instruction == 'Y') 103: { 104: (*s_etat_processus).nombre_arguments = -1; 105: return; 106: } 107: 108: if (test_cfsf(s_etat_processus, 31) == d_vrai) 109: { 110: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 111: { 112: return; 113: } 114: } 115: 116: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 117: &s_objet_1) == d_erreur) 118: { 119: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 120: return; 121: } 122: 123: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 124: &s_objet_2) == d_erreur) 125: { 126: liberation(s_etat_processus, s_objet_1); 127: 128: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 129: return; 130: } 131: 132: /* 133: -------------------------------------------------------------------------------- 134: Traitement des éléments des vecteurs 135: -------------------------------------------------------------------------------- 136: */ 137: 138: if (((*s_objet_2).type == VIN) || 139: ((*s_objet_2).type == VRL) || 140: ((*s_objet_2).type == VCX)) 141: { 142: if ((*s_objet_1).type != LST) 143: { 144: liberation(s_etat_processus, s_objet_1); 145: liberation(s_etat_processus, s_objet_2); 146: 147: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 148: return; 149: } 150: 151: l_element_courant = (*s_objet_1).objet; 152: nombre_dimensions = 0; 153: 154: while(l_element_courant != NULL) 155: { 156: nombre_dimensions++; 157: l_element_courant = (*l_element_courant).suivant; 158: } 159: 160: if (nombre_dimensions != 1) 161: { 162: liberation(s_etat_processus, s_objet_1); 163: liberation(s_etat_processus, s_objet_2); 164: 165: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 166: return; 167: } 168: 169: l_element_courant = (*s_objet_1).objet; 170: 171: if ((*(*l_element_courant).donnee).type != INT) 172: { 173: liberation(s_etat_processus, s_objet_1); 174: liberation(s_etat_processus, s_objet_2); 175: 176: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 177: return; 178: } 179: 180: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0) 181: { 182: liberation(s_etat_processus, s_objet_1); 183: liberation(s_etat_processus, s_objet_2); 184: 185: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 186: return; 187: } 188: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) > 189: (integer8) (*((struct_vecteur *) (*s_objet_2).objet)).taille) 190: { 191: liberation(s_etat_processus, s_objet_1); 192: liberation(s_etat_processus, s_objet_2); 193: 194: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 195: return; 196: } 197: 198: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet)); 199: 200: if ((*s_objet_2).type == VIN) 201: { 202: /* 203: * Vecteur d'entiers 204: */ 205: 206: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 207: == NULL) 208: { 209: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 210: return; 211: } 212: 213: (*((integer8 *) (*s_objet_resultat).objet)) = 214: ((integer8 *) (*((struct_vecteur *) (*s_objet_2).objet)) 215: .tableau)[indice_i - 1]; 216: } 217: else if ((*s_objet_2).type == VRL) 218: { 219: /* 220: * Vecteur de réels 221: */ 222: 223: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 224: == NULL) 225: { 226: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 227: return; 228: } 229: 230: (*((real8 *) (*s_objet_resultat).objet)) = 231: ((real8 *) (*((struct_vecteur *) (*s_objet_2).objet)) 232: .tableau)[indice_i - 1]; 233: } 234: else 235: { 236: /* 237: * Vecteur de complexes 238: */ 239: 240: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) 241: == NULL) 242: { 243: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 244: return; 245: } 246: 247: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle = 248: ((struct_complexe16 *) (*((struct_vecteur *) 249: (*s_objet_2).objet)).tableau)[indice_i - 1].partie_reelle; 250: (*((struct_complexe16 *) (*s_objet_resultat).objet)) 251: .partie_imaginaire = ((struct_complexe16 *) 252: (*((struct_vecteur *) (*s_objet_2).objet)).tableau) 253: [indice_i - 1].partie_imaginaire; 254: } 255: } 256: 257: /* 258: -------------------------------------------------------------------------------- 259: Traitement des éléments des matrices 260: -------------------------------------------------------------------------------- 261: */ 262: 263: else if (((*s_objet_2).type == MIN) || 264: ((*s_objet_2).type == MRL) || 265: ((*s_objet_2).type == MCX)) 266: { 267: if ((*s_objet_1).type != LST) 268: { 269: liberation(s_etat_processus, s_objet_1); 270: liberation(s_etat_processus, s_objet_2); 271: 272: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 273: return; 274: } 275: 276: l_element_courant = (*s_objet_1).objet; 277: nombre_dimensions = 0; 278: 279: while(l_element_courant != NULL) 280: { 281: nombre_dimensions++; 282: l_element_courant = (*l_element_courant).suivant; 283: } 284: 285: if (nombre_dimensions != 2) 286: { 287: liberation(s_etat_processus, s_objet_1); 288: liberation(s_etat_processus, s_objet_2); 289: 290: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 291: return; 292: } 293: 294: l_element_courant = (*s_objet_1).objet; 295: 296: indice_i = 0; 297: indice_j = 0; 298: 299: while(l_element_courant != NULL) 300: { 301: if ((*(*l_element_courant).donnee).type != INT) 302: { 303: liberation(s_etat_processus, s_objet_1); 304: liberation(s_etat_processus, s_objet_2); 305: 306: (*s_etat_processus).erreur_execution = 307: d_ex_erreur_type_argument; 308: return; 309: } 310: 311: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0) 312: { 313: liberation(s_etat_processus, s_objet_1); 314: liberation(s_etat_processus, s_objet_2); 315: 316: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 317: return; 318: } 319: 320: if (indice_i == 0) 321: { 322: indice_i = (*((integer8 *) 323: (*(*l_element_courant).donnee).objet)); 324: } 325: else 326: { 327: indice_j = (*((integer8 *) 328: (*(*l_element_courant).donnee).objet)); 329: } 330: 331: l_element_courant = (*l_element_courant).suivant; 332: } 333: 334: if ((indice_i > (*((struct_matrice *) (*s_objet_2).objet)) 335: .nombre_lignes) || (indice_j > (*((struct_matrice *) 336: (*s_objet_2).objet)).nombre_colonnes)) 337: { 338: liberation(s_etat_processus, s_objet_1); 339: liberation(s_etat_processus, s_objet_2); 340: 341: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 342: return; 343: } 344: 345: if ((*s_objet_2).type == MIN) 346: { 347: /* 348: * Matrice d'entiers 349: */ 350: 351: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 352: == NULL) 353: { 354: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 355: return; 356: } 357: 358: (*((integer8 *) (*s_objet_resultat).objet)) = 359: ((integer8 **) (*((struct_matrice *) (*s_objet_2).objet)) 360: .tableau)[indice_i - 1][indice_j - 1]; 361: } 362: else if ((*s_objet_2).type == MRL) 363: { 364: /* 365: * Matrice de réels 366: */ 367: 368: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 369: == NULL) 370: { 371: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 372: return; 373: } 374: 375: (*((real8 *) (*s_objet_resultat).objet)) = 376: ((real8 **) (*((struct_matrice *) (*s_objet_2).objet)) 377: .tableau)[indice_i - 1][indice_j - 1]; 378: } 379: else 380: { 381: /* 382: * Matrices de complexes 383: */ 384: 385: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) 386: == NULL) 387: { 388: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 389: return; 390: } 391: 392: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle = 393: ((struct_complexe16 **) (*((struct_matrice *) 394: (*s_objet_2).objet)).tableau)[indice_i - 1] 395: [indice_j - 1].partie_reelle; 396: (*((struct_complexe16 *) (*s_objet_resultat).objet)) 397: .partie_imaginaire = ((struct_complexe16 **) 398: (*((struct_matrice *) (*s_objet_2).objet)).tableau) 399: [indice_i - 1][indice_j - 1].partie_imaginaire; 400: } 401: } 402: 403: /* 404: -------------------------------------------------------------------------------- 405: Traitement des listes 406: -------------------------------------------------------------------------------- 407: */ 408: 409: else if ((*s_objet_2).type == LST) 410: { 411: if ((*s_objet_1).type != INT) 412: { 413: liberation(s_etat_processus, s_objet_1); 414: liberation(s_etat_processus, s_objet_2); 415: 416: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 417: return; 418: } 419: 420: indice_i = (*((integer8 *) (*s_objet_1).objet)); 421: indice_j = 1; 422: 423: l_element_courant = (*s_objet_2).objet; 424: 425: while((l_element_courant != NULL) && (indice_j != indice_i)) 426: { 427: l_element_courant = (*l_element_courant).suivant; 428: indice_j++; 429: } 430: 431: if (l_element_courant != NULL) 432: { 433: if ((s_objet_resultat = copie_objet(s_etat_processus, 434: (*l_element_courant).donnee, 'P')) == NULL) 435: { 436: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 437: return; 438: } 439: } 440: else 441: { 442: liberation(s_etat_processus, s_objet_1); 443: liberation(s_etat_processus, s_objet_2); 444: 445: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 446: return; 447: } 448: } 449: 450: /* 451: -------------------------------------------------------------------------------- 452: Traitement des tables 453: -------------------------------------------------------------------------------- 454: */ 455: 456: else if ((*s_objet_2).type == TBL) 457: { 458: if ((*s_objet_1).type != LST) 459: { 460: liberation(s_etat_processus, s_objet_1); 461: liberation(s_etat_processus, s_objet_2); 462: 463: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 464: return; 465: } 466: 467: l_element_courant = (*s_objet_1).objet; 468: s_objet_element = s_objet_2; 469: 470: while(l_element_courant != NULL) 471: { 472: if ((*(*l_element_courant).donnee).type != INT) 473: { 474: liberation(s_etat_processus, s_objet_1); 475: liberation(s_etat_processus, s_objet_2); 476: 477: (*s_etat_processus).erreur_execution = 478: d_ex_erreur_type_argument; 479: return; 480: } 481: 482: if ((*s_objet_element).type != TBL) 483: { 484: liberation(s_etat_processus, s_objet_1); 485: liberation(s_etat_processus, s_objet_2); 486: 487: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 488: return; 489: } 490: 491: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet)); 492: 493: if ((indice_i < 1) || (indice_i > (*((struct_tableau *) 494: (*s_objet_element).objet)).nombre_elements)) 495: { 496: liberation(s_etat_processus, s_objet_1); 497: liberation(s_etat_processus, s_objet_2); 498: 499: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 500: return; 501: } 502: 503: s_objet_element = (*((struct_tableau *) (*s_objet_element) 504: .objet)).elements[indice_i - 1]; 505: l_element_courant = (*l_element_courant).suivant; 506: } 507: 508: if ((s_objet_resultat = copie_objet(s_etat_processus, 509: s_objet_element, 'P')) == NULL) 510: { 511: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 512: return; 513: } 514: } 515: 516: /* 517: -------------------------------------------------------------------------------- 518: Traitement des variables 519: -------------------------------------------------------------------------------- 520: */ 521: 522: else if ((*s_objet_2).type == NOM) 523: { 524: variable_partagee = d_faux; 525: 526: if (recherche_variable(s_etat_processus, (*((struct_nom *) 527: (*s_objet_2).objet)).nom) == d_faux) 528: { 529: (*s_etat_processus).erreur_systeme = d_es; 530: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; 531: 532: liberation(s_etat_processus, s_objet_1); 533: liberation(s_etat_processus, s_objet_2); 534: 535: return; 536: } 537: 538: s_objet_3 = (*(*s_etat_processus).pointeur_variable_courante).objet; 539: 540: if (s_objet_3 == NULL) 541: { 542: if (pthread_mutex_lock(&((*(*s_etat_processus) 543: .s_liste_variables_partagees).mutex)) != 0) 544: { 545: (*s_etat_processus).erreur_systeme = d_es_processus; 546: return; 547: } 548: 549: if (recherche_variable_partagee(s_etat_processus, 550: (*(*s_etat_processus).pointeur_variable_courante).nom, 551: (*(*s_etat_processus).pointeur_variable_courante) 552: .variable_partagee, (*(*s_etat_processus) 553: .pointeur_variable_courante).origine) == d_faux) 554: { 555: if (pthread_mutex_unlock(&((*(*s_etat_processus) 556: .s_liste_variables_partagees).mutex)) != 0) 557: { 558: (*s_etat_processus).erreur_systeme = d_es_processus; 559: return; 560: } 561: 562: (*s_etat_processus).erreur_systeme = d_es; 563: (*s_etat_processus).erreur_execution = 564: d_ex_variable_non_definie; 565: 566: liberation(s_etat_processus, s_objet_1); 567: liberation(s_etat_processus, s_objet_2); 568: 569: return; 570: } 571: 572: s_objet_3 = (*(*s_etat_processus).s_liste_variables_partagees) 573: .table[(*(*s_etat_processus).s_liste_variables_partagees) 574: .position_variable].objet; 575: variable_partagee = d_vrai; 576: } 577: 578: if (((*s_objet_3).type == VIN) || 579: ((*s_objet_3).type == VRL) || 580: ((*s_objet_3).type == VCX)) 581: { 582: if ((*s_objet_1).type != LST) 583: { 584: if (variable_partagee == d_vrai) 585: { 586: if (pthread_mutex_unlock(&((*(*s_etat_processus) 587: .s_liste_variables_partagees).mutex)) != 0) 588: { 589: (*s_etat_processus).erreur_systeme = d_es_processus; 590: return; 591: } 592: } 593: 594: liberation(s_etat_processus, s_objet_1); 595: liberation(s_etat_processus, s_objet_2); 596: 597: (*s_etat_processus).erreur_execution = 598: d_ex_erreur_type_argument; 599: return; 600: } 601: 602: l_element_courant = (*s_objet_1).objet; 603: nombre_dimensions = 0; 604: 605: while(l_element_courant != NULL) 606: { 607: nombre_dimensions++; 608: l_element_courant = (*l_element_courant).suivant; 609: } 610: 611: if (nombre_dimensions != 1) 612: { 613: if (variable_partagee == d_vrai) 614: { 615: if (pthread_mutex_unlock(&((*(*s_etat_processus) 616: .s_liste_variables_partagees).mutex)) != 0) 617: { 618: (*s_etat_processus).erreur_systeme = d_es_processus; 619: return; 620: } 621: } 622: 623: liberation(s_etat_processus, s_objet_1); 624: liberation(s_etat_processus, s_objet_2); 625: 626: (*s_etat_processus).erreur_execution = 627: d_ex_dimensions_invalides; 628: return; 629: } 630: 631: l_element_courant = (*s_objet_1).objet; 632: 633: if ((*(*l_element_courant).donnee).type != INT) 634: { 635: if (variable_partagee == d_vrai) 636: { 637: if (pthread_mutex_unlock(&((*(*s_etat_processus) 638: .s_liste_variables_partagees).mutex)) != 0) 639: { 640: (*s_etat_processus).erreur_systeme = d_es_processus; 641: return; 642: } 643: } 644: 645: liberation(s_etat_processus, s_objet_1); 646: liberation(s_etat_processus, s_objet_2); 647: 648: (*s_etat_processus).erreur_execution = 649: d_ex_erreur_type_argument; 650: return; 651: } 652: 653: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0) 654: { 655: if (variable_partagee == d_vrai) 656: { 657: if (pthread_mutex_unlock(&((*(*s_etat_processus) 658: .s_liste_variables_partagees).mutex)) != 0) 659: { 660: (*s_etat_processus).erreur_systeme = d_es_processus; 661: return; 662: } 663: } 664: 665: liberation(s_etat_processus, s_objet_1); 666: liberation(s_etat_processus, s_objet_2); 667: 668: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 669: return; 670: } 671: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) > 672: (integer8) (*((struct_vecteur *) (*s_objet_3).objet)) 673: .taille) 674: { 675: if (variable_partagee == d_vrai) 676: { 677: if (pthread_mutex_unlock(&((*(*s_etat_processus) 678: .s_liste_variables_partagees).mutex)) != 0) 679: { 680: (*s_etat_processus).erreur_systeme = d_es_processus; 681: return; 682: } 683: } 684: 685: liberation(s_etat_processus, s_objet_1); 686: liberation(s_etat_processus, s_objet_2); 687: 688: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 689: return; 690: } 691: 692: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet)); 693: 694: if ((*s_objet_3).type == VIN) 695: { 696: /* 697: * Vecteur d'entiers 698: */ 699: 700: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 701: == NULL) 702: { 703: if (variable_partagee == d_vrai) 704: { 705: if (pthread_mutex_unlock(&((*(*s_etat_processus) 706: .s_liste_variables_partagees).mutex)) != 0) 707: { 708: (*s_etat_processus).erreur_systeme = d_es_processus; 709: return; 710: } 711: } 712: 713: (*s_etat_processus).erreur_systeme 714: = d_es_allocation_memoire; 715: return; 716: } 717: 718: (*((integer8 *) (*s_objet_resultat).objet)) = 719: ((integer8 *) (*((struct_vecteur *) 720: (*s_objet_3).objet)).tableau)[indice_i - 1]; 721: } 722: else if ((*s_objet_3).type == VRL) 723: { 724: /* 725: * Vecteur de réels 726: */ 727: 728: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 729: == NULL) 730: { 731: if (variable_partagee == d_vrai) 732: { 733: if (pthread_mutex_unlock(&((*(*s_etat_processus) 734: .s_liste_variables_partagees).mutex)) != 0) 735: { 736: (*s_etat_processus).erreur_systeme = d_es_processus; 737: return; 738: } 739: } 740: 741: (*s_etat_processus).erreur_systeme 742: = d_es_allocation_memoire; 743: return; 744: } 745: 746: (*((real8 *) (*s_objet_resultat).objet)) = 747: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet)) 748: .tableau)[indice_i - 1]; 749: } 750: else 751: { 752: /* 753: * Vecteur de complexes 754: */ 755: 756: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) 757: == NULL) 758: { 759: if (variable_partagee == d_vrai) 760: { 761: if (pthread_mutex_unlock(&((*(*s_etat_processus) 762: .s_liste_variables_partagees).mutex)) != 0) 763: { 764: (*s_etat_processus).erreur_systeme = d_es_processus; 765: return; 766: } 767: } 768: 769: (*s_etat_processus).erreur_systeme 770: = d_es_allocation_memoire; 771: return; 772: } 773: 774: (*((struct_complexe16 *) (*s_objet_resultat).objet)) 775: .partie_reelle = ((struct_complexe16 *) 776: (*((struct_vecteur *) (*s_objet_3).objet)) 777: .tableau)[indice_i - 1].partie_reelle; 778: (*((struct_complexe16 *) (*s_objet_resultat).objet)) 779: .partie_imaginaire = ((struct_complexe16 *) 780: (*((struct_vecteur *) (*s_objet_3).objet)).tableau) 781: [indice_i - 1].partie_imaginaire; 782: } 783: } 784: else if (((*s_objet_3).type == MIN) || 785: ((*s_objet_3).type == MRL) || 786: ((*s_objet_3).type == MCX)) 787: { 788: if ((*s_objet_1).type != LST) 789: { 790: if (variable_partagee == d_vrai) 791: { 792: if (pthread_mutex_unlock(&((*(*s_etat_processus) 793: .s_liste_variables_partagees).mutex)) != 0) 794: { 795: (*s_etat_processus).erreur_systeme = d_es_processus; 796: return; 797: } 798: } 799: 800: liberation(s_etat_processus, s_objet_1); 801: liberation(s_etat_processus, s_objet_2); 802: 803: (*s_etat_processus).erreur_execution = 804: d_ex_erreur_type_argument; 805: return; 806: } 807: 808: l_element_courant = (*s_objet_1).objet; 809: nombre_dimensions = 0; 810: 811: while(l_element_courant != NULL) 812: { 813: nombre_dimensions++; 814: l_element_courant = (*l_element_courant).suivant; 815: } 816: 817: if (nombre_dimensions != 2) 818: { 819: if (variable_partagee == d_vrai) 820: { 821: if (pthread_mutex_unlock(&((*(*s_etat_processus) 822: .s_liste_variables_partagees).mutex)) != 0) 823: { 824: (*s_etat_processus).erreur_systeme = d_es_processus; 825: return; 826: } 827: } 828: 829: liberation(s_etat_processus, s_objet_1); 830: liberation(s_etat_processus, s_objet_2); 831: 832: (*s_etat_processus).erreur_execution = 833: d_ex_dimensions_invalides; 834: return; 835: } 836: 837: l_element_courant = (*s_objet_1).objet; 838: 839: indice_i = 0; 840: indice_j = 0; 841: 842: while(l_element_courant != NULL) 843: { 844: if ((*(*l_element_courant).donnee).type != INT) 845: { 846: if (variable_partagee == d_vrai) 847: { 848: if (pthread_mutex_unlock(&((*(*s_etat_processus) 849: .s_liste_variables_partagees).mutex)) != 0) 850: { 851: (*s_etat_processus).erreur_systeme = d_es_processus; 852: return; 853: } 854: } 855: 856: liberation(s_etat_processus, s_objet_1); 857: liberation(s_etat_processus, s_objet_2); 858: 859: (*s_etat_processus).erreur_execution = 860: d_ex_erreur_type_argument; 861: return; 862: } 863: 864: if ((*((integer8 *) (*(*l_element_courant) 865: .donnee).objet)) <= 0) 866: { 867: if (variable_partagee == d_vrai) 868: { 869: if (pthread_mutex_unlock(&((*(*s_etat_processus) 870: .s_liste_variables_partagees).mutex)) != 0) 871: { 872: (*s_etat_processus).erreur_systeme = d_es_processus; 873: return; 874: } 875: } 876: 877: liberation(s_etat_processus, s_objet_1); 878: liberation(s_etat_processus, s_objet_2); 879: 880: (*s_etat_processus).erreur_execution = 881: d_ex_argument_invalide; 882: return; 883: } 884: 885: if (indice_i == 0) 886: { 887: indice_i = (*((integer8 *) 888: (*(*l_element_courant).donnee).objet)); 889: } 890: else 891: { 892: indice_j = (*((integer8 *) 893: (*(*l_element_courant).donnee).objet)); 894: } 895: 896: l_element_courant = (*l_element_courant).suivant; 897: } 898: 899: if ((indice_i > (*((struct_matrice *) (*s_objet_3).objet)) 900: .nombre_lignes) || (indice_j > (*((struct_matrice *) 901: (*s_objet_3).objet)).nombre_colonnes)) 902: { 903: if (variable_partagee == d_vrai) 904: { 905: if (pthread_mutex_unlock(&((*(*s_etat_processus) 906: .s_liste_variables_partagees).mutex)) != 0) 907: { 908: (*s_etat_processus).erreur_systeme = d_es_processus; 909: return; 910: } 911: } 912: 913: liberation(s_etat_processus, s_objet_1); 914: liberation(s_etat_processus, s_objet_2); 915: 916: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 917: return; 918: } 919: 920: if ((*s_objet_3).type == MIN) 921: { 922: /* 923: * Matrice d'entiers 924: */ 925: 926: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 927: == NULL) 928: { 929: if (variable_partagee == d_vrai) 930: { 931: if (pthread_mutex_unlock(&((*(*s_etat_processus) 932: .s_liste_variables_partagees).mutex)) != 0) 933: { 934: (*s_etat_processus).erreur_systeme = d_es_processus; 935: return; 936: } 937: } 938: 939: (*s_etat_processus).erreur_systeme = 940: d_es_allocation_memoire; 941: return; 942: } 943: 944: (*((integer8 *) (*s_objet_resultat).objet)) = 945: ((integer8 **) (*((struct_matrice *) 946: (*s_objet_3).objet)) 947: .tableau)[indice_i - 1][indice_j - 1]; 948: } 949: else if ((*s_objet_3).type == MRL) 950: { 951: /* 952: * Matrice de réels 953: */ 954: 955: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 956: == NULL) 957: { 958: if (variable_partagee == d_vrai) 959: { 960: if (pthread_mutex_unlock(&((*(*s_etat_processus) 961: .s_liste_variables_partagees).mutex)) != 0) 962: { 963: (*s_etat_processus).erreur_systeme = d_es_processus; 964: return; 965: } 966: } 967: 968: (*s_etat_processus).erreur_systeme = 969: d_es_allocation_memoire; 970: return; 971: } 972: 973: (*((real8 *) (*s_objet_resultat).objet)) = 974: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet)) 975: .tableau)[indice_i - 1][indice_j - 1]; 976: } 977: else 978: { 979: /* 980: * Matrices de complexes 981: */ 982: 983: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) 984: == NULL) 985: { 986: if (variable_partagee == d_vrai) 987: { 988: if (pthread_mutex_unlock(&((*(*s_etat_processus) 989: .s_liste_variables_partagees).mutex)) != 0) 990: { 991: (*s_etat_processus).erreur_systeme = d_es_processus; 992: return; 993: } 994: } 995: 996: (*s_etat_processus).erreur_systeme = 997: d_es_allocation_memoire; 998: return; 999: } 1000: 1001: (*((struct_complexe16 *) (*s_objet_resultat).objet)) 1002: .partie_reelle = ((struct_complexe16 **) 1003: (*((struct_matrice *) 1004: (*s_objet_3).objet)).tableau)[indice_i - 1] 1005: [indice_j - 1].partie_reelle; 1006: (*((struct_complexe16 *) (*s_objet_resultat).objet)) 1007: .partie_imaginaire = ((struct_complexe16 **) 1008: (*((struct_matrice *) (*s_objet_3).objet)).tableau) 1009: [indice_i - 1][indice_j - 1].partie_imaginaire; 1010: } 1011: } 1012: else if ((*s_objet_3).type == LST) 1013: { 1014: if ((*s_objet_1).type != INT) 1015: { 1016: if (variable_partagee == d_vrai) 1017: { 1018: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1019: .s_liste_variables_partagees).mutex)) != 0) 1020: { 1021: (*s_etat_processus).erreur_systeme = d_es_processus; 1022: return; 1023: } 1024: } 1025: 1026: liberation(s_etat_processus, s_objet_1); 1027: liberation(s_etat_processus, s_objet_2); 1028: 1029: (*s_etat_processus).erreur_execution = 1030: d_ex_erreur_type_argument; 1031: return; 1032: } 1033: 1034: indice_i = (*((integer8 *) (*s_objet_1).objet)); 1035: indice_j = 1; 1036: 1037: l_element_courant = (*s_objet_3).objet; 1038: 1039: while((l_element_courant != NULL) && (indice_j != indice_i)) 1040: { 1041: l_element_courant = (*l_element_courant).suivant; 1042: indice_j++; 1043: } 1044: 1045: if (l_element_courant != NULL) 1046: { 1047: if ((s_objet_resultat = copie_objet(s_etat_processus, 1048: (*l_element_courant).donnee, 'P')) == NULL) 1049: { 1050: if (variable_partagee == d_vrai) 1051: { 1052: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1053: .s_liste_variables_partagees).mutex)) != 0) 1054: { 1055: (*s_etat_processus).erreur_systeme = d_es_processus; 1056: return; 1057: } 1058: } 1059: 1060: (*s_etat_processus).erreur_systeme = 1061: d_es_allocation_memoire; 1062: return; 1063: } 1064: } 1065: else 1066: { 1067: if (variable_partagee == d_vrai) 1068: { 1069: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1070: .s_liste_variables_partagees).mutex)) != 0) 1071: { 1072: (*s_etat_processus).erreur_systeme = d_es_processus; 1073: return; 1074: } 1075: } 1076: 1077: liberation(s_etat_processus, s_objet_1); 1078: liberation(s_etat_processus, s_objet_2); 1079: 1080: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 1081: return; 1082: } 1083: } 1084: else if ((*s_objet_3).type == TBL) 1085: { 1086: if ((*s_objet_1).type != LST) 1087: { 1088: if (variable_partagee == d_vrai) 1089: { 1090: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1091: .s_liste_variables_partagees).mutex)) != 0) 1092: { 1093: (*s_etat_processus).erreur_systeme = d_es_processus; 1094: return; 1095: } 1096: } 1097: 1098: liberation(s_etat_processus, s_objet_1); 1099: liberation(s_etat_processus, s_objet_2); 1100: 1101: (*s_etat_processus).erreur_execution = 1102: d_ex_erreur_type_argument; 1103: return; 1104: } 1105: 1106: l_element_courant = (*s_objet_1).objet; 1107: s_objet_element = s_objet_3; 1108: 1109: while(l_element_courant != NULL) 1110: { 1111: if ((*(*l_element_courant).donnee).type != INT) 1112: { 1113: if (variable_partagee == d_vrai) 1114: { 1115: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1116: .s_liste_variables_partagees).mutex)) != 0) 1117: { 1118: (*s_etat_processus).erreur_systeme = d_es_processus; 1119: return; 1120: } 1121: } 1122: 1123: liberation(s_etat_processus, s_objet_1); 1124: liberation(s_etat_processus, s_objet_2); 1125: 1126: (*s_etat_processus).erreur_execution = 1127: d_ex_erreur_type_argument; 1128: return; 1129: } 1130: 1131: if ((*s_objet_element).type != TBL) 1132: { 1133: if (variable_partagee == d_vrai) 1134: { 1135: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1136: .s_liste_variables_partagees).mutex)) != 0) 1137: { 1138: (*s_etat_processus).erreur_systeme = d_es_processus; 1139: return; 1140: } 1141: } 1142: 1143: liberation(s_etat_processus, s_objet_1); 1144: liberation(s_etat_processus, s_objet_2); 1145: 1146: (*s_etat_processus).erreur_execution = 1147: d_ex_element_inexistant; 1148: return; 1149: } 1150: 1151: indice_i = (*((integer8 *) (*(*l_element_courant) 1152: .donnee).objet)); 1153: 1154: if ((indice_i < 1) || (indice_i > (*((struct_tableau *) 1155: (*s_objet_element).objet)).nombre_elements)) 1156: { 1157: if (variable_partagee == d_vrai) 1158: { 1159: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1160: .s_liste_variables_partagees).mutex)) != 0) 1161: { 1162: (*s_etat_processus).erreur_systeme = d_es_processus; 1163: return; 1164: } 1165: } 1166: 1167: liberation(s_etat_processus, s_objet_1); 1168: liberation(s_etat_processus, s_objet_2); 1169: 1170: (*s_etat_processus).erreur_execution = 1171: d_ex_element_inexistant; 1172: return; 1173: } 1174: 1175: s_objet_element = (*((struct_tableau *) (*s_objet_element) 1176: .objet)).elements[indice_i - 1]; 1177: l_element_courant = (*l_element_courant).suivant; 1178: } 1179: 1180: if ((s_objet_resultat = copie_objet(s_etat_processus, 1181: s_objet_element, 'P')) == NULL) 1182: { 1183: if (variable_partagee == d_vrai) 1184: { 1185: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1186: .s_liste_variables_partagees).mutex)) != 0) 1187: { 1188: (*s_etat_processus).erreur_systeme = d_es_processus; 1189: return; 1190: } 1191: } 1192: 1193: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1194: return; 1195: } 1196: } 1197: else 1198: { 1199: if (variable_partagee == d_vrai) 1200: { 1201: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1202: .s_liste_variables_partagees).mutex)) != 0) 1203: { 1204: (*s_etat_processus).erreur_systeme = d_es_processus; 1205: return; 1206: } 1207: } 1208: 1209: liberation(s_etat_processus, s_objet_1); 1210: liberation(s_etat_processus, s_objet_2); 1211: 1212: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1213: return; 1214: } 1215: 1216: if (variable_partagee == d_vrai) 1217: { 1218: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1219: .s_liste_variables_partagees).mutex)) != 0) 1220: { 1221: (*s_etat_processus).erreur_systeme = d_es_processus; 1222: return; 1223: } 1224: } 1225: } 1226: 1227: /* 1228: -------------------------------------------------------------------------------- 1229: Type incompatible avec la fonction GET 1230: -------------------------------------------------------------------------------- 1231: */ 1232: 1233: else 1234: { 1235: liberation(s_etat_processus, s_objet_1); 1236: liberation(s_etat_processus, s_objet_2); 1237: 1238: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1239: return; 1240: } 1241: 1242: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1243: s_objet_resultat) == d_erreur) 1244: { 1245: return; 1246: } 1247: 1248: liberation(s_etat_processus, s_objet_1); 1249: liberation(s_etat_processus, s_objet_2); 1250: 1251: return; 1252: } 1253: 1254: 1255: /* 1256: ================================================================================ 1257: Fonction 'geti' 1258: ================================================================================ 1259: Entrées : 1260: -------------------------------------------------------------------------------- 1261: Sorties : 1262: -------------------------------------------------------------------------------- 1263: Effets de bord : néant 1264: ================================================================================ 1265: */ 1266: 1267: void 1268: instruction_geti(struct_processus *s_etat_processus) 1269: { 1270: logical1 variable_partagee; 1271: 1272: struct_liste_chainee *l_element_courant; 1273: 1274: struct_objet *s_copie_1; 1275: struct_objet *s_objet_1; 1276: struct_objet *s_objet_2; 1277: struct_objet *s_objet_3; 1278: struct_objet *s_objet_resultat; 1279: 1280: unsigned long indice_i; 1281: unsigned long indice_j; 1282: unsigned long nombre_dimensions; 1283: unsigned long nombre_elements; 1284: 1285: (*s_etat_processus).erreur_execution = d_ex; 1286: 1287: if ((*s_etat_processus).affichage_arguments == 'Y') 1288: { 1289: printf("\n GETI "); 1290: 1291: if ((*s_etat_processus).langue == 'F') 1292: { 1293: printf("(prend un élément)\n\n"); 1294: } 1295: else 1296: { 1297: printf("(get element)\n\n"); 1298: } 1299: 1300: printf(" 2: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM); 1301: printf(" 1: %s\n", d_LST); 1302: printf("-> 3: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM); 1303: printf(" 2: %s\n", d_LST); 1304: printf(" 1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL); 1305: 1306: printf(" 2: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM); 1307: printf(" 1: %s\n", d_LST); 1308: printf("-> 3: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM); 1309: printf(" 2: %s\n", d_LST); 1310: printf(" 1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL); 1311: 1312: printf(" 2: %s, %s\n", d_LST, d_NOM); 1313: printf(" 1: %s\n", d_INT); 1314: printf("-> 3: %s, %s\n", d_LST, d_NOM); 1315: printf(" 2: %s\n", d_INT); 1316: printf(" 1: %s, %s, %s, %s, %s, %s,\n" 1317: " %s, %s, %s, %s, %s,\n" 1318: " %s, %s, %s, %s, %s,\n" 1319: " %s, %s, %s, %s,\n" 1320: " %s, %s\n", 1321: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 1322: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK, 1323: d_SQL, d_SLB, d_PRC, d_MTX); 1324: 1325: return; 1326: } 1327: else if ((*s_etat_processus).test_instruction == 'Y') 1328: { 1329: (*s_etat_processus).nombre_arguments = -1; 1330: return; 1331: } 1332: 1333: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1334: { 1335: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 1336: { 1337: return; 1338: } 1339: } 1340: 1341: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1342: &s_objet_1) == d_erreur) 1343: { 1344: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1345: return; 1346: } 1347: 1348: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1349: &s_objet_2) == d_erreur) 1350: { 1351: liberation(s_etat_processus, s_objet_1); 1352: 1353: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1354: return; 1355: } 1356: 1357: if ((s_copie_1 = copie_objet(s_etat_processus, s_objet_1, 'O')) == NULL) 1358: { 1359: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1360: return; 1361: } 1362: 1363: liberation(s_etat_processus, s_objet_1); 1364: s_objet_1 = s_copie_1; 1365: 1366: /* 1367: -------------------------------------------------------------------------------- 1368: Traitement des éléments des vecteurs 1369: -------------------------------------------------------------------------------- 1370: */ 1371: 1372: if (((*s_objet_2).type == VIN) || 1373: ((*s_objet_2).type == VRL) || 1374: ((*s_objet_2).type == VCX)) 1375: { 1376: if ((*s_objet_1).type != LST) 1377: { 1378: liberation(s_etat_processus, s_objet_1); 1379: liberation(s_etat_processus, s_objet_2); 1380: 1381: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1382: return; 1383: } 1384: 1385: l_element_courant = (*s_objet_1).objet; 1386: nombre_dimensions = 0; 1387: 1388: while(l_element_courant != NULL) 1389: { 1390: nombre_dimensions++; 1391: l_element_courant = (*l_element_courant).suivant; 1392: } 1393: 1394: if (nombre_dimensions != 1) 1395: { 1396: liberation(s_etat_processus, s_objet_1); 1397: liberation(s_etat_processus, s_objet_2); 1398: 1399: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 1400: return; 1401: } 1402: 1403: l_element_courant = (*s_objet_1).objet; 1404: 1405: if ((*(*l_element_courant).donnee).type != INT) 1406: { 1407: liberation(s_etat_processus, s_objet_1); 1408: liberation(s_etat_processus, s_objet_2); 1409: 1410: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1411: return; 1412: } 1413: 1414: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0) 1415: { 1416: liberation(s_etat_processus, s_objet_1); 1417: liberation(s_etat_processus, s_objet_2); 1418: 1419: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1420: return; 1421: } 1422: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) > 1423: (integer8) (*((struct_vecteur *) (*s_objet_2).objet)).taille) 1424: { 1425: liberation(s_etat_processus, s_objet_1); 1426: liberation(s_etat_processus, s_objet_2); 1427: 1428: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 1429: return; 1430: } 1431: 1432: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet)); 1433: 1434: if ((*s_objet_2).type == VIN) 1435: { 1436: /* 1437: * Vecteur d'entiers 1438: */ 1439: 1440: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 1441: == NULL) 1442: { 1443: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1444: return; 1445: } 1446: 1447: (*((integer8 *) (*s_objet_resultat).objet)) = 1448: ((integer8 *) (*((struct_vecteur *) (*s_objet_2).objet)) 1449: .tableau)[indice_i - 1]; 1450: } 1451: else if ((*s_objet_2).type == VRL) 1452: { 1453: /* 1454: * Vecteur de réels 1455: */ 1456: 1457: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 1458: == NULL) 1459: { 1460: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1461: return; 1462: } 1463: 1464: (*((real8 *) (*s_objet_resultat).objet)) = 1465: ((real8 *) (*((struct_vecteur *) (*s_objet_2).objet)) 1466: .tableau)[indice_i - 1]; 1467: } 1468: else 1469: { 1470: /* 1471: * Vecteur de complexes 1472: */ 1473: 1474: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) 1475: == NULL) 1476: { 1477: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1478: return; 1479: } 1480: 1481: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle = 1482: ((struct_complexe16 *) (*((struct_vecteur *) 1483: (*s_objet_2).objet)).tableau)[indice_i - 1].partie_reelle; 1484: (*((struct_complexe16 *) (*s_objet_resultat).objet)) 1485: .partie_imaginaire = ((struct_complexe16 *) 1486: (*((struct_vecteur *) (*s_objet_2).objet)).tableau) 1487: [indice_i - 1].partie_imaginaire; 1488: } 1489: 1490: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = 1491: (indice_i % (*((struct_vecteur *) (*s_objet_2).objet)).taille) 1492: + 1; 1493: } 1494: 1495: /* 1496: -------------------------------------------------------------------------------- 1497: Traitement des éléments des matrices 1498: -------------------------------------------------------------------------------- 1499: */ 1500: 1501: else if (((*s_objet_2).type == MIN) || 1502: ((*s_objet_2).type == MRL) || 1503: ((*s_objet_2).type == MCX)) 1504: { 1505: if ((*s_objet_1).type != LST) 1506: { 1507: liberation(s_etat_processus, s_objet_1); 1508: liberation(s_etat_processus, s_objet_2); 1509: 1510: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1511: return; 1512: } 1513: 1514: l_element_courant = (*s_objet_1).objet; 1515: nombre_dimensions = 0; 1516: 1517: while(l_element_courant != NULL) 1518: { 1519: nombre_dimensions++; 1520: l_element_courant = (*l_element_courant).suivant; 1521: } 1522: 1523: if (nombre_dimensions != 2) 1524: { 1525: liberation(s_etat_processus, s_objet_1); 1526: liberation(s_etat_processus, s_objet_2); 1527: 1528: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides; 1529: return; 1530: } 1531: 1532: l_element_courant = (*s_objet_1).objet; 1533: 1534: indice_i = 0; 1535: indice_j = 0; 1536: 1537: while(l_element_courant != NULL) 1538: { 1539: if ((*(*l_element_courant).donnee).type != INT) 1540: { 1541: liberation(s_etat_processus, s_objet_1); 1542: liberation(s_etat_processus, s_objet_2); 1543: 1544: (*s_etat_processus).erreur_execution = 1545: d_ex_erreur_type_argument; 1546: return; 1547: } 1548: 1549: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0) 1550: { 1551: liberation(s_etat_processus, s_objet_1); 1552: liberation(s_etat_processus, s_objet_2); 1553: 1554: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1555: return; 1556: } 1557: 1558: if (indice_i == 0) 1559: { 1560: indice_i = (*((integer8 *) 1561: (*(*l_element_courant).donnee).objet)); 1562: } 1563: else 1564: { 1565: indice_j = (*((integer8 *) 1566: (*(*l_element_courant).donnee).objet)); 1567: } 1568: 1569: l_element_courant = (*l_element_courant).suivant; 1570: } 1571: 1572: if ((indice_i > (*((struct_matrice *) (*s_objet_2).objet)) 1573: .nombre_lignes) || (indice_j > (*((struct_matrice *) 1574: (*s_objet_2).objet)).nombre_colonnes)) 1575: { 1576: liberation(s_etat_processus, s_objet_1); 1577: liberation(s_etat_processus, s_objet_2); 1578: 1579: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 1580: return; 1581: } 1582: 1583: if ((*s_objet_2).type == MIN) 1584: { 1585: /* 1586: * Matrice d'entiers 1587: */ 1588: 1589: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 1590: == NULL) 1591: { 1592: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1593: return; 1594: } 1595: 1596: (*((integer8 *) (*s_objet_resultat).objet)) = 1597: ((integer8 **) (*((struct_matrice *) (*s_objet_2).objet)) 1598: .tableau)[indice_i - 1][indice_j - 1]; 1599: } 1600: else if ((*s_objet_2).type == MRL) 1601: { 1602: /* 1603: * Matrice de réels 1604: */ 1605: 1606: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 1607: == NULL) 1608: { 1609: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1610: return; 1611: } 1612: 1613: (*((real8 *) (*s_objet_resultat).objet)) = 1614: ((real8 **) (*((struct_matrice *) (*s_objet_2).objet)) 1615: .tableau)[indice_i - 1][indice_j - 1]; 1616: } 1617: else 1618: { 1619: /* 1620: * Matrices de complexes 1621: */ 1622: 1623: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) 1624: == NULL) 1625: { 1626: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1627: return; 1628: } 1629: 1630: (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle = 1631: ((struct_complexe16 **) (*((struct_matrice *) 1632: (*s_objet_2).objet)).tableau)[indice_i - 1] 1633: [indice_j - 1].partie_reelle; 1634: (*((struct_complexe16 *) (*s_objet_resultat).objet)) 1635: .partie_imaginaire = ((struct_complexe16 **) 1636: (*((struct_matrice *) (*s_objet_2).objet)).tableau) 1637: [indice_i - 1][indice_j - 1].partie_imaginaire; 1638: } 1639: 1640: 1641: if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *) 1642: (*s_objet_1).objet)).suivant).donnee).objet))) > 1643: (integer8) (*((struct_matrice *) (*s_objet_2).objet)) 1644: .nombre_colonnes) 1645: { 1646: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_1) 1647: .objet)).suivant).donnee).objet)) = 1; 1648: 1649: if ((++(*((integer8 *) (*(*((struct_liste_chainee *) 1650: (*s_objet_1).objet)).donnee).objet))) > 1651: (integer8) (*((struct_matrice *) (*s_objet_2).objet)) 1652: .nombre_lignes) 1653: { 1654: (*((integer8 *) (*(*((struct_liste_chainee *) 1655: (*s_objet_1).objet)).donnee).objet)) = 1; 1656: } 1657: } 1658: } 1659: 1660: /* 1661: -------------------------------------------------------------------------------- 1662: Traitement des listes 1663: -------------------------------------------------------------------------------- 1664: */ 1665: 1666: else if ((*s_objet_2).type == LST) 1667: { 1668: if ((*s_objet_1).type != INT) 1669: { 1670: liberation(s_etat_processus, s_objet_1); 1671: liberation(s_etat_processus, s_objet_2); 1672: 1673: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1674: return; 1675: } 1676: 1677: nombre_elements = 0; 1678: l_element_courant = (*s_objet_2).objet; 1679: 1680: while(l_element_courant != NULL) 1681: { 1682: l_element_courant = (*l_element_courant).suivant; 1683: nombre_elements++; 1684: } 1685: 1686: indice_i = (*((integer8 *) (*s_objet_1).objet)); 1687: indice_j = 1; 1688: l_element_courant = (*s_objet_2).objet; 1689: 1690: while((l_element_courant != NULL) && (indice_j != indice_i)) 1691: { 1692: l_element_courant = (*l_element_courant).suivant; 1693: indice_j++; 1694: } 1695: 1696: if (l_element_courant != NULL) 1697: { 1698: if ((s_objet_resultat = copie_objet(s_etat_processus, 1699: (*l_element_courant).donnee, 'O')) == NULL) 1700: { 1701: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1702: return; 1703: } 1704: } 1705: else 1706: { 1707: liberation(s_etat_processus, s_objet_1); 1708: liberation(s_etat_processus, s_objet_2); 1709: 1710: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 1711: return; 1712: } 1713: 1714: (*((integer8 *) (*s_objet_1).objet)) = 1715: (indice_i % nombre_elements) + 1; 1716: } 1717: 1718: /* 1719: -------------------------------------------------------------------------------- 1720: Traitement des variables 1721: -------------------------------------------------------------------------------- 1722: */ 1723: 1724: else if ((*s_objet_2).type == NOM) 1725: { 1726: variable_partagee = d_faux; 1727: 1728: if (recherche_variable(s_etat_processus, (*((struct_nom *) 1729: (*s_objet_2).objet)).nom) == d_faux) 1730: { 1731: (*s_etat_processus).erreur_systeme = d_es; 1732: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; 1733: 1734: liberation(s_etat_processus, s_objet_1); 1735: liberation(s_etat_processus, s_objet_2); 1736: 1737: return; 1738: } 1739: 1740: s_objet_3 = (*(*s_etat_processus).pointeur_variable_courante).objet; 1741: 1742: if (s_objet_3 == NULL) 1743: { 1744: if (pthread_mutex_lock(&((*(*s_etat_processus) 1745: .s_liste_variables_partagees).mutex)) != 0) 1746: { 1747: (*s_etat_processus).erreur_systeme = d_es_processus; 1748: return; 1749: } 1750: 1751: if (recherche_variable_partagee(s_etat_processus, 1752: (*(*s_etat_processus).pointeur_variable_courante).nom, 1753: (*(*s_etat_processus).pointeur_variable_courante) 1754: .variable_partagee, (*(*s_etat_processus) 1755: .pointeur_variable_courante).origine) == d_faux) 1756: { 1757: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1758: .s_liste_variables_partagees).mutex)) != 0) 1759: { 1760: (*s_etat_processus).erreur_systeme = d_es_processus; 1761: return; 1762: } 1763: 1764: (*s_etat_processus).erreur_systeme = d_es; 1765: (*s_etat_processus).erreur_execution = 1766: d_ex_variable_non_definie; 1767: 1768: liberation(s_etat_processus, s_objet_1); 1769: liberation(s_etat_processus, s_objet_2); 1770: 1771: return; 1772: } 1773: 1774: s_objet_3 = (*(*s_etat_processus).s_liste_variables_partagees) 1775: .table[(*(*s_etat_processus).s_liste_variables_partagees) 1776: .position_variable].objet; 1777: variable_partagee = d_vrai; 1778: } 1779: 1780: if (((*s_objet_3).type == VIN) || 1781: ((*s_objet_3).type == VRL) || 1782: ((*s_objet_3).type == VCX)) 1783: { 1784: if ((*s_objet_1).type != LST) 1785: { 1786: if (variable_partagee == d_vrai) 1787: { 1788: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1789: .s_liste_variables_partagees).mutex)) != 0) 1790: { 1791: (*s_etat_processus).erreur_systeme = d_es_processus; 1792: return; 1793: } 1794: } 1795: 1796: liberation(s_etat_processus, s_objet_1); 1797: liberation(s_etat_processus, s_objet_2); 1798: 1799: (*s_etat_processus).erreur_execution = 1800: d_ex_erreur_type_argument; 1801: return; 1802: } 1803: 1804: l_element_courant = (*s_objet_1).objet; 1805: nombre_dimensions = 0; 1806: 1807: while(l_element_courant != NULL) 1808: { 1809: nombre_dimensions++; 1810: l_element_courant = (*l_element_courant).suivant; 1811: } 1812: 1813: if (nombre_dimensions != 1) 1814: { 1815: if (variable_partagee == d_vrai) 1816: { 1817: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1818: .s_liste_variables_partagees).mutex)) != 0) 1819: { 1820: (*s_etat_processus).erreur_systeme = d_es_processus; 1821: return; 1822: } 1823: } 1824: 1825: liberation(s_etat_processus, s_objet_1); 1826: liberation(s_etat_processus, s_objet_2); 1827: 1828: (*s_etat_processus).erreur_execution = 1829: d_ex_dimensions_invalides; 1830: return; 1831: } 1832: 1833: l_element_courant = (*s_objet_1).objet; 1834: 1835: if ((*(*l_element_courant).donnee).type != INT) 1836: { 1837: if (variable_partagee == d_vrai) 1838: { 1839: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1840: .s_liste_variables_partagees).mutex)) != 0) 1841: { 1842: (*s_etat_processus).erreur_systeme = d_es_processus; 1843: return; 1844: } 1845: } 1846: 1847: liberation(s_etat_processus, s_objet_1); 1848: liberation(s_etat_processus, s_objet_2); 1849: 1850: (*s_etat_processus).erreur_execution = 1851: d_ex_erreur_type_argument; 1852: return; 1853: } 1854: 1855: if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0) 1856: { 1857: if (variable_partagee == d_vrai) 1858: { 1859: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1860: .s_liste_variables_partagees).mutex)) != 0) 1861: { 1862: (*s_etat_processus).erreur_systeme = d_es_processus; 1863: return; 1864: } 1865: } 1866: 1867: liberation(s_etat_processus, s_objet_1); 1868: liberation(s_etat_processus, s_objet_2); 1869: 1870: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1871: return; 1872: } 1873: else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) > 1874: (integer8) (*((struct_vecteur *) (*s_objet_3).objet)) 1875: .taille) 1876: { 1877: if (variable_partagee == d_vrai) 1878: { 1879: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1880: .s_liste_variables_partagees).mutex)) != 0) 1881: { 1882: (*s_etat_processus).erreur_systeme = d_es_processus; 1883: return; 1884: } 1885: } 1886: 1887: liberation(s_etat_processus, s_objet_1); 1888: liberation(s_etat_processus, s_objet_2); 1889: 1890: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 1891: return; 1892: } 1893: 1894: indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet)); 1895: 1896: if ((*s_objet_3).type == VIN) 1897: { 1898: /* 1899: * Vecteur d'entiers 1900: */ 1901: 1902: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 1903: == NULL) 1904: { 1905: if (variable_partagee == d_vrai) 1906: { 1907: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1908: .s_liste_variables_partagees).mutex)) != 0) 1909: { 1910: (*s_etat_processus).erreur_systeme = d_es_processus; 1911: return; 1912: } 1913: } 1914: 1915: (*s_etat_processus).erreur_systeme 1916: = d_es_allocation_memoire; 1917: return; 1918: } 1919: 1920: (*((integer8 *) (*s_objet_resultat).objet)) = 1921: ((integer8 *) (*((struct_vecteur *) 1922: (*s_objet_3).objet)).tableau)[indice_i - 1]; 1923: } 1924: else if ((*s_objet_3).type == VRL) 1925: { 1926: /* 1927: * Vecteur de réels 1928: */ 1929: 1930: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 1931: == NULL) 1932: { 1933: if (variable_partagee == d_vrai) 1934: { 1935: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1936: .s_liste_variables_partagees).mutex)) != 0) 1937: { 1938: (*s_etat_processus).erreur_systeme = d_es_processus; 1939: return; 1940: } 1941: } 1942: 1943: (*s_etat_processus).erreur_systeme 1944: = d_es_allocation_memoire; 1945: return; 1946: } 1947: 1948: (*((real8 *) (*s_objet_resultat).objet)) = 1949: ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet)) 1950: .tableau)[indice_i - 1]; 1951: } 1952: else 1953: { 1954: /* 1955: * Vecteur de complexes 1956: */ 1957: 1958: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) 1959: == NULL) 1960: { 1961: if (variable_partagee == d_vrai) 1962: { 1963: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1964: .s_liste_variables_partagees).mutex)) != 0) 1965: { 1966: (*s_etat_processus).erreur_systeme = d_es_processus; 1967: return; 1968: } 1969: } 1970: 1971: (*s_etat_processus).erreur_systeme 1972: = d_es_allocation_memoire; 1973: return; 1974: } 1975: 1976: (*((struct_complexe16 *) (*s_objet_resultat).objet)) 1977: .partie_reelle = ((struct_complexe16 *) 1978: (*((struct_vecteur *) (*s_objet_3).objet)) 1979: .tableau)[indice_i - 1].partie_reelle; 1980: (*((struct_complexe16 *) (*s_objet_resultat).objet)) 1981: .partie_imaginaire = ((struct_complexe16 *) 1982: (*((struct_vecteur *) (*s_objet_3).objet)).tableau) 1983: [indice_i - 1].partie_imaginaire; 1984: } 1985: 1986: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = 1987: (indice_i % (*((struct_vecteur *) (*s_objet_3).objet)) 1988: .taille) + 1; 1989: } 1990: else if (((*s_objet_3).type == MIN) || 1991: ((*s_objet_3).type == MRL) || 1992: ((*s_objet_3).type == MCX)) 1993: { 1994: if ((*s_objet_1).type != LST) 1995: { 1996: if (variable_partagee == d_vrai) 1997: { 1998: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1999: .s_liste_variables_partagees).mutex)) != 0) 2000: { 2001: (*s_etat_processus).erreur_systeme = d_es_processus; 2002: return; 2003: } 2004: } 2005: 2006: liberation(s_etat_processus, s_objet_1); 2007: liberation(s_etat_processus, s_objet_2); 2008: 2009: (*s_etat_processus).erreur_execution = 2010: d_ex_erreur_type_argument; 2011: return; 2012: } 2013: 2014: l_element_courant = (*s_objet_1).objet; 2015: nombre_dimensions = 0; 2016: 2017: while(l_element_courant != NULL) 2018: { 2019: nombre_dimensions++; 2020: l_element_courant = (*l_element_courant).suivant; 2021: } 2022: 2023: if (nombre_dimensions != 2) 2024: { 2025: if (variable_partagee == d_vrai) 2026: { 2027: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2028: .s_liste_variables_partagees).mutex)) != 0) 2029: { 2030: (*s_etat_processus).erreur_systeme = d_es_processus; 2031: return; 2032: } 2033: } 2034: 2035: liberation(s_etat_processus, s_objet_1); 2036: liberation(s_etat_processus, s_objet_2); 2037: 2038: (*s_etat_processus).erreur_execution = 2039: d_ex_dimensions_invalides; 2040: return; 2041: } 2042: 2043: l_element_courant = (*s_objet_1).objet; 2044: 2045: indice_i = 0; 2046: indice_j = 0; 2047: 2048: while(l_element_courant != NULL) 2049: { 2050: if ((*(*l_element_courant).donnee).type != INT) 2051: { 2052: if (variable_partagee == d_vrai) 2053: { 2054: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2055: .s_liste_variables_partagees).mutex)) != 0) 2056: { 2057: (*s_etat_processus).erreur_systeme = d_es_processus; 2058: return; 2059: } 2060: } 2061: 2062: liberation(s_etat_processus, s_objet_1); 2063: liberation(s_etat_processus, s_objet_2); 2064: 2065: (*s_etat_processus).erreur_execution = 2066: d_ex_erreur_type_argument; 2067: return; 2068: } 2069: 2070: if ((*((integer8 *) (*(*l_element_courant) 2071: .donnee).objet)) <= 0) 2072: { 2073: if (variable_partagee == d_vrai) 2074: { 2075: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2076: .s_liste_variables_partagees).mutex)) != 0) 2077: { 2078: (*s_etat_processus).erreur_systeme = d_es_processus; 2079: return; 2080: } 2081: } 2082: 2083: liberation(s_etat_processus, s_objet_1); 2084: liberation(s_etat_processus, s_objet_2); 2085: 2086: (*s_etat_processus).erreur_execution = 2087: d_ex_argument_invalide; 2088: return; 2089: } 2090: 2091: if (indice_i == 0) 2092: { 2093: indice_i = (*((integer8 *) 2094: (*(*l_element_courant).donnee).objet)); 2095: } 2096: else 2097: { 2098: indice_j = (*((integer8 *) 2099: (*(*l_element_courant).donnee).objet)); 2100: } 2101: 2102: l_element_courant = (*l_element_courant).suivant; 2103: } 2104: 2105: if ((indice_i > (*((struct_matrice *) (*s_objet_3).objet)) 2106: .nombre_lignes) || (indice_j > (*((struct_matrice *) 2107: (*s_objet_3).objet)).nombre_colonnes)) 2108: { 2109: if (variable_partagee == d_vrai) 2110: { 2111: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2112: .s_liste_variables_partagees).mutex)) != 0) 2113: { 2114: (*s_etat_processus).erreur_systeme = d_es_processus; 2115: return; 2116: } 2117: } 2118: 2119: liberation(s_etat_processus, s_objet_1); 2120: liberation(s_etat_processus, s_objet_2); 2121: 2122: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 2123: return; 2124: } 2125: 2126: if ((*s_objet_3).type == MIN) 2127: { 2128: /* 2129: * Matrice d'entiers 2130: */ 2131: 2132: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 2133: == NULL) 2134: { 2135: if (variable_partagee == d_vrai) 2136: { 2137: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2138: .s_liste_variables_partagees).mutex)) != 0) 2139: { 2140: (*s_etat_processus).erreur_systeme = d_es_processus; 2141: return; 2142: } 2143: } 2144: 2145: (*s_etat_processus).erreur_systeme = 2146: d_es_allocation_memoire; 2147: return; 2148: } 2149: 2150: (*((integer8 *) (*s_objet_resultat).objet)) = 2151: ((integer8 **) (*((struct_matrice *) 2152: (*s_objet_3).objet)) 2153: .tableau)[indice_i - 1][indice_j - 1]; 2154: } 2155: else if ((*s_objet_3).type == MRL) 2156: { 2157: /* 2158: * Matrice de réels 2159: */ 2160: 2161: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 2162: == NULL) 2163: { 2164: if (variable_partagee == d_vrai) 2165: { 2166: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2167: .s_liste_variables_partagees).mutex)) != 0) 2168: { 2169: (*s_etat_processus).erreur_systeme = d_es_processus; 2170: return; 2171: } 2172: } 2173: 2174: (*s_etat_processus).erreur_systeme = 2175: d_es_allocation_memoire; 2176: return; 2177: } 2178: 2179: (*((real8 *) (*s_objet_resultat).objet)) = 2180: ((real8 **) (*((struct_matrice *) (*s_objet_3).objet)) 2181: .tableau)[indice_i - 1][indice_j - 1]; 2182: } 2183: else 2184: { 2185: /* 2186: * Matrices de complexes 2187: */ 2188: 2189: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) 2190: == NULL) 2191: { 2192: if (variable_partagee == d_vrai) 2193: { 2194: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2195: .s_liste_variables_partagees).mutex)) != 0) 2196: { 2197: (*s_etat_processus).erreur_systeme = d_es_processus; 2198: return; 2199: } 2200: } 2201: 2202: (*s_etat_processus).erreur_systeme = 2203: d_es_allocation_memoire; 2204: return; 2205: } 2206: 2207: (*((struct_complexe16 *) (*s_objet_resultat).objet)) 2208: .partie_reelle = ((struct_complexe16 **) 2209: (*((struct_matrice *) 2210: (*s_objet_3).objet)).tableau)[indice_i - 1] 2211: [indice_j - 1].partie_reelle; 2212: (*((struct_complexe16 *) (*s_objet_resultat).objet)) 2213: .partie_imaginaire = ((struct_complexe16 **) 2214: (*((struct_matrice *) (*s_objet_3).objet)).tableau) 2215: [indice_i - 1][indice_j - 1].partie_imaginaire; 2216: } 2217: 2218: if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *) 2219: (*s_objet_1).objet)).suivant).donnee).objet))) > 2220: (integer8) (*((struct_matrice *) (*s_objet_3).objet)) 2221: .nombre_colonnes) 2222: { 2223: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_1) 2224: .objet)).suivant).donnee).objet)) = 1; 2225: 2226: if ((++(*((integer8 *) (*(*((struct_liste_chainee *) 2227: (*s_objet_1).objet)).donnee).objet))) > 2228: (integer8) (*((struct_matrice *) (*s_objet_3).objet)) 2229: .nombre_lignes) 2230: { 2231: (*((integer8 *) (*(*((struct_liste_chainee *) 2232: (*s_objet_1).objet)).donnee).objet)) = 1; 2233: } 2234: } 2235: } 2236: else if ((*s_objet_3).type == LST) 2237: { 2238: if ((*s_objet_1).type != INT) 2239: { 2240: if (variable_partagee == d_vrai) 2241: { 2242: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2243: .s_liste_variables_partagees).mutex)) != 0) 2244: { 2245: (*s_etat_processus).erreur_systeme = d_es_processus; 2246: return; 2247: } 2248: } 2249: 2250: liberation(s_etat_processus, s_objet_1); 2251: liberation(s_etat_processus, s_objet_2); 2252: 2253: (*s_etat_processus).erreur_execution = 2254: d_ex_erreur_type_argument; 2255: return; 2256: } 2257: 2258: nombre_elements = 0; 2259: l_element_courant = (*s_objet_3).objet; 2260: 2261: while(l_element_courant != NULL) 2262: { 2263: l_element_courant = (*l_element_courant).suivant; 2264: nombre_elements++; 2265: } 2266: 2267: indice_i = (*((integer8 *) (*s_objet_1).objet)); 2268: indice_j = 1; 2269: l_element_courant = (*s_objet_3).objet; 2270: 2271: while((l_element_courant != NULL) && (indice_j != indice_i)) 2272: { 2273: l_element_courant = (*l_element_courant).suivant; 2274: indice_j++; 2275: } 2276: 2277: if (l_element_courant != NULL) 2278: { 2279: if ((s_objet_resultat = copie_objet(s_etat_processus, 2280: (*l_element_courant).donnee, 'O')) == NULL) 2281: { 2282: if (variable_partagee == d_vrai) 2283: { 2284: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2285: .s_liste_variables_partagees).mutex)) != 0) 2286: { 2287: (*s_etat_processus).erreur_systeme = d_es_processus; 2288: return; 2289: } 2290: } 2291: 2292: (*s_etat_processus).erreur_systeme = 2293: d_es_allocation_memoire; 2294: return; 2295: } 2296: } 2297: else 2298: { 2299: if (variable_partagee == d_vrai) 2300: { 2301: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2302: .s_liste_variables_partagees).mutex)) != 0) 2303: { 2304: (*s_etat_processus).erreur_systeme = d_es_processus; 2305: return; 2306: } 2307: } 2308: 2309: liberation(s_etat_processus, s_objet_1); 2310: liberation(s_etat_processus, s_objet_2); 2311: 2312: (*s_etat_processus).erreur_execution = d_ex_element_inexistant; 2313: return; 2314: } 2315: 2316: (*((integer8 *) (*s_objet_1).objet)) = 2317: (indice_i % nombre_elements) + 1; 2318: } 2319: else 2320: { 2321: if (variable_partagee == d_vrai) 2322: { 2323: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2324: .s_liste_variables_partagees).mutex)) != 0) 2325: { 2326: (*s_etat_processus).erreur_systeme = d_es_processus; 2327: return; 2328: } 2329: } 2330: 2331: liberation(s_etat_processus, s_objet_1); 2332: liberation(s_etat_processus, s_objet_2); 2333: 2334: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 2335: return; 2336: } 2337: 2338: if (variable_partagee == d_vrai) 2339: { 2340: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2341: .s_liste_variables_partagees).mutex)) != 0) 2342: { 2343: (*s_etat_processus).erreur_systeme = d_es_processus; 2344: return; 2345: } 2346: } 2347: } 2348: 2349: /* 2350: -------------------------------------------------------------------------------- 2351: Type incompatible avec la fonction GETI 2352: -------------------------------------------------------------------------------- 2353: */ 2354: 2355: else 2356: { 2357: liberation(s_etat_processus, s_objet_1); 2358: liberation(s_etat_processus, s_objet_2); 2359: 2360: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 2361: return; 2362: } 2363: 2364: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2365: s_objet_2) == d_erreur) 2366: { 2367: return; 2368: } 2369: 2370: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2371: s_objet_1) == d_erreur) 2372: { 2373: return; 2374: } 2375: 2376: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2377: s_objet_resultat) == d_erreur) 2378: { 2379: return; 2380: } 2381: 2382: return; 2383: } 2384: 2385: // vim: ts=4