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