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