![]() ![]() | ![]() |
Correction d'un bug mineur de l'évaluation.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.22 4: Copyright (C) 1989-2015 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: #define TEST(instruction) (fonction == instruction) 26: #define vers_niveau_inferieur instruction_vers_niveau_inferieur 27: #define vers_niveau_superieur instruction_vers_niveau_superieur 28: 29: 30: /* 31: ================================================================================ 32: Evaluation d'une expression 33: ================================================================================ 34: Entrées : 35: structure processus, 36: objet à évaluer (non libéré au retour de la routine) 37: et type ('E' pour 'EVAL', 'I' pour interactif et 'N' pour '->NUM') 38: -------------------------------------------------------------------------------- 39: Sorties : objet évalué au niveau 1 de la pile 40: -------------------------------------------------------------------------------- 41: Effets de bord : néant 42: ================================================================================ 43: */ 44: 45: logical1 46: evaluation(struct_processus *s_etat_processus, struct_objet *s_objet, 47: unsigned char type_evaluation) 48: { 49: integer8 i; 50: integer8 j; 51: integer8 k; 52: integer8 l; 53: integer8 niveau_initial; 54: integer8 nombre_termes; 55: integer8 registre_hauteur_pile_operationnelle; 56: integer8 registre_position_courante; 57: 58: 59: logical1 drapeau_then; 60: logical1 erreur_evaluation; 61: logical1 presence_compteur; 62: logical1 presence_egalite; 63: logical1 presence_fonction; 64: logical1 presence_variable; 65: logical1 presence_variable_partagee; 66: 67: struct_liste_chainee *l_element_courant; 68: struct_liste_chainee *l_element_egalite; 69: struct_liste_chainee *l_element_fonction; 70: struct_liste_chainee *l_liste1; 71: struct_liste_chainee *l_liste2; 72: struct_liste_chainee *l_registre_atome; 73: struct_liste_chainee *l_registre_pile_operationnelle; 74: struct_liste_chainee *l_sous_element_courant; 75: struct_liste_chainee *registre_expression_courante; 76: 77: struct_liste_pile_systeme *pile_systeme_originelle; 78: 79: struct_objet *s_objet_elementaire; 80: struct_objet *s_objet_evalue; 81: struct_objet *s_objet_indice_i; 82: struct_objet *s_objet_indice_j; 83: struct_objet *s_objet_tampon; 84: struct_objet *s_sous_objet; 85: struct_objet *s_copie_variable_partagee; 86: 87: unsigned char autorisation_empilement_programme; 88: unsigned char *instruction_courante; 89: unsigned char *message; 90: unsigned char registre_evaluation_expression_compilee; 91: unsigned char registre_evaluation_forcee; 92: unsigned char registre_instruction_valide; 93: unsigned char registre_mode_execution_programme; 94: unsigned char registre_test; 95: unsigned char registre_test_2; 96: unsigned char registre_type_evaluation; 97: 98: int registre_erreur_execution; 99: int registre_erreur_systeme; 100: int registre_exception; 101: 102: void (*fonction)(); 103: 104: registre_mode_execution_programme = 105: (*s_etat_processus).mode_execution_programme; 106: (*s_etat_processus).mode_execution_programme = 'I'; 107: instruction_courante = (*s_etat_processus).instruction_courante; 108: (*s_etat_processus).erreur_execution = d_ex; 109: 110: erreur_evaluation = d_absence_erreur; 111: s_copie_variable_partagee = NULL; 112: 113: if ((*s_objet).type == NOM) 114: { 115: if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P')) 116: == NULL) 117: { 118: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 119: (*s_etat_processus).instruction_courante = instruction_courante; 120: return(d_erreur); 121: } 122: 123: registre_instruction_valide = (*s_etat_processus).instruction_valide; 124: registre_test = (*s_etat_processus).test_instruction; 125: (*s_etat_processus).test_instruction = 'Y'; 126: (*s_etat_processus).instruction_courante = (*((struct_nom *) 127: (*s_objet_tampon).objet)).nom; 128: 129: analyse(s_etat_processus, NULL); 130: 131: (*s_etat_processus).test_instruction = 'N'; 132: 133: if ((*s_etat_processus).constante_symbolique == 'N') 134: { 135: presence_fonction = d_faux; 136: presence_variable_partagee = d_faux; 137: 138: if (recherche_variable(s_etat_processus, (*((struct_nom *) 139: (*s_objet_tampon).objet)).nom) == d_faux) 140: { 141: (*s_etat_processus).erreur_execution = d_ex; 142: 143: if ((*s_etat_processus).autorisation_nom_implicite == 'N') 144: { 145: if ((*((struct_nom *) (*s_objet_tampon).objet)).symbole == 146: d_faux) 147: { 148: if (test_cfsf(s_etat_processus, 31) == d_vrai) 149: { 150: if (empilement_pile_last(s_etat_processus, 0) 151: == d_erreur) 152: { 153: return(d_erreur); 154: } 155: } 156: 157: erreur_evaluation = d_erreur; 158: (*s_etat_processus).erreur_execution = 159: d_ex_nom_implicite; 160: 161: if (type_evaluation == 'I') 162: { 163: (*s_etat_processus).derniere_erreur_evaluation = 164: (*s_etat_processus).erreur_execution; 165: } 166: } 167: } 168: 169: (*s_etat_processus).erreur_systeme = d_es; 170: presence_variable = d_faux; 171: } 172: else 173: { 174: if ((*s_etat_processus).traitement_symbolique == 'N') 175: { 176: if ((*(*s_etat_processus).pointeur_variable_courante) 177: .objet == NULL) 178: { 179: // Variable partagée 180: 181: presence_variable_partagee = d_faux; 182: 183: if (recherche_variable_partagee(s_etat_processus, 184: (*(*s_etat_processus) 185: .pointeur_variable_courante).nom, 186: (*(*s_etat_processus) 187: .pointeur_variable_courante) 188: .variable_partagee, 'E') != NULL) 189: { 190: presence_variable = d_vrai; 191: presence_variable_partagee = d_vrai; 192: 193: if ((*(*(*s_etat_processus) 194: .pointeur_variable_partagee_courante).objet) 195: .type == ADR) 196: { 197: presence_fonction = d_vrai; 198: } 199: 200: if ((s_copie_variable_partagee = 201: copie_objet(s_etat_processus, 202: (*(*s_etat_processus) 203: .pointeur_variable_partagee_courante).objet, 204: 'P')) == NULL) 205: { 206: (*s_etat_processus).erreur_systeme = 207: d_es_allocation_memoire; 208: 209: if (pthread_mutex_unlock(&((*(*s_etat_processus) 210: .pointeur_variable_partagee_courante) 211: .mutex)) != 0) 212: { 213: (*s_etat_processus).erreur_systeme = 214: d_es_processus; 215: return(d_erreur); 216: } 217: 218: return(d_erreur); 219: } 220: 221: if (pthread_mutex_unlock(&((*(*s_etat_processus) 222: .pointeur_variable_partagee_courante) 223: .mutex)) != 0) 224: { 225: (*s_etat_processus).erreur_systeme = 226: d_es_processus; 227: return(d_erreur); 228: } 229: } 230: else 231: { 232: (*s_etat_processus).erreur_systeme = d_es; 233: presence_variable = d_faux; 234: presence_variable_partagee = d_faux; 235: } 236: } 237: else 238: { 239: // Variable privée 240: 241: presence_variable = d_vrai; 242: 243: if ((*(*(*s_etat_processus).pointeur_variable_courante) 244: .objet).type == ADR) 245: { 246: presence_fonction = d_vrai; 247: } 248: } 249: } 250: else 251: { 252: presence_variable = d_faux; 253: } 254: } 255: 256: liberation(s_etat_processus, s_objet_tampon); 257: 258: if (presence_fonction == d_vrai) 259: { 260: autorisation_empilement_programme = (*s_etat_processus) 261: .autorisation_empilement_programme; 262: registre_position_courante = (*s_etat_processus) 263: .position_courante; 264: 265: empilement_pile_systeme(s_etat_processus); 266: 267: if ((*s_etat_processus).erreur_systeme != d_es) 268: { 269: if (presence_variable_partagee == d_vrai) 270: { 271: liberation(s_etat_processus, s_copie_variable_partagee); 272: } 273: 274: (*s_etat_processus).instruction_courante = 275: instruction_courante; 276: return(d_erreur); 277: } 278: 279: (*(*s_etat_processus).l_base_pile_systeme) 280: .retour_definition = 'Y'; 281: (*(*s_etat_processus).l_base_pile_systeme) 282: .origine_routine_evaluation = 'Y'; 283: 284: (*s_etat_processus).mode_execution_programme = 'Y'; 285: (*s_etat_processus).autorisation_empilement_programme = 'N'; 286: 287: (*(*s_etat_processus).l_base_pile_systeme) 288: .niveau_courant = (*s_etat_processus).niveau_courant; 289: 290: if (presence_variable_partagee == d_faux) 291: { 292: (*s_etat_processus).position_courante = 293: (*((integer8 *) ((*(*(*s_etat_processus) 294: .pointeur_variable_courante).objet).objet))); 295: } 296: else 297: { 298: (*s_etat_processus).position_courante = 299: (*((integer8 *) (*s_copie_variable_partagee) 300: .objet)); 301: liberation(s_etat_processus, s_copie_variable_partagee); 302: } 303: 304: if ((*s_etat_processus).profilage == d_vrai) 305: { 306: profilage(s_etat_processus, 307: (*(*s_etat_processus).pointeur_variable_courante) 308: .nom); 309: 310: if ((*s_etat_processus).erreur_systeme != d_es) 311: { 312: return(d_erreur); 313: } 314: } 315: 316: registre_evaluation_forcee = 317: (*s_etat_processus).evaluation_forcee; 318: 319: if (type_evaluation == 'N') 320: { 321: (*s_etat_processus).evaluation_forcee = 'Y'; 322: } 323: 324: if (sequenceur(s_etat_processus) == d_erreur) 325: { 326: depilement_pile_systeme(s_etat_processus); 327: 328: (*s_etat_processus).evaluation_forcee = 329: registre_evaluation_forcee; 330: (*s_etat_processus).mode_execution_programme = 331: registre_mode_execution_programme; 332: (*s_etat_processus).instruction_courante = 333: instruction_courante; 334: return(d_erreur); 335: } 336: 337: (*s_etat_processus).evaluation_forcee = 338: registre_evaluation_forcee; 339: (*s_etat_processus).instruction_courante = 340: instruction_courante; 341: (*s_etat_processus).mode_execution_programme = 'N'; 342: 343: depilement_pile_systeme(s_etat_processus); 344: 345: if ((*s_etat_processus).erreur_systeme != d_es) 346: { 347: return(d_erreur); 348: } 349: 350: (*s_etat_processus).retour_routine_evaluation = 'N'; 351: (*s_etat_processus).position_courante = 352: registre_position_courante; 353: (*s_etat_processus).autorisation_empilement_programme = 354: autorisation_empilement_programme; 355: } 356: else if (presence_variable == d_vrai) 357: { 358: registre_evaluation_expression_compilee = 359: (*s_etat_processus).evaluation_expression_compilee; 360: 361: if (((*(*s_etat_processus).pointeur_variable_courante).origine 362: == 'E') && ((*(*s_etat_processus) 363: .pointeur_variable_courante).niveau == 0)) 364: { 365: (*s_etat_processus).evaluation_expression_compilee = 'Y'; 366: } 367: else 368: { 369: (*s_etat_processus).evaluation_expression_compilee = 'N'; 370: } 371: 372: if ((*s_etat_processus).profilage == d_vrai) 373: { 374: profilage(s_etat_processus, 375: (*(*s_etat_processus).pointeur_variable_courante) 376: .nom); 377: 378: if ((*s_etat_processus).erreur_systeme != d_es) 379: { 380: return(d_erreur); 381: } 382: } 383: 384: autorisation_empilement_programme = (*s_etat_processus) 385: .autorisation_empilement_programme; 386: 387: empilement_pile_systeme(s_etat_processus); 388: 389: if ((*s_etat_processus).erreur_systeme != d_es) 390: { 391: if (presence_variable_partagee == d_vrai) 392: { 393: liberation(s_etat_processus, s_copie_variable_partagee); 394: } 395: 396: (*s_etat_processus).instruction_courante = 397: instruction_courante; 398: return(d_erreur); 399: } 400: 401: (*(*s_etat_processus).l_base_pile_systeme) 402: .retour_definition = 'Y'; 403: (*(*s_etat_processus).l_base_pile_systeme) 404: .origine_routine_evaluation = 'Y'; 405: 406: (*s_etat_processus).mode_execution_programme = 'Y'; 407: (*s_etat_processus).autorisation_empilement_programme = 'N'; 408: 409: (*(*s_etat_processus).l_base_pile_systeme) 410: .niveau_courant = (*s_etat_processus) 411: .niveau_courant; 412: 413: if (presence_variable_partagee == d_faux) 414: { 415: if (evaluation(s_etat_processus, (*(*s_etat_processus) 416: .pointeur_variable_courante).objet, 417: type_evaluation) == d_erreur) 418: { 419: if ((*s_etat_processus).profilage == d_vrai) 420: { 421: profilage(s_etat_processus, NULL); 422: } 423: 424: depilement_pile_systeme(s_etat_processus); 425: 426: (*s_etat_processus).evaluation_expression_compilee = 427: registre_evaluation_expression_compilee; 428: 429: (*s_etat_processus).mode_execution_programme = 430: registre_mode_execution_programme; 431: (*s_etat_processus).instruction_courante = 432: instruction_courante; 433: return(d_erreur); 434: } 435: } 436: else 437: { 438: if (evaluation(s_etat_processus, s_copie_variable_partagee, 439: type_evaluation) == d_erreur) 440: { 441: liberation(s_etat_processus, s_copie_variable_partagee); 442: 443: if ((*s_etat_processus).profilage == d_vrai) 444: { 445: profilage(s_etat_processus, NULL); 446: } 447: 448: depilement_pile_systeme(s_etat_processus); 449: 450: (*s_etat_processus).evaluation_expression_compilee = 451: registre_evaluation_expression_compilee; 452: 453: (*s_etat_processus).mode_execution_programme = 454: registre_mode_execution_programme; 455: (*s_etat_processus).instruction_courante = 456: instruction_courante; 457: return(d_erreur); 458: } 459: 460: liberation(s_etat_processus, s_copie_variable_partagee); 461: } 462: 463: if ((*s_etat_processus).profilage == d_vrai) 464: { 465: profilage(s_etat_processus, NULL); 466: } 467: 468: depilement_pile_systeme(s_etat_processus); 469: 470: if ((*s_etat_processus).erreur_systeme != d_es) 471: { 472: return(d_erreur); 473: } 474: 475: (*s_etat_processus).evaluation_expression_compilee = 476: registre_evaluation_expression_compilee; 477: (*s_etat_processus).autorisation_empilement_programme = 478: autorisation_empilement_programme; 479: } 480: else if ((*s_etat_processus).erreur_execution != d_ex_nom_implicite) 481: { 482: if ((s_objet_tampon = copie_objet(s_etat_processus, 483: s_objet, 'Q')) == NULL) 484: { 485: (*s_etat_processus).erreur_systeme = 486: d_es_allocation_memoire; 487: (*s_etat_processus).instruction_courante = 488: instruction_courante; 489: return(d_erreur); 490: } 491: 492: (*((struct_nom *) (*s_objet_tampon).objet)).symbole = d_vrai; 493: 494: if (empilement(s_etat_processus, &((*s_etat_processus) 495: .l_base_pile), s_objet_tampon) == d_erreur) 496: { 497: (*s_etat_processus).instruction_courante = 498: instruction_courante; 499: return(d_erreur); 500: } 501: } 502: } 503: else 504: { 505: registre_type_evaluation = (test_cfsf(s_etat_processus, 35) 506: == d_vrai) ? 'E' : 'N'; 507: 508: if (type_evaluation == 'N') 509: { 510: cf(s_etat_processus, 35); 511: } 512: else 513: { 514: sf(s_etat_processus, 35); 515: } 516: 517: analyse(s_etat_processus, NULL); 518: liberation(s_etat_processus, s_objet_tampon); 519: 520: if (registre_type_evaluation == 'E') 521: { 522: sf(s_etat_processus, 35); 523: } 524: else 525: { 526: cf(s_etat_processus, 35); 527: } 528: 529: if (((*s_etat_processus).erreur_systeme != d_es) || 530: ((*s_etat_processus).erreur_execution != d_ex) || 531: ((*s_etat_processus).exception != d_ep)) 532: { 533: (*s_etat_processus).mode_execution_programme = 534: registre_mode_execution_programme; 535: (*s_etat_processus).instruction_courante = instruction_courante; 536: return(d_erreur); 537: } 538: } 539: 540: (*s_etat_processus).instruction_courante = instruction_courante; 541: (*s_etat_processus).test_instruction = registre_test; 542: (*s_etat_processus).instruction_valide = registre_instruction_valide; 543: } 544: else if (((*s_objet).type == RPN) || ((*s_objet).type == ALG)) 545: { 546: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 547: l_element_egalite = NULL; 548: presence_egalite = d_faux; 549: nombre_termes = 0; 550: 551: while(l_element_courant != NULL) 552: { 553: if ((*(*l_element_courant).donnee).type == FCT) 554: { 555: if (strcmp((*((struct_fonction *) (*(*l_element_courant) 556: .donnee).objet)).nom_fonction, "=") == 0) 557: { 558: presence_egalite = d_vrai; 559: l_element_egalite = l_element_courant; 560: } 561: } 562: 563: l_element_courant = (*l_element_courant).suivant; 564: nombre_termes++; 565: } 566: 567: if (nombre_termes <= 4) 568: { 569: presence_egalite = d_faux; 570: } 571: 572: if (presence_egalite == d_vrai) 573: { 574: // S'il y a un signe '=', on modifie l'expression à évaluer en ôtant 575: // le signe '=' et en le remplaçant d'une part par SWAP DROP 576: // et d'autre part par DROP. On évalue la première puis la 577: // seconde normalement avant de reconstituer le tout à la fin 578: // de la routine. 579: 580: l_registre_pile_operationnelle = NULL; 581: registre_hauteur_pile_operationnelle = (*s_etat_processus) 582: .hauteur_pile_operationnelle; 583: l_element_courant = (*s_etat_processus).l_base_pile; 584: 585: while(l_element_courant != NULL) 586: { 587: s_sous_objet = copie_objet(s_etat_processus, 588: (*l_element_courant).donnee, 'O'); 589: 590: if (s_sous_objet == NULL) 591: { 592: (*s_etat_processus).instruction_courante = 593: instruction_courante; 594: (*s_etat_processus).erreur_systeme = 595: d_es_allocation_memoire; 596: return(d_erreur); 597: } 598: 599: if (empilement(s_etat_processus, 600: &l_registre_pile_operationnelle, s_sous_objet) 601: == d_erreur) 602: { 603: (*s_etat_processus).instruction_courante = 604: instruction_courante; 605: (*s_etat_processus).erreur_systeme = 606: d_es_allocation_memoire; 607: return(d_erreur); 608: } 609: 610: l_element_courant = (*l_element_courant).suivant; 611: } 612: 613: free((*((struct_fonction *) (*(*l_element_egalite).donnee) 614: .objet)).nom_fonction); 615: 616: if (((*((struct_fonction *) (*(*l_element_egalite).donnee).objet)) 617: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) 618: { 619: (*s_etat_processus).instruction_courante = instruction_courante; 620: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 621: return(d_erreur); 622: } 623: 624: (*((struct_fonction *) (*(*l_element_egalite).donnee).objet)) 625: .fonction = instruction_drop; 626: strcpy((*((struct_fonction *) (*(*l_element_egalite).donnee).objet)) 627: .nom_fonction, "DROP"); 628: 629: if (evaluation(s_etat_processus, s_objet, type_evaluation) 630: == d_erreur) 631: { 632: (*s_etat_processus).instruction_courante = instruction_courante; 633: return(d_erreur); 634: } 635: 636: // Récupération de l'objet au niveau 1 résultat de l'évaluation 637: // du premier membre de l'équation puis destruction de la pile. 638: 639: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 640: &s_objet_evalue) == d_erreur) 641: { 642: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 643: (*s_etat_processus).instruction_courante = instruction_courante; 644: return(d_erreur); 645: } 646: 647: instruction_clear(s_etat_processus); 648: 649: // Régénération de la pile initiale 650: 651: while(depilement(s_etat_processus, &l_registre_pile_operationnelle, 652: &s_sous_objet) != d_erreur) 653: { 654: if (empilement(s_etat_processus, &((*s_etat_processus) 655: .l_base_pile), s_sous_objet) == d_erreur) 656: { 657: (*s_etat_processus).instruction_courante = 658: instruction_courante; 659: return(d_erreur); 660: } 661: } 662: 663: (*s_etat_processus).hauteur_pile_operationnelle = 664: registre_hauteur_pile_operationnelle; 665: (*s_etat_processus).erreur_execution = d_ex; 666: 667: (*((struct_fonction *) (*(*l_element_egalite).donnee).objet)) 668: .fonction = instruction_swap; 669: strcpy((*((struct_fonction *) (*(*l_element_egalite).donnee).objet)) 670: .nom_fonction, "SWAP"); 671: l_element_courant = (*l_element_egalite).suivant; 672: 673: if (((*l_element_egalite).suivant = 674: malloc(sizeof(struct_liste_chainee))) == NULL) 675: { 676: liberation(s_etat_processus, s_objet_evalue); 677: 678: (*s_etat_processus).instruction_courante = instruction_courante; 679: return(d_erreur); 680: } 681: 682: l_element_egalite = (*l_element_egalite).suivant; 683: (*l_element_egalite).suivant = l_element_courant; 684: 685: if (((*l_element_egalite).donnee = allocation(s_etat_processus, 686: FCT)) == NULL) 687: { 688: liberation(s_etat_processus, s_objet_evalue); 689: 690: (*s_etat_processus).instruction_courante = instruction_courante; 691: return(d_erreur); 692: } 693: 694: (*((struct_fonction *) (*(*l_element_egalite).donnee).objet)) 695: .nombre_arguments = 0; 696: (*((struct_fonction *) (*(*l_element_egalite).donnee).objet)) 697: .fonction = instruction_drop; 698: 699: if (((*((struct_fonction *) (*(*l_element_egalite).donnee).objet)) 700: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) 701: { 702: liberation(s_etat_processus, s_objet_evalue); 703: 704: (*s_etat_processus).instruction_courante = instruction_courante; 705: return(d_erreur); 706: } 707: 708: strcpy((*((struct_fonction *) (*(*l_element_egalite).donnee).objet)) 709: .nom_fonction, "DROP"); 710: } 711: 712: /* 713: * Exécution de la séquence d'instructions 714: */ 715: 716: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 717: autorisation_empilement_programme = (*s_etat_processus) 718: .autorisation_empilement_programme; 719: (*s_etat_processus).autorisation_empilement_programme = 'N'; 720: 721: niveau_initial = (*s_etat_processus).niveau_courant; 722: pile_systeme_originelle = (*s_etat_processus).l_base_pile_systeme; 723: 724: while((l_element_courant != NULL) && 725: ((*s_etat_processus).var_volatile_requete_arret == 0) 726: && (erreur_evaluation == d_absence_erreur) && 727: (*s_etat_processus).requete_arret == 'N') 728: { 729: (*s_etat_processus).objet_courant = (*l_element_courant).donnee; 730: 731: if ((*(*l_element_courant).donnee).type == FCT) 732: { 733: /* 734: * Tester la cohérence avec une variable pour récupérer les 735: * données selon les indices passés en argument (tableaux, 736: * listes...). 737: */ 738: 739: if (recherche_variable(s_etat_processus, 740: (*((struct_fonction *) 741: (*(*l_element_courant).donnee).objet)).nom_fonction) 742: == d_faux) 743: { 744: (*s_etat_processus).erreur_systeme = d_es; 745: (*s_etat_processus).instruction_courante = 746: (*((struct_fonction *) (*(*l_element_courant) 747: .donnee).objet)).nom_fonction; 748: 749: registre_expression_courante = 750: (*s_etat_processus).expression_courante; 751: (*s_etat_processus).expression_courante = l_element_courant; 752: 753: if (((*s_etat_processus).erreur_execution == d_ex) && 754: ((*s_etat_processus).erreur_systeme == d_es) && 755: ((*s_etat_processus).exception == d_ep)) 756: { 757: registre_evaluation_expression_compilee = 758: (*s_etat_processus) 759: .evaluation_expression_compilee; 760: 761: (*s_etat_processus).evaluation_expression_compilee 762: = 'Y'; 763: 764: analyse(s_etat_processus, (*((struct_fonction *) 765: (*(*l_element_courant).donnee).objet)) 766: .fonction); 767: 768: (*s_etat_processus).evaluation_expression_compilee = 769: registre_evaluation_expression_compilee; 770: 771: if (type_evaluation == 'I') 772: { 773: (*s_etat_processus).derniere_erreur_evaluation = 774: (*s_etat_processus).erreur_execution; 775: } 776: } 777: 778: if ((*s_etat_processus).erreur_systeme != d_es) 779: { 780: if (presence_egalite == d_vrai) 781: { 782: liberation(s_etat_processus, s_objet_evalue); 783: } 784: 785: if ((*s_etat_processus).var_volatile_processus_pere 786: == 0) 787: { 788: envoi_signal_processus((*s_etat_processus) 789: .pid_processus_pere, rpl_sigalrm); 790: } 791: else 792: { 793: (*s_etat_processus).var_volatile_alarme = -1; 794: } 795: 796: (*s_etat_processus).instruction_courante = 797: instruction_courante; 798: return(d_erreur); 799: } 800: else if (((*s_etat_processus).erreur_execution != d_ex) || 801: ((*s_etat_processus).exception != d_ep)) 802: { 803: if ((*s_etat_processus).arret_si_exception == d_faux) 804: { 805: /* 806: * Reprise sur erreur 807: */ 808: 809: if ((message = messages(s_etat_processus)) == NULL) 810: { 811: if (presence_egalite == d_vrai) 812: { 813: liberation(s_etat_processus, 814: s_objet_evalue); 815: } 816: 817: (*s_etat_processus).instruction_courante = 818: instruction_courante; 819: return(d_erreur); 820: } 821: 822: free(message); 823: 824: drapeau_then = d_faux; 825: 826: while(drapeau_then == d_faux) 827: { 828: l_registre_atome = l_element_courant; 829: l_element_courant = 830: (*l_element_courant).suivant; 831: 832: if (l_element_courant == NULL) 833: { 834: /* 835: * La fin de l'expression est atteinte, 836: * le sequenceur reprend la main. 837: */ 838: 839: if (presence_egalite == d_vrai) 840: { 841: liberation(s_etat_processus, 842: s_objet_evalue); 843: } 844: 845: (*s_etat_processus) 846: .mode_execution_programme = 847: registre_mode_execution_programme; 848: return(d_absence_erreur); 849: } 850: 851: if ((*(*l_element_courant).donnee).type == FCT) 852: { 853: (*s_etat_processus).instruction_courante = 854: (*((struct_fonction *) 855: (*(*l_element_courant).donnee) 856: .objet)).nom_fonction; 857: 858: if (recherche_variable(s_etat_processus, 859: (*s_etat_processus) 860: .instruction_courante) == d_faux) 861: { 862: (*s_etat_processus).erreur_systeme 863: = d_es; 864: fonction = (*((struct_fonction *) 865: (*(*l_element_courant).donnee) 866: .objet)).fonction; 867: 868: /* 869: * Traitement de la pile système par les 870: * différentes instructions. 871: */ 872: 873: if (TEST(instruction_if) || 874: TEST(instruction_iferr) || 875: TEST(instruction_do) || 876: TEST(instruction_while) || 877: TEST(instruction_for) || 878: TEST(instruction_forall) || 879: TEST(instruction_start) || 880: TEST(instruction_select) || 881: TEST(instruction_case) || 882: TEST(instruction_critical) || 883: TEST(vers_niveau_superieur)) 884: { 885: if (TEST(vers_niveau_superieur)) 886: { 887: registre_exception = 888: (*s_etat_processus) 889: .exception; 890: registre_erreur_execution = 891: (*s_etat_processus) 892: .erreur_execution; 893: 894: analyse(s_etat_processus, 895: vers_niveau_superieur); 896: 897: if ((*s_etat_processus) 898: .erreur_systeme != d_es) 899: { 900: if (presence_egalite == 901: d_vrai) 902: { 903: liberation( 904: s_etat_processus, 905: s_objet_evalue); 906: } 907: 908: (*s_etat_processus) 909: .instruction_courante = 910: instruction_courante; 911: return(d_erreur); 912: } 913: 914: (*s_etat_processus).exception 915: = registre_exception; 916: (*s_etat_processus) 917: .erreur_execution = 918: registre_erreur_execution; 919: } 920: else if (TEST(instruction_for) || 921: TEST(instruction_forall) || 922: TEST(instruction_start)) 923: { 924: empilement_pile_systeme( 925: s_etat_processus); 926: 927: if ((*s_etat_processus) 928: .erreur_systeme != d_es) 929: { 930: if (presence_egalite == 931: d_vrai) 932: { 933: liberation( 934: s_etat_processus, 935: s_objet_evalue); 936: } 937: 938: (*s_etat_processus) 939: .instruction_courante = 940: instruction_courante; 941: return(d_erreur); 942: } 943: 944: (*(*s_etat_processus) 945: .l_base_pile_systeme) 946: .type_cloture = 'L'; 947: } 948: else 949: { 950: empilement_pile_systeme( 951: s_etat_processus); 952: 953: if ((*s_etat_processus) 954: .erreur_systeme != d_es) 955: { 956: if (presence_egalite == 957: d_vrai) 958: { 959: liberation( 960: s_etat_processus, 961: s_objet_evalue); 962: } 963: 964: (*s_etat_processus) 965: .instruction_courante = 966: instruction_courante; 967: return(d_erreur); 968: } 969: } 970: } 971: else if (TEST(instruction_end) || 972: TEST(instruction_next) || 973: TEST(instruction_step) || 974: TEST(vers_niveau_inferieur)) 975: { 976: if (TEST(vers_niveau_inferieur)) 977: { 978: registre_exception = 979: (*s_etat_processus) 980: .exception; 981: registre_erreur_execution = 982: (*s_etat_processus) 983: .erreur_execution; 984: 985: analyse(s_etat_processus, 986: vers_niveau_inferieur); 987: 988: if ((*s_etat_processus) 989: .erreur_systeme != d_es) 990: { 991: if (presence_egalite == 992: d_vrai) 993: { 994: liberation( 995: s_etat_processus, 996: s_objet_evalue); 997: } 998: 999: (*s_etat_processus) 1000: .instruction_courante = 1001: instruction_courante; 1002: return(d_erreur); 1003: } 1004: 1005: (*s_etat_processus).exception 1006: = registre_exception; 1007: (*s_etat_processus) 1008: .erreur_execution = 1009: registre_erreur_execution; 1010: } 1011: else if ((TEST(instruction_next) || 1012: TEST(instruction_step)) && 1013: ((*(*s_etat_processus) 1014: .l_base_pile_systeme) 1015: .type_cloture != 'L')) 1016: { 1017: /* 1018: * Libération des compteurs 1019: * de boucle 1020: */ 1021: 1022: presence_compteur = 1023: (((*(*s_etat_processus) 1024: .l_base_pile_systeme) 1025: .type_cloture == 'F') || 1026: ((*(*s_etat_processus) 1027: .l_base_pile_systeme) 1028: .type_cloture == 'A')) 1029: ? d_vrai : d_faux; 1030: 1031: if (((*(*s_etat_processus) 1032: .l_base_pile_systeme) 1033: .type_cloture != 'S') && 1034: (presence_compteur == 1035: d_faux)) 1036: { 1037: (*s_etat_processus) 1038: .erreur_execution = 1039: d_ex_erreur_traitement_boucle; 1040: 1041: if (presence_egalite == 1042: d_vrai) 1043: { 1044: liberation( 1045: s_etat_processus, 1046: s_objet_evalue); 1047: } 1048: 1049: (*s_etat_processus) 1050: .instruction_courante = 1051: instruction_courante; 1052: return(d_erreur); 1053: } 1054: 1055: if (presence_compteur == d_vrai) 1056: { 1057: if (recherche_variable( 1058: s_etat_processus, 1059: (*(*s_etat_processus) 1060: .l_base_pile_systeme) 1061: .nom_variable) == 1062: d_faux) 1063: { 1064: (*s_etat_processus) 1065: .erreur_systeme = d_es; 1066: (*s_etat_processus) 1067: .erreur_execution = 1068: d_ex_erreur_traitement_boucle; 1069: 1070: if (presence_egalite == 1071: d_vrai) 1072: { 1073: liberation( 1074: s_etat_processus, 1075: s_objet_evalue); 1076: } 1077: 1078: (*s_etat_processus) 1079: .instruction_courante = 1080: instruction_courante; 1081: return(d_erreur); 1082: } 1083: 1084: if ((*(*s_etat_processus) 1085: .pointeur_variable_courante) 1086: .objet == NULL) 1087: { 1088: (*s_etat_processus) 1089: .erreur_systeme = d_es; 1090: (*s_etat_processus) 1091: .erreur_execution = 1092: d_ex_variable_partagee; 1093: 1094: if (presence_egalite == 1095: d_vrai) 1096: { 1097: liberation( 1098: s_etat_processus, 1099: s_objet_evalue); 1100: } 1101: 1102: (*s_etat_processus) 1103: .instruction_courante = 1104: instruction_courante; 1105: return(d_erreur); 1106: } 1107: 1108: (*s_etat_processus) 1109: .niveau_courant--; 1110: 1111: if ( 1112: retrait_variables_par_niveau( 1113: s_etat_processus) == d_erreur) 1114: { 1115: if (presence_egalite == 1116: d_vrai) 1117: { 1118: liberation( 1119: s_etat_processus, 1120: s_objet_evalue); 1121: } 1122: 1123: (*s_etat_processus) 1124: .instruction_courante = 1125: instruction_courante; 1126: return(d_erreur); 1127: } 1128: } 1129: 1130: depilement_pile_systeme( 1131: s_etat_processus); 1132: } 1133: else 1134: { 1135: // Traitement spécifique pour 1136: // la fin d'une section 1137: // critique 1138: 1139: if ((*s_etat_processus) 1140: .l_base_pile_systeme 1141: == NULL) 1142: { 1143: (*s_etat_processus) 1144: .erreur_systeme = 1145: d_es_end_incoherent; 1146: 1147: if (presence_egalite == 1148: d_vrai) 1149: { 1150: liberation( 1151: s_etat_processus, 1152: s_objet_evalue); 1153: } 1154: 1155: (*s_etat_processus) 1156: .instruction_courante = 1157: instruction_courante; 1158: return(d_erreur); 1159: } 1160: 1161: if ((*(*s_etat_processus) 1162: .l_base_pile_systeme) 1163: .type_cloture == 'Q') 1164: { 1165: if (pthread_mutex_unlock( 1166: &mutex_sections_critiques) 1167: != 0) 1168: { 1169: (*s_etat_processus) 1170: .erreur_systeme = 1171: d_es_processus; 1172: 1173: liberation( 1174: s_etat_processus, 1175: s_objet_evalue); 1176: 1177: (*s_etat_processus) 1178: .instruction_courante = 1179: instruction_courante; 1180: return(d_erreur); 1181: } 1182: 1183: (*s_etat_processus) 1184: .sections_critiques--; 1185: } 1186: 1187: depilement_pile_systeme( 1188: s_etat_processus); 1189: 1190: if ((*s_etat_processus) 1191: .erreur_systeme != d_es) 1192: { 1193: if (presence_egalite == 1194: d_vrai) 1195: { 1196: liberation( 1197: s_etat_processus, 1198: s_objet_evalue); 1199: } 1200: 1201: (*s_etat_processus) 1202: .instruction_courante = 1203: instruction_courante; 1204: return(d_erreur); 1205: } 1206: } 1207: } 1208: else if (TEST(instruction_then)) 1209: { 1210: if ((*(*s_etat_processus) 1211: .l_base_pile_systeme) 1212: .clause == 'R') 1213: { 1214: (*(*s_etat_processus) 1215: .l_base_pile_systeme) 1216: .clause = 'X'; 1217: instruction_then( 1218: s_etat_processus); 1219: drapeau_then = d_vrai; 1220: } 1221: } 1222: } 1223: } 1224: } 1225: 1226: (*s_etat_processus).expression_courante = 1227: l_element_courant; 1228: (*s_etat_processus).instruction_courante = 1229: instruction_courante; 1230: 1231: (*s_etat_processus).exception = d_ep; 1232: (*s_etat_processus).erreur_execution = d_ex; 1233: } 1234: else if ((*s_etat_processus).mode_evaluation_expression 1235: == 'Y') 1236: { 1237: /* 1238: * Reprise sur erreur 1239: */ 1240: 1241: while(l_element_courant != NULL) 1242: { 1243: if ((*(*l_element_courant).donnee).type == FCT) 1244: { 1245: (*s_etat_processus).instruction_courante = 1246: (*((struct_fonction *) 1247: (*(*l_element_courant).donnee) 1248: .objet)).nom_fonction; 1249: fonction = (*((struct_fonction *) 1250: (*(*l_element_courant).donnee) 1251: .objet)).fonction; 1252: 1253: if (recherche_variable(s_etat_processus, 1254: (*s_etat_processus) 1255: .instruction_courante) == d_faux) 1256: { 1257: (*s_etat_processus).erreur_systeme 1258: = d_es; 1259: 1260: /* 1261: * Traitement de la pile système par les 1262: * différentes instructions. 1263: */ 1264: 1265: if (TEST(instruction_if) || 1266: TEST(instruction_iferr) || 1267: TEST(instruction_do) || 1268: TEST(instruction_while) || 1269: TEST(instruction_for) || 1270: TEST(instruction_forall) || 1271: TEST(instruction_start) || 1272: TEST(instruction_select) || 1273: TEST(instruction_case) || 1274: TEST(instruction_critical) || 1275: TEST(vers_niveau_superieur)) 1276: { 1277: if (TEST(vers_niveau_superieur)) 1278: { 1279: analyse(s_etat_processus, 1280: vers_niveau_superieur); 1281: 1282: if ((*s_etat_processus) 1283: .erreur_systeme != d_es) 1284: { 1285: if (presence_egalite == 1286: d_vrai) 1287: { 1288: liberation( 1289: s_etat_processus, 1290: s_objet_evalue); 1291: } 1292: 1293: (*s_etat_processus) 1294: .instruction_courante = 1295: instruction_courante; 1296: return(d_erreur); 1297: } 1298: } 1299: else if (TEST(instruction_for) || 1300: TEST(instruction_forall) || 1301: TEST(instruction_start)) 1302: { 1303: empilement_pile_systeme( 1304: s_etat_processus); 1305: 1306: if ((*s_etat_processus) 1307: .erreur_systeme != d_es) 1308: { 1309: if (presence_egalite == 1310: d_vrai) 1311: { 1312: liberation( 1313: s_etat_processus, 1314: s_objet_evalue); 1315: } 1316: 1317: (*s_etat_processus) 1318: .instruction_courante = 1319: instruction_courante; 1320: return(d_erreur); 1321: } 1322: 1323: (*(*s_etat_processus) 1324: .l_base_pile_systeme) 1325: .type_cloture = 'L'; 1326: } 1327: else 1328: { 1329: empilement_pile_systeme( 1330: s_etat_processus); 1331: 1332: if ((*s_etat_processus) 1333: .erreur_systeme != d_es) 1334: { 1335: if (presence_egalite == 1336: d_vrai) 1337: { 1338: liberation( 1339: s_etat_processus, 1340: s_objet_evalue); 1341: } 1342: 1343: (*s_etat_processus) 1344: .instruction_courante = 1345: instruction_courante; 1346: return(d_erreur); 1347: } 1348: } 1349: } 1350: else if (TEST(instruction_end) || 1351: TEST(instruction_next) || 1352: TEST(instruction_step) || 1353: TEST(vers_niveau_inferieur)) 1354: { 1355: if (TEST(vers_niveau_inferieur)) 1356: { 1357: analyse(s_etat_processus, 1358: vers_niveau_inferieur); 1359: 1360: if ((*s_etat_processus) 1361: .erreur_systeme != d_es) 1362: { 1363: if (presence_egalite == 1364: d_vrai) 1365: { 1366: liberation( 1367: s_etat_processus, 1368: s_objet_evalue); 1369: } 1370: 1371: (*s_etat_processus) 1372: .instruction_courante = 1373: instruction_courante; 1374: return(d_erreur); 1375: } 1376: } 1377: else if ((TEST(instruction_next) || 1378: TEST(instruction_step)) && 1379: ((*(*s_etat_processus) 1380: .l_base_pile_systeme) 1381: .type_cloture != 'L')) 1382: { 1383: /* 1384: * Libération des compteurs 1385: * de boucle 1386: */ 1387: 1388: presence_compteur = 1389: (((*(*s_etat_processus) 1390: .l_base_pile_systeme) 1391: .type_cloture == 'F') || 1392: ((*(*s_etat_processus) 1393: .l_base_pile_systeme) 1394: .type_cloture == 'A')) 1395: ? d_vrai : d_faux; 1396: 1397: if (((*(*s_etat_processus) 1398: .l_base_pile_systeme) 1399: .type_cloture != 'S') && 1400: (presence_compteur == 1401: d_faux)) 1402: { 1403: (*s_etat_processus) 1404: .erreur_execution = 1405: d_ex_erreur_traitement_boucle; 1406: 1407: if (presence_egalite == 1408: d_vrai) 1409: { 1410: liberation( 1411: s_etat_processus, 1412: s_objet_evalue); 1413: } 1414: 1415: (*s_etat_processus) 1416: .instruction_courante = 1417: instruction_courante; 1418: return(d_erreur); 1419: } 1420: 1421: if (presence_compteur == d_vrai) 1422: { 1423: if (recherche_variable( 1424: s_etat_processus, 1425: (*(*s_etat_processus) 1426: .l_base_pile_systeme) 1427: .nom_variable) == 1428: d_faux) 1429: { 1430: (*s_etat_processus) 1431: .erreur_systeme = d_es; 1432: (*s_etat_processus) 1433: .erreur_execution = 1434: d_ex_erreur_traitement_boucle; 1435: 1436: if (presence_egalite == 1437: d_vrai) 1438: { 1439: liberation( 1440: s_etat_processus, 1441: s_objet_evalue); 1442: } 1443: 1444: (*s_etat_processus) 1445: .instruction_courante = 1446: instruction_courante; 1447: return(d_erreur); 1448: } 1449: 1450: if ((*(*s_etat_processus) 1451: .pointeur_variable_courante) 1452: .objet == NULL) 1453: { 1454: (*s_etat_processus) 1455: .erreur_systeme = d_es; 1456: (*s_etat_processus) 1457: .erreur_execution = 1458: d_ex_variable_partagee; 1459: 1460: if (presence_egalite == 1461: d_vrai) 1462: { 1463: liberation( 1464: s_etat_processus, 1465: s_objet_evalue); 1466: } 1467: 1468: (*s_etat_processus) 1469: .instruction_courante = 1470: instruction_courante; 1471: return(d_erreur); 1472: } 1473: 1474: (*s_etat_processus) 1475: .niveau_courant--; 1476: 1477: if ( 1478: retrait_variables_par_niveau( 1479: s_etat_processus) == d_erreur) 1480: { 1481: if (presence_egalite == 1482: d_vrai) 1483: { 1484: liberation( 1485: s_etat_processus, 1486: s_objet_evalue); 1487: } 1488: 1489: (*s_etat_processus) 1490: .instruction_courante = 1491: instruction_courante; 1492: return(d_erreur); 1493: } 1494: } 1495: 1496: depilement_pile_systeme( 1497: s_etat_processus); 1498: } 1499: else 1500: { 1501: // Traitement spécifique pour 1502: // la fin d'une section 1503: // critique 1504: 1505: if ((*s_etat_processus) 1506: .l_base_pile_systeme 1507: == NULL) 1508: { 1509: (*s_etat_processus) 1510: .erreur_systeme = 1511: d_es_end_incoherent; 1512: 1513: if (presence_egalite == 1514: d_vrai) 1515: { 1516: liberation( 1517: s_etat_processus, 1518: s_objet_evalue); 1519: } 1520: 1521: (*s_etat_processus) 1522: .instruction_courante = 1523: instruction_courante; 1524: return(d_erreur); 1525: } 1526: 1527: if ((*(*s_etat_processus) 1528: .l_base_pile_systeme) 1529: .type_cloture == 'Q') 1530: { 1531: if (pthread_mutex_unlock( 1532: &mutex_sections_critiques) 1533: != 0) 1534: { 1535: (*s_etat_processus) 1536: .erreur_systeme = 1537: d_es_processus; 1538: 1539: if (presence_egalite == 1540: d_vrai) 1541: { 1542: liberation( 1543: s_etat_processus, 1544: s_objet_evalue); 1545: } 1546: 1547: (*s_etat_processus) 1548: .instruction_courante = 1549: instruction_courante; 1550: return(d_erreur); 1551: } 1552: 1553: (*s_etat_processus) 1554: .sections_critiques--; 1555: } 1556: 1557: depilement_pile_systeme( 1558: s_etat_processus); 1559: } 1560: 1561: if ((*s_etat_processus) 1562: .erreur_systeme != d_es) 1563: { 1564: if (presence_egalite == 1565: d_vrai) 1566: { 1567: liberation( 1568: s_etat_processus, 1569: s_objet_evalue); 1570: } 1571: 1572: (*s_etat_processus) 1573: .instruction_courante = 1574: instruction_courante; 1575: return(d_erreur); 1576: } 1577: } 1578: } 1579: } 1580: 1581: l_element_courant = 1582: (*l_element_courant).suivant; 1583: } 1584: 1585: (*s_etat_processus).mode_execution_programme = 1586: registre_mode_execution_programme; 1587: (*s_etat_processus).instruction_courante = 1588: instruction_courante; 1589: 1590: (*s_etat_processus).exception = d_ep; 1591: (*s_etat_processus).erreur_execution = d_ex; 1592: 1593: erreur_evaluation = d_erreur; 1594: 1595: (*s_etat_processus).expression_courante = 1596: registre_expression_courante; 1597: } 1598: else 1599: { 1600: // On ne détruit pas les variables pour les inclure 1601: // dans le fichier rpl-core. 1602: 1603: (*s_etat_processus).gel_liste_variables = d_vrai; 1604: 1605: registre_erreur_execution = 1606: (*s_etat_processus).erreur_execution; 1607: registre_exception = 1608: (*s_etat_processus).exception; 1609: registre_erreur_systeme = 1610: (*s_etat_processus).erreur_systeme; 1611: 1612: (*s_etat_processus).s_objet_errone = s_objet; 1613: (*s_etat_processus).s_objet_erreur = 1614: (*l_element_courant).donnee; 1615: 1616: l_element_courant = (*l_element_courant).suivant; 1617: 1618: while(l_element_courant != NULL) 1619: { 1620: if ((*(*l_element_courant).donnee).type == FCT) 1621: { 1622: (*s_etat_processus).instruction_courante = 1623: (*((struct_fonction *) 1624: (*(*l_element_courant).donnee) 1625: .objet)).nom_fonction; 1626: fonction = (*((struct_fonction *) 1627: (*(*l_element_courant).donnee) 1628: .objet)).fonction; 1629: 1630: if (recherche_variable(s_etat_processus, 1631: (*s_etat_processus) 1632: .instruction_courante) == d_faux) 1633: { 1634: (*s_etat_processus).erreur_systeme 1635: = d_es; 1636: 1637: /* 1638: * Traitement de la pile système par les 1639: * différentes instructions. 1640: */ 1641: 1642: if (TEST(instruction_if) || 1643: TEST(instruction_iferr) || 1644: TEST(instruction_do) || 1645: TEST(instruction_while) || 1646: TEST(instruction_for) || 1647: TEST(instruction_forall) || 1648: TEST(instruction_start) || 1649: TEST(instruction_select) || 1650: TEST(instruction_case) || 1651: TEST(instruction_critical) || 1652: TEST(vers_niveau_superieur)) 1653: { 1654: if (TEST(vers_niveau_superieur)) 1655: { 1656: analyse(s_etat_processus, 1657: vers_niveau_superieur); 1658: 1659: if ((*s_etat_processus) 1660: .erreur_systeme != d_es) 1661: { 1662: if (presence_egalite == 1663: d_vrai) 1664: { 1665: liberation( 1666: s_etat_processus, 1667: s_objet_evalue); 1668: } 1669: 1670: (*s_etat_processus) 1671: .instruction_courante = 1672: instruction_courante; 1673: return(d_erreur); 1674: } 1675: } 1676: else if (TEST(instruction_for) || 1677: TEST(instruction_forall) || 1678: TEST(instruction_start)) 1679: { 1680: empilement_pile_systeme( 1681: s_etat_processus); 1682: 1683: if ((*s_etat_processus) 1684: .erreur_systeme != d_es) 1685: { 1686: if (presence_egalite == 1687: d_vrai) 1688: { 1689: liberation( 1690: s_etat_processus, 1691: s_objet_evalue); 1692: } 1693: 1694: (*s_etat_processus) 1695: .instruction_courante = 1696: instruction_courante; 1697: return(d_erreur); 1698: } 1699: 1700: (*(*s_etat_processus) 1701: .l_base_pile_systeme) 1702: .type_cloture = 'L'; 1703: } 1704: else 1705: { 1706: empilement_pile_systeme( 1707: s_etat_processus); 1708: 1709: if ((*s_etat_processus) 1710: .erreur_systeme != d_es) 1711: { 1712: if (presence_egalite == 1713: d_vrai) 1714: { 1715: liberation( 1716: s_etat_processus, 1717: s_objet_evalue); 1718: } 1719: 1720: (*s_etat_processus) 1721: .instruction_courante = 1722: instruction_courante; 1723: return(d_erreur); 1724: } 1725: } 1726: } 1727: else if (TEST(instruction_end) || 1728: TEST(instruction_next) || 1729: TEST(instruction_step) || 1730: TEST(vers_niveau_inferieur)) 1731: { 1732: if (TEST(vers_niveau_inferieur)) 1733: { 1734: analyse(s_etat_processus, 1735: vers_niveau_inferieur); 1736: 1737: if ((*s_etat_processus) 1738: .erreur_systeme != d_es) 1739: { 1740: if (presence_egalite == 1741: d_vrai) 1742: { 1743: liberation( 1744: s_etat_processus, 1745: s_objet_evalue); 1746: } 1747: 1748: (*s_etat_processus) 1749: .instruction_courante = 1750: instruction_courante; 1751: return(d_erreur); 1752: } 1753: 1754: if ((*(*s_etat_processus) 1755: .l_base_pile_systeme) 1756: .retour_definition 1757: == 'Y') 1758: { 1759: break; 1760: } 1761: } 1762: else if ((TEST(instruction_next) || 1763: TEST(instruction_step)) && 1764: ((*(*s_etat_processus) 1765: .l_base_pile_systeme) 1766: .type_cloture != 'L')) 1767: { 1768: /* 1769: * Libération des compteurs 1770: * de boucle 1771: */ 1772: 1773: presence_compteur = 1774: (((*(*s_etat_processus) 1775: .l_base_pile_systeme) 1776: .type_cloture == 'F') || 1777: ((*(*s_etat_processus) 1778: .l_base_pile_systeme) 1779: .type_cloture == 'A')) 1780: ? d_vrai : d_faux; 1781: 1782: if (((*(*s_etat_processus) 1783: .l_base_pile_systeme) 1784: .type_cloture != 'S') && 1785: (presence_compteur == 1786: d_faux)) 1787: { 1788: (*s_etat_processus) 1789: .erreur_execution = 1790: d_ex_erreur_traitement_boucle; 1791: 1792: if (presence_egalite == 1793: d_vrai) 1794: { 1795: liberation( 1796: s_etat_processus, 1797: s_objet_evalue); 1798: } 1799: 1800: (*s_etat_processus) 1801: .instruction_courante = 1802: instruction_courante; 1803: return(d_erreur); 1804: } 1805: 1806: if (presence_compteur == d_vrai) 1807: { 1808: if (recherche_variable( 1809: s_etat_processus, 1810: (*(*s_etat_processus) 1811: .l_base_pile_systeme) 1812: .nom_variable) == 1813: d_faux) 1814: { 1815: (*s_etat_processus) 1816: .erreur_systeme = d_es; 1817: (*s_etat_processus) 1818: .erreur_execution = 1819: d_ex_erreur_traitement_boucle; 1820: 1821: if (presence_egalite == 1822: d_vrai) 1823: { 1824: liberation( 1825: s_etat_processus, 1826: s_objet_evalue); 1827: } 1828: 1829: (*s_etat_processus) 1830: .instruction_courante = 1831: instruction_courante; 1832: return(d_erreur); 1833: } 1834: 1835: if ((*(*s_etat_processus) 1836: .pointeur_variable_courante) 1837: .objet == NULL) 1838: { 1839: (*s_etat_processus) 1840: .erreur_systeme = d_es; 1841: (*s_etat_processus) 1842: .erreur_execution = 1843: d_ex_variable_partagee; 1844: 1845: if (presence_egalite == 1846: d_vrai) 1847: { 1848: liberation( 1849: s_etat_processus, 1850: s_objet_evalue); 1851: } 1852: 1853: (*s_etat_processus) 1854: .instruction_courante = 1855: instruction_courante; 1856: return(d_erreur); 1857: } 1858: 1859: (*s_etat_processus) 1860: .niveau_courant--; 1861: 1862: if ( 1863: retrait_variables_par_niveau( 1864: s_etat_processus) == d_erreur) 1865: { 1866: if (presence_egalite == 1867: d_vrai) 1868: { 1869: liberation( 1870: s_etat_processus, 1871: s_objet_evalue); 1872: } 1873: 1874: (*s_etat_processus) 1875: .instruction_courante = 1876: instruction_courante; 1877: return(d_erreur); 1878: } 1879: } 1880: 1881: depilement_pile_systeme( 1882: s_etat_processus); 1883: } 1884: else 1885: { 1886: // Traitement spécifique pour 1887: // la fin d'une section critique 1888: 1889: if ((*s_etat_processus) 1890: .l_base_pile_systeme 1891: == NULL) 1892: { 1893: (*s_etat_processus) 1894: .erreur_systeme = 1895: d_es_end_incoherent; 1896: 1897: if (presence_egalite == 1898: d_vrai) 1899: { 1900: liberation( 1901: s_etat_processus, 1902: s_objet_evalue); 1903: } 1904: 1905: (*s_etat_processus) 1906: .instruction_courante = 1907: instruction_courante; 1908: return(d_erreur); 1909: } 1910: 1911: if ((*(*s_etat_processus) 1912: .l_base_pile_systeme) 1913: .type_cloture == 'Q') 1914: { 1915: if (pthread_mutex_unlock( 1916: &mutex_sections_critiques) 1917: != 0) 1918: { 1919: (*s_etat_processus) 1920: .erreur_systeme = 1921: d_es_processus; 1922: 1923: if (presence_egalite == 1924: d_vrai) 1925: { 1926: liberation( 1927: s_etat_processus, 1928: s_objet_evalue); 1929: } 1930: 1931: (*s_etat_processus) 1932: .instruction_courante = 1933: instruction_courante; 1934: return(d_erreur); 1935: } 1936: 1937: (*s_etat_processus) 1938: .sections_critiques--; 1939: } 1940: 1941: depilement_pile_systeme( 1942: s_etat_processus); 1943: 1944: if ((*s_etat_processus) 1945: .erreur_systeme != d_es) 1946: { 1947: if (presence_egalite == 1948: d_vrai) 1949: { 1950: liberation( 1951: s_etat_processus, 1952: s_objet_evalue); 1953: } 1954: 1955: (*s_etat_processus) 1956: .instruction_courante = 1957: instruction_courante; 1958: return(d_erreur); 1959: } 1960: } 1961: } 1962: } 1963: } 1964: 1965: l_element_courant = 1966: (*l_element_courant).suivant; 1967: } 1968: 1969: (*s_etat_processus).mode_execution_programme = 1970: registre_mode_execution_programme; 1971: (*s_etat_processus).instruction_courante = 1972: instruction_courante; 1973: 1974: if (presence_egalite == d_vrai) 1975: { 1976: liberation(s_etat_processus, s_objet_evalue); 1977: } 1978: 1979: if ((*s_etat_processus) 1980: .var_volatile_processus_pere == 0) 1981: { 1982: envoi_signal_processus((*s_etat_processus) 1983: .pid_processus_pere, rpl_sigalrm); 1984: } 1985: else 1986: { 1987: (*s_etat_processus).var_volatile_alarme = -1; 1988: } 1989: 1990: (*s_etat_processus).erreur_execution = 1991: registre_erreur_execution; 1992: (*s_etat_processus).erreur_systeme = 1993: registre_erreur_systeme; 1994: (*s_etat_processus).exception = 1995: registre_exception; 1996: return(d_erreur); 1997: } 1998: } 1999: 2000: if ((*s_etat_processus).instruction_valide == 'Y') 2001: { 2002: l_element_courant = (*s_etat_processus) 2003: .expression_courante; 2004: } 2005: else 2006: { 2007: /* 2008: * Régénération de la fonction en notation algébrique 2009: */ 2010: 2011: if ((s_objet_elementaire = (struct_objet *) 2012: allocation(s_etat_processus, ALG)) == NULL) 2013: { 2014: if (presence_egalite == d_vrai) 2015: { 2016: liberation(s_etat_processus, s_objet_evalue); 2017: } 2018: 2019: (*s_etat_processus).erreur_systeme = 2020: d_es_allocation_memoire; 2021: (*s_etat_processus).instruction_courante = 2022: instruction_courante; 2023: return(d_erreur); 2024: } 2025: 2026: /* 2027: * Ouverture de l'expression 2028: */ 2029: 2030: if (((*s_objet_elementaire).objet = 2031: (struct_liste_chainee *) 2032: malloc(sizeof(struct_liste_chainee))) == NULL) 2033: { 2034: if (presence_egalite == d_vrai) 2035: { 2036: liberation(s_etat_processus, s_objet_evalue); 2037: } 2038: 2039: (*s_etat_processus).erreur_systeme = 2040: d_es_allocation_memoire; 2041: (*s_etat_processus).instruction_courante = 2042: instruction_courante; 2043: return(d_erreur); 2044: } 2045: 2046: l_element_fonction = (*s_objet_elementaire).objet; 2047: 2048: if (((*l_element_fonction).donnee = (struct_objet *) 2049: allocation(s_etat_processus, FCT)) == NULL) 2050: { 2051: if (presence_egalite == d_vrai) 2052: { 2053: liberation(s_etat_processus, s_objet_evalue); 2054: } 2055: 2056: (*s_etat_processus).erreur_systeme = 2057: d_es_allocation_memoire; 2058: (*s_etat_processus).instruction_courante = 2059: instruction_courante; 2060: return(d_erreur); 2061: } 2062: 2063: (*((struct_fonction *) (*(*l_element_fonction).donnee) 2064: .objet)).nombre_arguments = 0; 2065: (*((struct_fonction *) (*(*l_element_fonction).donnee) 2066: .objet)).fonction = 2067: instruction_vers_niveau_superieur; 2068: 2069: if (((*((struct_fonction *) (*(*l_element_fonction) 2070: .donnee).objet)).nom_fonction = 2071: (unsigned char *) malloc(3 * sizeof( 2072: unsigned char))) == NULL) 2073: { 2074: if (presence_egalite == d_vrai) 2075: { 2076: liberation(s_etat_processus, s_objet_evalue); 2077: } 2078: 2079: (*s_etat_processus).erreur_systeme = 2080: d_es_allocation_memoire; 2081: (*s_etat_processus).instruction_courante = 2082: instruction_courante; 2083: return(d_erreur); 2084: } 2085: 2086: strcpy((*((struct_fonction *) (*(*l_element_fonction) 2087: .donnee).objet)).nom_fonction, "<<"); 2088: 2089: /* 2090: * Ajout des arguments 2091: */ 2092: 2093: for(k = (*((struct_fonction *) 2094: (*(*l_element_courant).donnee).objet)) 2095: .nombre_arguments; k >= 1; k--) 2096: { 2097: if (((*l_element_fonction).suivant = 2098: (struct_liste_chainee *) malloc(sizeof( 2099: struct_liste_chainee))) == NULL) 2100: { 2101: if (presence_egalite == d_vrai) 2102: { 2103: liberation(s_etat_processus, 2104: s_objet_evalue); 2105: } 2106: 2107: (*s_etat_processus).erreur_systeme = 2108: d_es_allocation_memoire; 2109: (*s_etat_processus).instruction_courante = 2110: instruction_courante; 2111: return(d_erreur); 2112: } 2113: 2114: l_element_fonction = (*l_element_fonction).suivant; 2115: 2116: if (k > 1) 2117: { 2118: l_liste1 = (*s_etat_processus).l_base_pile; 2119: 2120: for(l = 2; l < k; l++) 2121: { 2122: l_liste1 = (*l_liste1).suivant; 2123: } 2124: 2125: l_liste2 = (*l_liste1).suivant; 2126: (*l_liste1).suivant = (*l_liste2).suivant; 2127: (*l_liste2).suivant = (*s_etat_processus) 2128: .l_base_pile; 2129: (*s_etat_processus).l_base_pile = l_liste2; 2130: } 2131: 2132: if (depilement(s_etat_processus, 2133: &((*s_etat_processus).l_base_pile), 2134: &s_sous_objet) == d_erreur) 2135: { 2136: if (presence_egalite == d_vrai) 2137: { 2138: liberation(s_etat_processus, 2139: s_objet_evalue); 2140: } 2141: 2142: (*s_etat_processus).erreur_execution = 2143: d_ex_manque_argument; 2144: (*s_etat_processus).instruction_courante = 2145: instruction_courante; 2146: (*s_etat_processus).mode_execution_programme = 2147: registre_mode_execution_programme; 2148: return(d_erreur); 2149: } 2150: 2151: (*l_element_fonction).donnee = s_sous_objet; 2152: } 2153: 2154: /* 2155: * Ajout de la fonction 2156: */ 2157: 2158: if (((*l_element_fonction).suivant = 2159: (struct_liste_chainee *) malloc(sizeof( 2160: struct_liste_chainee))) == NULL) 2161: { 2162: if (presence_egalite == d_vrai) 2163: { 2164: liberation(s_etat_processus, s_objet_evalue); 2165: } 2166: 2167: (*s_etat_processus).erreur_systeme = 2168: d_es_allocation_memoire; 2169: (*s_etat_processus).instruction_courante = 2170: instruction_courante; 2171: return(d_erreur); 2172: } 2173: 2174: l_element_fonction = (*l_element_fonction).suivant; 2175: 2176: if (((*l_element_fonction).donnee = 2177: copie_objet(s_etat_processus, 2178: (*l_element_courant).donnee, 'P')) 2179: == NULL) 2180: { 2181: if (presence_egalite == d_vrai) 2182: { 2183: liberation(s_etat_processus, s_objet_evalue); 2184: } 2185: 2186: (*s_etat_processus).erreur_systeme = 2187: d_es_allocation_memoire; 2188: (*s_etat_processus).instruction_courante = 2189: instruction_courante; 2190: return(d_erreur); 2191: } 2192: 2193: /* 2194: * Clôture de l'expression 2195: */ 2196: 2197: if (((*l_element_fonction).suivant = 2198: (struct_liste_chainee *) malloc(sizeof( 2199: struct_liste_chainee))) == NULL) 2200: { 2201: if (presence_egalite == d_vrai) 2202: { 2203: liberation(s_etat_processus, s_objet_evalue); 2204: } 2205: 2206: (*s_etat_processus).erreur_systeme = 2207: d_es_allocation_memoire; 2208: (*s_etat_processus).instruction_courante = 2209: instruction_courante; 2210: return(d_erreur); 2211: } 2212: 2213: l_element_fonction = (*l_element_fonction).suivant; 2214: 2215: if (((*l_element_fonction).donnee = 2216: allocation(s_etat_processus, FCT)) == NULL) 2217: { 2218: if (presence_egalite == d_vrai) 2219: { 2220: liberation(s_etat_processus, s_objet_evalue); 2221: } 2222: 2223: (*s_etat_processus).erreur_systeme = 2224: d_es_allocation_memoire; 2225: (*s_etat_processus).instruction_courante = 2226: instruction_courante; 2227: return(d_erreur); 2228: } 2229: 2230: (*((struct_fonction *) (*(*l_element_fonction).donnee) 2231: .objet)).nombre_arguments = 0; 2232: (*((struct_fonction *) (*(*l_element_fonction).donnee) 2233: .objet)).fonction = 2234: instruction_vers_niveau_inferieur; 2235: 2236: if (((*((struct_fonction *) (*(*l_element_fonction) 2237: .donnee).objet)).nom_fonction = 2238: (unsigned char *) malloc(3 * sizeof( 2239: unsigned char))) == NULL) 2240: { 2241: if (presence_egalite == d_vrai) 2242: { 2243: liberation(s_etat_processus, s_objet_evalue); 2244: } 2245: 2246: (*s_etat_processus).erreur_systeme = 2247: d_es_allocation_memoire; 2248: (*s_etat_processus).instruction_courante = 2249: instruction_courante; 2250: return(d_erreur); 2251: } 2252: 2253: strcpy((*((struct_fonction *) (*(*l_element_fonction) 2254: .donnee).objet)).nom_fonction, ">>"); 2255: 2256: (*l_element_fonction).suivant = NULL; 2257: 2258: if (empilement(s_etat_processus, &((*s_etat_processus) 2259: .l_base_pile), s_objet_elementaire) == 2260: d_erreur) 2261: { 2262: if (presence_egalite == d_vrai) 2263: { 2264: liberation(s_etat_processus, s_objet_evalue); 2265: } 2266: 2267: (*s_etat_processus).instruction_courante = 2268: instruction_courante; 2269: return(d_erreur); 2270: } 2271: } 2272: 2273: (*s_etat_processus).expression_courante = 2274: registre_expression_courante; 2275: } 2276: else 2277: { 2278: if ((s_objet_elementaire = 2279: allocation(s_etat_processus, NON)) == NULL) 2280: { 2281: if (presence_egalite == d_vrai) 2282: { 2283: liberation(s_etat_processus, s_objet_evalue); 2284: } 2285: 2286: (*s_etat_processus).erreur_systeme = 2287: d_es_allocation_memoire; 2288: (*s_etat_processus).instruction_courante = 2289: instruction_courante; 2290: return(d_erreur); 2291: } 2292: 2293: if ((*(*s_etat_processus).pointeur_variable_courante).objet 2294: == NULL) 2295: { 2296: if (recherche_variable_partagee(s_etat_processus, 2297: (*(*s_etat_processus) 2298: .pointeur_variable_courante).nom, 2299: (*(*s_etat_processus) 2300: .pointeur_variable_courante).variable_partagee, 2301: 'E') != NULL) 2302: { 2303: // Une variable partagée existe. 2304: 2305: presence_variable_partagee = d_vrai; 2306: 2307: (*(*s_etat_processus).pointeur_variable_courante) 2308: .objet = (*(*s_etat_processus) 2309: .pointeur_variable_partagee_courante) 2310: .objet; 2311: } 2312: else 2313: { 2314: presence_variable_partagee = d_faux; 2315: } 2316: } 2317: else 2318: { 2319: presence_variable_partagee = d_faux; 2320: } 2321: 2322: /* 2323: * Recherche d'un élément dans un vecteur 2324: */ 2325: 2326: if ((*(*s_etat_processus).pointeur_variable_courante) 2327: .objet == NULL) 2328: { 2329: // La variable partagée n'existe plus. 2330: 2331: free(s_objet_elementaire); 2332: 2333: if ((s_objet_elementaire = 2334: copie_objet(s_etat_processus, 2335: (*l_element_courant).donnee, 'P')) == NULL) 2336: { 2337: if (presence_variable_partagee == d_vrai) 2338: { 2339: (*(*s_etat_processus) 2340: .pointeur_variable_courante).objet = 2341: NULL; 2342: 2343: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2344: .pointeur_variable_partagee_courante) 2345: .mutex)) != 0) 2346: { 2347: (*s_etat_processus).erreur_systeme = 2348: d_es_processus; 2349: } 2350: } 2351: 2352: (*s_etat_processus).erreur_systeme = 2353: d_es_allocation_memoire; 2354: return(d_erreur);; 2355: } 2356: } 2357: else if ((((*((*(*s_etat_processus) 2358: .pointeur_variable_courante).objet)).type == VIN) || 2359: ((*((*(*s_etat_processus) 2360: .pointeur_variable_courante).objet)).type == VRL) || 2361: ((*((*(*s_etat_processus) 2362: .pointeur_variable_courante).objet)).type == VCX)) 2363: && ((*((struct_fonction *) (*(*l_element_courant) 2364: .donnee).objet)).nombre_arguments == 1)) 2365: { 2366: if (depilement(s_etat_processus, &((*s_etat_processus) 2367: .l_base_pile), &s_objet_indice_i) == d_erreur) 2368: { 2369: free(s_objet_elementaire); 2370: 2371: if (presence_variable_partagee == d_vrai) 2372: { 2373: (*(*s_etat_processus) 2374: .pointeur_variable_courante).objet = 2375: NULL; 2376: 2377: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2378: .pointeur_variable_partagee_courante) 2379: .mutex)) != 0) 2380: { 2381: (*s_etat_processus).erreur_systeme = 2382: d_es_processus; 2383: } 2384: } 2385: 2386: if (presence_egalite == d_vrai) 2387: { 2388: liberation(s_etat_processus, s_objet_evalue); 2389: } 2390: 2391: (*s_etat_processus).erreur_execution = 2392: d_ex_manque_argument; 2393: (*s_etat_processus).instruction_courante = 2394: instruction_courante; 2395: (*s_etat_processus).mode_execution_programme = 2396: registre_mode_execution_programme; 2397: return(d_erreur); 2398: } 2399: 2400: if ((*s_objet_indice_i).type != INT) 2401: { 2402: liberation(s_etat_processus, s_objet_indice_i); 2403: free(s_objet_elementaire); 2404: 2405: if (presence_variable_partagee == d_vrai) 2406: { 2407: (*(*s_etat_processus) 2408: .pointeur_variable_courante).objet = 2409: NULL; 2410: 2411: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2412: .pointeur_variable_partagee_courante) 2413: .mutex)) != 0) 2414: { 2415: (*s_etat_processus).erreur_systeme = 2416: d_es_processus; 2417: } 2418: } 2419: 2420: if (presence_egalite == d_vrai) 2421: { 2422: liberation(s_etat_processus, s_objet_evalue); 2423: } 2424: 2425: (*s_etat_processus).erreur_execution = 2426: d_ex_erreur_type_argument; 2427: (*s_etat_processus).instruction_courante = 2428: instruction_courante; 2429: (*s_etat_processus).mode_execution_programme = 2430: registre_mode_execution_programme; 2431: return(d_erreur); 2432: } 2433: 2434: i = (*((integer8 *) (*s_objet_indice_i).objet)); 2435: 2436: liberation(s_etat_processus, s_objet_indice_i); 2437: 2438: if ((i < 1) || (i > (integer8) (*((struct_vecteur *) 2439: (*((*(*s_etat_processus) 2440: .pointeur_variable_courante).objet)).objet)) 2441: .taille)) 2442: { 2443: free(s_objet_elementaire); 2444: 2445: if (presence_variable_partagee == d_vrai) 2446: { 2447: (*(*s_etat_processus) 2448: .pointeur_variable_courante).objet = 2449: NULL; 2450: 2451: if (pthread_mutex_unlock(&((*(*s_etat_processus) 2452: .pointeur_variable_partagee_courante) 2453: .mutex)) != 0) 2454: { 2455: (*s_etat_processus).erreur_systeme = 2456: d_es_processus; 2457: } 2458: } 2459: 2460: if (presence_egalite == d_vrai) 2461: { 2462: liberation(s_etat_processus, s_objet_evalue); 2463: } 2464: 2465: (*s_etat_processus).erreur_execution = 2466: d_ex_element_inexistant; 2467: (*s_etat_processus).instruction_courante = 2468: instruction_courante; 2469: (*s_etat_processus).mode_execution_programme = 2470: registre_mode_execution_programme; 2471: return(d_erreur); 2472: } 2473: 2474: if ((*((*(*s_etat_processus) 2475: .pointeur_variable_courante).objet)).type 2476: == VIN) 2477: { 2478: if (((*s_objet_elementaire).objet = malloc(sizeof( 2479: integer8))) == NULL) 2480: { 2481: if (presence_egalite == d_vrai) 2482: { 2483: liberation(s_etat_processus, 2484: s_objet_evalue); 2485: } 2486: 2487: if (presence_variable_partagee == d_vrai) 2488: { 2489: (*(*s_etat_processus) 2490: .pointeur_variable_courante).objet = 2491: NULL; 2492: 2493: if (pthread_mutex_unlock( 2494: &((*(*s_etat_processus) 2495: .pointeur_variable_partagee_courante 2496: ).mutex)) != 0) 2497: { 2498: (*s_etat_processus).erreur_systeme = 2499: d_es_processus; 2500: } 2501: } 2502: 2503: (*s_etat_processus).erreur_systeme = 2504: d_es_allocation_memoire; 2505: (*s_etat_processus).instruction_courante = 2506: instruction_courante; 2507: return(d_erreur); 2508: } 2509: 2510: (*s_objet_elementaire).type = INT; 2511: (*((integer8 *) (*s_objet_elementaire).objet)) = 2512: ((integer8 *) (*((struct_vecteur *) 2513: (*((*(*s_etat_processus) 2514: .pointeur_variable_courante).objet)) 2515: .objet)).tableau)[i - 1]; 2516: } 2517: else if ((*((*(*s_etat_processus) 2518: .pointeur_variable_courante).objet)).type 2519: == VRL) 2520: { 2521: if (((*s_objet_elementaire).objet = malloc(sizeof( 2522: real8))) == NULL) 2523: { 2524: if (presence_variable_partagee == d_vrai) 2525: { 2526: (*(*s_etat_processus) 2527: .pointeur_variable_courante).objet = 2528: NULL; 2529: 2530: if (pthread_mutex_unlock( 2531: &((*(*s_etat_processus) 2532: .pointeur_variable_partagee_courante 2533: ).mutex)) != 0) 2534: { 2535: (*s_etat_processus).erreur_systeme = 2536: d_es_processus; 2537: } 2538: } 2539: 2540: if (presence_egalite == d_vrai) 2541: { 2542: liberation(s_etat_processus, 2543: s_objet_evalue); 2544: } 2545: 2546: (*s_etat_processus).erreur_systeme = 2547: d_es_allocation_memoire; 2548: (*s_etat_processus).instruction_courante = 2549: instruction_courante; 2550: return(d_erreur); 2551: } 2552: 2553: (*s_objet_elementaire).type = REL; 2554: (*((real8 *) (*s_objet_elementaire).objet)) = 2555: ((real8 *) (*((struct_vecteur *) 2556: (*((*(*s_etat_processus) 2557: .pointeur_variable_courante).objet)) 2558: .objet)).tableau)[i - 1]; 2559: } 2560: else if ((*((*(*s_etat_processus) 2561: .pointeur_variable_courante).objet)).type 2562: == VCX) 2563: { 2564: if (((*s_objet_elementaire).objet = malloc(sizeof( 2565: struct_complexe16))) == NULL) 2566: { 2567: if (presence_variable_partagee == d_vrai) 2568: { 2569: (*(*s_etat_processus) 2570: .pointeur_variable_courante).objet = 2571: NULL; 2572: 2573: if (pthread_mutex_unlock( 2574: &((*(*s_etat_processus) 2575: .pointeur_variable_partagee_courante 2576: ).mutex)) != 0) 2577: { 2578: (*s_etat_processus).erreur_systeme = 2579: d_es_processus; 2580: } 2581: } 2582: 2583: if (presence_egalite == d_vrai) 2584: { 2585: liberation(s_etat_processus, 2586: s_objet_evalue); 2587: } 2588: 2589: (*s_etat_processus).erreur_systeme = 2590: d_es_allocation_memoire; 2591: (*s_etat_processus).instruction_courante = 2592: instruction_courante; 2593: return(d_erreur); 2594: } 2595: 2596: (*s_objet_elementaire).type = CPL; 2597: (*((struct_complexe16 *) (*s_objet_elementaire) 2598: .objet)).partie_reelle = 2599: ((struct_complexe16 *) (*((struct_vecteur *) 2600: (*((*(*s_etat_processus) 2601: .pointeur_variable_courante).objet)) 2602: .objet)).tableau)[i - 1].partie_reelle; 2603: (*((struct_complexe16 *) (*s_objet_elementaire) 2604: .objet)).partie_imaginaire = 2605: ((struct_complexe16 *) (*((struct_vecteur *) 2606: (*((*(*s_etat_processus) 2607: .pointeur_variable_courante).objet)) 2608: .objet)).tableau)[i - 1].partie_imaginaire; 2609: } 2610: } 2611: 2612: /* 2613: * Recherche d'un élément dans une matrice 2614: */ 2615: 2616: else if ((((*((*(*s_etat_processus) 2617: .pointeur_variable_courante).objet)).type == MIN) || 2618: ((*((*(*s_etat_processus) 2619: .pointeur_variable_courante).objet)).type == MRL) || 2620: ((*((*(*s_etat_processus) 2621: .pointeur_variable_courante).objet)).type == MCX)) 2622: && ((*((struct_fonction *) (*(*l_element_courant) 2623: .donnee).objet)).nombre_arguments == 2)) 2624: { 2625: if (depilement(s_etat_processus, &((*s_etat_processus) 2626: .l_base_pile), &s_objet_indice_j) == d_erreur) 2627: { 2628: free(s_objet_elementaire); 2629: 2630: if (presence_variable_partagee == d_vrai) 2631: { 2632: (*(*s_etat_processus) 2633: .pointeur_variable_courante).objet = 2634: NULL; 2635: 2636: if (pthread_mutex_unlock( 2637: &((*(*s_etat_processus) 2638: .pointeur_variable_partagee_courante) 2639: .mutex)) != 0) 2640: { 2641: (*s_etat_processus).erreur_systeme = 2642: d_es_processus; 2643: } 2644: } 2645: 2646: if (presence_egalite == d_vrai) 2647: { 2648: liberation(s_etat_processus, s_objet_evalue); 2649: } 2650: 2651: (*s_etat_processus).erreur_execution = 2652: d_ex_manque_argument; 2653: (*s_etat_processus).instruction_courante = 2654: instruction_courante; 2655: (*s_etat_processus).mode_execution_programme = 2656: registre_mode_execution_programme; 2657: return(d_erreur); 2658: } 2659: 2660: if (depilement(s_etat_processus, &((*s_etat_processus) 2661: .l_base_pile), &s_objet_indice_i) == d_erreur) 2662: { 2663: liberation(s_etat_processus, s_objet_indice_j); 2664: free(s_objet_elementaire); 2665: 2666: if (presence_variable_partagee == d_vrai) 2667: { 2668: (*(*s_etat_processus) 2669: .pointeur_variable_courante).objet = 2670: NULL; 2671: 2672: if (pthread_mutex_unlock( 2673: &((*(*s_etat_processus) 2674: .pointeur_variable_partagee_courante) 2675: .mutex)) != 0) 2676: { 2677: (*s_etat_processus).erreur_systeme = 2678: d_es_processus; 2679: } 2680: } 2681: 2682: if (presence_egalite == d_vrai) 2683: { 2684: liberation(s_etat_processus, s_objet_evalue); 2685: } 2686: 2687: (*s_etat_processus).erreur_execution = 2688: d_ex_manque_argument; 2689: (*s_etat_processus).instruction_courante = 2690: instruction_courante; 2691: (*s_etat_processus).mode_execution_programme = 2692: registre_mode_execution_programme; 2693: return(d_erreur); 2694: } 2695: 2696: if (((*s_objet_indice_i).type != INT) || 2697: ((*s_objet_indice_j).type != INT)) 2698: { 2699: liberation(s_etat_processus, s_objet_indice_i); 2700: liberation(s_etat_processus, s_objet_indice_j); 2701: free(s_objet_elementaire); 2702: 2703: if (presence_variable_partagee == d_vrai) 2704: { 2705: (*(*s_etat_processus) 2706: .pointeur_variable_courante).objet = 2707: NULL; 2708: 2709: if (pthread_mutex_unlock( 2710: &((*(*s_etat_processus) 2711: .pointeur_variable_partagee_courante) 2712: .mutex)) != 0) 2713: { 2714: (*s_etat_processus).erreur_systeme = 2715: d_es_processus; 2716: } 2717: } 2718: 2719: if (presence_egalite == d_vrai) 2720: { 2721: liberation(s_etat_processus, s_objet_evalue); 2722: } 2723: 2724: (*s_etat_processus).erreur_execution = 2725: d_ex_erreur_type_argument; 2726: (*s_etat_processus).instruction_courante = 2727: instruction_courante; 2728: (*s_etat_processus).mode_execution_programme = 2729: registre_mode_execution_programme; 2730: return(d_erreur); 2731: } 2732: 2733: i = (*((integer8 *) (*s_objet_indice_i).objet)); 2734: j = (*((integer8 *) (*s_objet_indice_j).objet)); 2735: 2736: liberation(s_etat_processus, s_objet_indice_i); 2737: liberation(s_etat_processus, s_objet_indice_j); 2738: 2739: if ((i < 1) || (i > (integer8) (*((struct_matrice *) 2740: (*((*(*s_etat_processus) 2741: .pointeur_variable_courante).objet)).objet)) 2742: .nombre_lignes) || (j < 1) || (j > (integer8) 2743: (*((struct_matrice *) (*((*(*s_etat_processus) 2744: .pointeur_variable_courante).objet)).objet)) 2745: .nombre_colonnes)) 2746: { 2747: free(s_objet_elementaire); 2748: 2749: if (presence_variable_partagee == d_vrai) 2750: { 2751: (*(*s_etat_processus) 2752: .pointeur_variable_courante).objet = 2753: NULL; 2754: 2755: if (pthread_mutex_unlock( 2756: &((*(*s_etat_processus) 2757: .pointeur_variable_partagee_courante) 2758: .mutex)) != 0) 2759: { 2760: (*s_etat_processus).erreur_systeme = 2761: d_es_processus; 2762: } 2763: } 2764: 2765: if (presence_egalite == d_vrai) 2766: { 2767: liberation(s_etat_processus, s_objet_evalue); 2768: } 2769: 2770: (*s_etat_processus).erreur_execution = 2771: d_ex_element_inexistant; 2772: (*s_etat_processus).instruction_courante = 2773: instruction_courante; 2774: (*s_etat_processus).mode_execution_programme = 2775: registre_mode_execution_programme; 2776: return(d_erreur); 2777: } 2778: 2779: if ((*((*(*s_etat_processus).pointeur_variable_courante) 2780: .objet)).type == MIN) 2781: { 2782: if (((*s_objet_elementaire).objet = malloc(sizeof( 2783: integer8))) == NULL) 2784: { 2785: if (presence_variable_partagee == d_vrai) 2786: { 2787: (*(*s_etat_processus) 2788: .pointeur_variable_courante).objet = 2789: NULL; 2790: 2791: if (pthread_mutex_unlock( 2792: &((*(*s_etat_processus) 2793: .pointeur_variable_partagee_courante 2794: ).mutex)) != 0) 2795: { 2796: (*s_etat_processus).erreur_systeme = 2797: d_es_processus; 2798: } 2799: } 2800: 2801: if (presence_egalite == d_vrai) 2802: { 2803: liberation(s_etat_processus, 2804: s_objet_evalue); 2805: } 2806: 2807: (*s_etat_processus).erreur_systeme = 2808: d_es_allocation_memoire; 2809: (*s_etat_processus).instruction_courante = 2810: instruction_courante; 2811: return(d_erreur); 2812: } 2813: 2814: (*s_objet_elementaire).type = INT; 2815: (*((integer8 *) (*s_objet_elementaire).objet)) = 2816: ((integer8 **) (*((struct_matrice *) 2817: (*((*(*s_etat_processus) 2818: .pointeur_variable_courante).objet)) 2819: .objet)).tableau)[i - 1][j - 1]; 2820: } 2821: else if ((*((*(*s_etat_processus) 2822: .pointeur_variable_courante).objet)).type 2823: == MRL) 2824: { 2825: if (((*s_objet_elementaire).objet = malloc(sizeof( 2826: real8))) == NULL) 2827: { 2828: if (presence_variable_partagee == d_vrai) 2829: { 2830: (*(*s_etat_processus) 2831: .pointeur_variable_courante).objet = 2832: NULL; 2833: 2834: if (pthread_mutex_unlock( 2835: &((*(*s_etat_processus) 2836: .pointeur_variable_partagee_courante 2837: ).mutex)) != 0) 2838: { 2839: (*s_etat_processus).erreur_systeme = 2840: d_es_processus; 2841: } 2842: } 2843: 2844: if (presence_egalite == d_vrai) 2845: { 2846: liberation(s_etat_processus, 2847: s_objet_evalue); 2848: } 2849: 2850: (*s_etat_processus).erreur_systeme = 2851: d_es_allocation_memoire; 2852: (*s_etat_processus).instruction_courante = 2853: instruction_courante; 2854: return(d_erreur); 2855: } 2856: 2857: (*s_objet_elementaire).type = REL; 2858: (*((real8 *) (*s_objet_elementaire).objet)) = 2859: ((real8 **) (*((struct_matrice *) 2860: (*((*(*s_etat_processus) 2861: .pointeur_variable_courante).objet)) 2862: .objet)).tableau)[i - 1][j - 1]; 2863: } 2864: else if ((*((*(*s_etat_processus) 2865: .pointeur_variable_courante).objet)).type 2866: == MCX) 2867: { 2868: if (((*s_objet_elementaire).objet = malloc(sizeof( 2869: struct_complexe16))) == NULL) 2870: { 2871: if (presence_variable_partagee == d_vrai) 2872: { 2873: (*(*s_etat_processus) 2874: .pointeur_variable_courante).objet = 2875: NULL; 2876: 2877: if (pthread_mutex_unlock( 2878: &((*(*s_etat_processus) 2879: .pointeur_variable_partagee_courante 2880: ).mutex)) != 0) 2881: { 2882: (*s_etat_processus).erreur_systeme = 2883: d_es_processus; 2884: } 2885: } 2886: 2887: if (presence_egalite == d_vrai) 2888: { 2889: liberation(s_etat_processus, 2890: s_objet_evalue); 2891: } 2892: 2893: (*s_etat_processus).erreur_systeme = 2894: d_es_allocation_memoire; 2895: (*s_etat_processus).instruction_courante = 2896: instruction_courante; 2897: return(d_erreur); 2898: } 2899: 2900: (*s_objet_elementaire).type = CPL; 2901: (*((struct_complexe16 *) (*s_objet_elementaire) 2902: .objet)).partie_reelle = 2903: ((struct_complexe16 **) 2904: (*((struct_matrice *) 2905: (*((*(*s_etat_processus) 2906: .pointeur_variable_courante).objet)) 2907: .objet)).tableau)[i - 1][j - 1] 2908: .partie_reelle; 2909: (*((struct_complexe16 *) (*s_objet_elementaire) 2910: .objet)).partie_imaginaire = 2911: ((struct_complexe16 **) 2912: (*((struct_matrice *) 2913: (*((*(*s_etat_processus) 2914: .pointeur_variable_courante).objet)) 2915: .objet)).tableau)[i - 1][j - 1] 2916: .partie_imaginaire; 2917: } 2918: } 2919: 2920: /* 2921: * Recherche de l'élément idoine dans la liste 2922: */ 2923: 2924: else if (((*((*(*s_etat_processus) 2925: .pointeur_variable_courante).objet)).type == LST) && 2926: ((*((struct_fonction *) (*(*l_element_courant) 2927: .donnee).objet)).nombre_arguments == 1)) 2928: { 2929: if (depilement(s_etat_processus, &((*s_etat_processus) 2930: .l_base_pile), &s_objet_indice_i) == d_erreur) 2931: { 2932: free(s_objet_elementaire); 2933: 2934: if (presence_variable_partagee == d_vrai) 2935: { 2936: (*(*s_etat_processus) 2937: .pointeur_variable_courante).objet = 2938: NULL; 2939: 2940: if (pthread_mutex_unlock( 2941: &((*(*s_etat_processus) 2942: .pointeur_variable_partagee_courante) 2943: .mutex)) != 0) 2944: { 2945: (*s_etat_processus).erreur_systeme = 2946: d_es_processus; 2947: } 2948: } 2949: 2950: if (presence_egalite == d_vrai) 2951: { 2952: liberation(s_etat_processus, s_objet_evalue); 2953: } 2954: 2955: (*s_etat_processus).erreur_execution = 2956: d_ex_manque_argument; 2957: (*s_etat_processus).instruction_courante = 2958: instruction_courante; 2959: (*s_etat_processus).mode_execution_programme = 2960: registre_mode_execution_programme; 2961: return(d_erreur); 2962: } 2963: 2964: if ((*s_objet_indice_i).type != INT) 2965: { 2966: liberation(s_etat_processus, s_objet_indice_i); 2967: free(s_objet_elementaire); 2968: 2969: if (presence_variable_partagee == d_vrai) 2970: { 2971: (*(*s_etat_processus) 2972: .pointeur_variable_courante).objet = 2973: NULL; 2974: 2975: if (pthread_mutex_unlock( 2976: &((*(*s_etat_processus) 2977: .pointeur_variable_partagee_courante) 2978: .mutex)) != 0) 2979: { 2980: (*s_etat_processus).erreur_systeme = 2981: d_es_processus; 2982: } 2983: } 2984: 2985: if (presence_egalite == d_vrai) 2986: { 2987: liberation(s_etat_processus, s_objet_evalue); 2988: } 2989: 2990: (*s_etat_processus).erreur_execution = 2991: d_ex_erreur_type_argument; 2992: (*s_etat_processus).instruction_courante = 2993: instruction_courante; 2994: (*s_etat_processus).mode_execution_programme = 2995: registre_mode_execution_programme; 2996: return(d_erreur); 2997: } 2998: 2999: i = (*((integer8 *) (*s_objet_indice_i).objet)); 3000: 3001: liberation(s_etat_processus, s_objet_indice_i); 3002: 3003: l_sous_element_courant = (*((*(*s_etat_processus) 3004: .pointeur_variable_courante).objet)).objet; 3005: j = 0; 3006: 3007: while(l_sous_element_courant != NULL) 3008: { 3009: if ((++j) == i) 3010: { 3011: break; 3012: } 3013: 3014: l_sous_element_courant = 3015: (*l_sous_element_courant).suivant; 3016: } 3017: 3018: if (j != i) 3019: { 3020: free(s_objet_elementaire); 3021: 3022: if (presence_variable_partagee == d_vrai) 3023: { 3024: (*(*s_etat_processus) 3025: .pointeur_variable_courante).objet = 3026: NULL; 3027: 3028: if (pthread_mutex_unlock( 3029: &((*(*s_etat_processus) 3030: .pointeur_variable_partagee_courante) 3031: .mutex)) != 0) 3032: { 3033: (*s_etat_processus).erreur_systeme = 3034: d_es_processus; 3035: } 3036: } 3037: 3038: if (presence_egalite == d_vrai) 3039: { 3040: liberation(s_etat_processus, s_objet_evalue); 3041: } 3042: 3043: (*s_etat_processus).erreur_execution = 3044: d_ex_element_inexistant; 3045: (*s_etat_processus).instruction_courante = 3046: instruction_courante; 3047: (*s_etat_processus).mode_execution_programme = 3048: registre_mode_execution_programme; 3049: return(d_erreur); 3050: } 3051: 3052: free(s_objet_elementaire); 3053: 3054: if ((s_objet_elementaire = 3055: copie_objet(s_etat_processus, 3056: (*l_sous_element_courant).donnee, 'P')) == NULL) 3057: { 3058: if (presence_variable_partagee == d_vrai) 3059: { 3060: (*(*s_etat_processus) 3061: .pointeur_variable_courante).objet = 3062: NULL; 3063: 3064: if (pthread_mutex_unlock( 3065: &((*(*s_etat_processus) 3066: .pointeur_variable_partagee_courante) 3067: .mutex)) != 0) 3068: { 3069: (*s_etat_processus).erreur_systeme = 3070: d_es_processus; 3071: } 3072: } 3073: 3074: if (presence_egalite == d_vrai) 3075: { 3076: liberation(s_etat_processus, s_objet_evalue); 3077: } 3078: 3079: (*s_etat_processus).erreur_systeme = 3080: d_es_allocation_memoire; 3081: (*s_etat_processus).instruction_courante = 3082: instruction_courante; 3083: return(d_erreur); 3084: } 3085: } 3086: 3087: /* 3088: * Recherche de l'élément idoine dans la table 3089: */ 3090: 3091: else if (((*((*(*s_etat_processus) 3092: .pointeur_variable_courante).objet)).type == TBL) && 3093: ((*((struct_fonction *) (*(*l_element_courant) 3094: .donnee).objet)).nombre_arguments == 1)) 3095: { 3096: if (depilement(s_etat_processus, &((*s_etat_processus) 3097: .l_base_pile), &s_objet_indice_i) == d_erreur) 3098: { 3099: free(s_objet_elementaire); 3100: 3101: if (presence_variable_partagee == d_vrai) 3102: { 3103: (*(*s_etat_processus) 3104: .pointeur_variable_courante).objet = 3105: NULL; 3106: 3107: if (pthread_mutex_unlock( 3108: &((*(*s_etat_processus) 3109: .pointeur_variable_partagee_courante) 3110: .mutex)) != 0) 3111: { 3112: (*s_etat_processus).erreur_systeme = 3113: d_es_processus; 3114: } 3115: } 3116: 3117: if (presence_egalite == d_vrai) 3118: { 3119: liberation(s_etat_processus, s_objet_evalue); 3120: } 3121: 3122: (*s_etat_processus).erreur_execution = 3123: d_ex_manque_argument; 3124: (*s_etat_processus).instruction_courante = 3125: instruction_courante; 3126: (*s_etat_processus).mode_execution_programme = 3127: registre_mode_execution_programme; 3128: return(d_erreur); 3129: } 3130: 3131: if ((*s_objet_indice_i).type != INT) 3132: { 3133: liberation(s_etat_processus, s_objet_indice_i); 3134: free(s_objet_elementaire); 3135: 3136: if (presence_variable_partagee == d_vrai) 3137: { 3138: (*(*s_etat_processus) 3139: .pointeur_variable_courante).objet = 3140: NULL; 3141: 3142: if (pthread_mutex_unlock( 3143: &((*(*s_etat_processus) 3144: .pointeur_variable_partagee_courante) 3145: .mutex)) != 0) 3146: { 3147: (*s_etat_processus).erreur_systeme = 3148: d_es_processus; 3149: } 3150: } 3151: 3152: if (presence_egalite == d_vrai) 3153: { 3154: liberation(s_etat_processus, s_objet_evalue); 3155: } 3156: 3157: (*s_etat_processus).erreur_execution = 3158: d_ex_erreur_type_argument; 3159: (*s_etat_processus).instruction_courante = 3160: instruction_courante; 3161: (*s_etat_processus).mode_execution_programme = 3162: registre_mode_execution_programme; 3163: return(d_erreur); 3164: } 3165: 3166: i = (*((integer8 *) (*s_objet_indice_i).objet)); 3167: 3168: liberation(s_etat_processus, s_objet_indice_i); 3169: 3170: if ((i < 1) || (i > (integer8) (*((struct_tableau *) 3171: (*(*(*s_etat_processus) 3172: .pointeur_variable_courante).objet) 3173: .objet)).nombre_elements)) 3174: { 3175: free(s_objet_elementaire); 3176: 3177: if (presence_variable_partagee == d_vrai) 3178: { 3179: (*(*s_etat_processus) 3180: .pointeur_variable_courante).objet = 3181: NULL; 3182: 3183: if (pthread_mutex_unlock( 3184: &((*(*s_etat_processus) 3185: .pointeur_variable_partagee_courante) 3186: .mutex)) != 0) 3187: { 3188: (*s_etat_processus).erreur_systeme = 3189: d_es_processus; 3190: } 3191: } 3192: 3193: if (presence_egalite == d_vrai) 3194: { 3195: liberation(s_etat_processus, s_objet_evalue); 3196: } 3197: 3198: (*s_etat_processus).erreur_execution = 3199: d_ex_element_inexistant; 3200: (*s_etat_processus).instruction_courante = 3201: instruction_courante; 3202: (*s_etat_processus).mode_execution_programme = 3203: registre_mode_execution_programme; 3204: return(d_erreur); 3205: } 3206: 3207: free(s_objet_elementaire); 3208: 3209: if ((s_objet_elementaire = 3210: copie_objet(s_etat_processus, 3211: (*((struct_tableau *) (*(*(*s_etat_processus) 3212: .pointeur_variable_courante).objet) 3213: .objet)).elements[i - 1], 'P')) == NULL) 3214: { 3215: if (presence_variable_partagee == d_vrai) 3216: { 3217: (*(*s_etat_processus) 3218: .pointeur_variable_courante).objet = 3219: NULL; 3220: 3221: if (pthread_mutex_unlock( 3222: &((*(*s_etat_processus) 3223: .pointeur_variable_partagee_courante) 3224: .mutex)) != 0) 3225: { 3226: (*s_etat_processus).erreur_systeme = 3227: d_es_processus; 3228: } 3229: } 3230: 3231: if (presence_egalite == d_vrai) 3232: { 3233: liberation(s_etat_processus, s_objet_evalue); 3234: } 3235: 3236: (*s_etat_processus).erreur_systeme = 3237: d_es_allocation_memoire; 3238: (*s_etat_processus).instruction_courante = 3239: instruction_courante; 3240: return(d_erreur); 3241: } 3242: } 3243: else if (((*((*(*s_etat_processus) 3244: .pointeur_variable_courante).objet)).type == ALG) || 3245: ((*((*(*s_etat_processus) 3246: .pointeur_variable_courante).objet)).type == RPN)) 3247: { 3248: registre_evaluation_expression_compilee = 3249: (*s_etat_processus) 3250: .evaluation_expression_compilee; 3251: 3252: if (((*(*s_etat_processus).pointeur_variable_courante) 3253: .origine == 'E') && ((*(*s_etat_processus) 3254: .pointeur_variable_courante).niveau == 0)) 3255: { 3256: (*s_etat_processus).evaluation_expression_compilee = 3257: 'Y'; 3258: } 3259: else 3260: { 3261: (*s_etat_processus).evaluation_expression_compilee = 3262: 'N'; 3263: } 3264: 3265: if (evaluation(s_etat_processus, (*(*s_etat_processus) 3266: .pointeur_variable_courante).objet, 3267: type_evaluation) == d_erreur) 3268: { 3269: (*s_etat_processus).evaluation_expression_compilee = 3270: registre_evaluation_expression_compilee; 3271: 3272: if (presence_variable_partagee == d_vrai) 3273: { 3274: (*(*s_etat_processus) 3275: .pointeur_variable_courante).objet = 3276: NULL; 3277: 3278: if (pthread_mutex_unlock( 3279: &((*(*s_etat_processus) 3280: .pointeur_variable_partagee_courante) 3281: .mutex)) != 0) 3282: { 3283: (*s_etat_processus).erreur_systeme = 3284: d_es_processus; 3285: } 3286: } 3287: 3288: if (presence_egalite == d_vrai) 3289: { 3290: liberation(s_etat_processus, s_objet_evalue); 3291: } 3292: 3293: (*s_etat_processus).instruction_courante = 3294: instruction_courante; 3295: (*s_etat_processus).mode_execution_programme = 3296: registre_mode_execution_programme; 3297: return(d_erreur); 3298: } 3299: 3300: (*s_etat_processus).evaluation_expression_compilee = 3301: registre_evaluation_expression_compilee; 3302: 3303: free(s_objet_elementaire); 3304: 3305: if (depilement(s_etat_processus, &((*s_etat_processus) 3306: .l_base_pile), &s_objet_elementaire) 3307: == d_erreur) 3308: { 3309: if (presence_variable_partagee == d_vrai) 3310: { 3311: (*(*s_etat_processus) 3312: .pointeur_variable_courante).objet = 3313: NULL; 3314: 3315: if (pthread_mutex_unlock( 3316: &((*(*s_etat_processus) 3317: .pointeur_variable_partagee_courante) 3318: .mutex)) != 0) 3319: { 3320: (*s_etat_processus).erreur_systeme = 3321: d_es_processus; 3322: } 3323: } 3324: 3325: if (presence_egalite == d_vrai) 3326: { 3327: liberation(s_etat_processus, s_objet_evalue); 3328: } 3329: 3330: (*s_etat_processus).erreur_execution = 3331: d_ex_manque_argument; 3332: (*s_etat_processus).instruction_courante = 3333: instruction_courante; 3334: (*s_etat_processus).mode_execution_programme = 3335: registre_mode_execution_programme; 3336: return(d_erreur); 3337: } 3338: } 3339: else if ((*((*(*s_etat_processus) 3340: .pointeur_variable_courante).objet)).type == ADR) 3341: { 3342: autorisation_empilement_programme = (*s_etat_processus) 3343: .autorisation_empilement_programme; 3344: registre_position_courante = (*s_etat_processus) 3345: .position_courante; 3346: 3347: empilement_pile_systeme(s_etat_processus); 3348: 3349: if ((*s_etat_processus).erreur_systeme != d_es) 3350: { 3351: if (presence_variable_partagee == d_vrai) 3352: { 3353: (*(*s_etat_processus) 3354: .pointeur_variable_courante).objet = 3355: NULL; 3356: 3357: if (pthread_mutex_unlock( 3358: &((*(*s_etat_processus) 3359: .pointeur_variable_partagee_courante) 3360: .mutex)) != 0) 3361: { 3362: (*s_etat_processus).erreur_systeme = 3363: d_es_processus; 3364: } 3365: } 3366: 3367: if (presence_egalite == d_vrai) 3368: { 3369: liberation(s_etat_processus, s_objet_evalue); 3370: } 3371: 3372: depilement_pile_systeme(s_etat_processus); 3373: 3374: (*s_etat_processus).instruction_courante = 3375: instruction_courante; 3376: return(d_erreur); 3377: } 3378: 3379: (*(*s_etat_processus).l_base_pile_systeme) 3380: .retour_definition = 'Y'; 3381: (*(*s_etat_processus).l_base_pile_systeme) 3382: .origine_routine_evaluation = 'Y'; 3383: 3384: (*s_etat_processus).mode_execution_programme = 'Y'; 3385: (*s_etat_processus).autorisation_empilement_programme 3386: = 'N'; 3387: 3388: (*(*s_etat_processus).l_base_pile_systeme) 3389: .niveau_courant = (*s_etat_processus) 3390: .niveau_courant; 3391: 3392: (*s_etat_processus).position_courante = 3393: (*((integer8 *) ((*(*(*s_etat_processus) 3394: .pointeur_variable_courante).objet).objet))); 3395: 3396: if ((*s_etat_processus).profilage == d_vrai) 3397: { 3398: profilage(s_etat_processus, 3399: (*(*s_etat_processus) 3400: .pointeur_variable_courante).nom); 3401: 3402: if ((*s_etat_processus).erreur_systeme != d_es) 3403: { 3404: if (presence_variable_partagee == d_vrai) 3405: { 3406: (*(*s_etat_processus) 3407: .pointeur_variable_courante).objet = 3408: NULL; 3409: 3410: if (pthread_mutex_unlock( 3411: &((*(*s_etat_processus) 3412: .pointeur_variable_partagee_courante 3413: ).mutex)) != 0) 3414: { 3415: (*s_etat_processus).erreur_systeme = 3416: d_es_processus; 3417: } 3418: } 3419: 3420: return(d_erreur); 3421: } 3422: } 3423: 3424: registre_evaluation_forcee = 3425: (*s_etat_processus).evaluation_forcee; 3426: 3427: if (type_evaluation == 'N') 3428: { 3429: (*s_etat_processus).evaluation_forcee = 'Y'; 3430: } 3431: 3432: if (sequenceur(s_etat_processus) == d_erreur) 3433: { 3434: (*s_etat_processus).evaluation_forcee = 3435: registre_evaluation_forcee; 3436: 3437: if (presence_variable_partagee == d_vrai) 3438: { 3439: (*(*s_etat_processus) 3440: .pointeur_variable_courante).objet = 3441: NULL; 3442: 3443: if (pthread_mutex_unlock(&((*(*s_etat_processus) 3444: .pointeur_variable_partagee_courante) 3445: .mutex)) != 0) 3446: { 3447: (*s_etat_processus).erreur_systeme = 3448: d_es_processus; 3449: } 3450: } 3451: 3452: if (presence_egalite == d_vrai) 3453: { 3454: liberation(s_etat_processus, s_objet_evalue); 3455: } 3456: 3457: depilement_pile_systeme(s_etat_processus); 3458: 3459: (*s_etat_processus).instruction_courante = 3460: instruction_courante; 3461: (*s_etat_processus).mode_execution_programme = 3462: registre_mode_execution_programme; 3463: return(d_erreur); 3464: } 3465: 3466: (*s_etat_processus).evaluation_forcee = 3467: registre_evaluation_forcee; 3468: (*s_etat_processus).instruction_courante = 3469: instruction_courante; 3470: (*s_etat_processus).mode_execution_programme = 'N'; 3471: 3472: depilement_pile_systeme(s_etat_processus); 3473: 3474: if ((*s_etat_processus).erreur_systeme != d_es) 3475: { 3476: if (presence_variable_partagee == d_vrai) 3477: { 3478: (*(*s_etat_processus) 3479: .pointeur_variable_courante).objet = 3480: NULL; 3481: 3482: if (pthread_mutex_unlock(&((*(*s_etat_processus) 3483: .pointeur_variable_partagee_courante) 3484: .mutex)) != 0) 3485: { 3486: (*s_etat_processus).erreur_systeme = 3487: d_es_processus; 3488: } 3489: } 3490: 3491: if (presence_egalite == d_vrai) 3492: { 3493: liberation(s_etat_processus, s_objet_evalue); 3494: } 3495: 3496: return(d_erreur); 3497: } 3498: 3499: (*s_etat_processus).retour_routine_evaluation = 'N'; 3500: (*s_etat_processus).position_courante = 3501: registre_position_courante; 3502: (*s_etat_processus).autorisation_empilement_programme = 3503: autorisation_empilement_programme; 3504: 3505: free(s_objet_elementaire); 3506: 3507: if (depilement(s_etat_processus, &((*s_etat_processus) 3508: .l_base_pile), &s_objet_elementaire) 3509: == d_erreur) 3510: { 3511: if (presence_variable_partagee == d_vrai) 3512: { 3513: (*(*s_etat_processus) 3514: .pointeur_variable_courante).objet = 3515: NULL; 3516: 3517: if (pthread_mutex_unlock(&((*(*s_etat_processus) 3518: .pointeur_variable_partagee_courante) 3519: .mutex)) != 0) 3520: { 3521: (*s_etat_processus).erreur_systeme = 3522: d_es_processus; 3523: } 3524: } 3525: 3526: if (presence_egalite == d_vrai) 3527: { 3528: liberation(s_etat_processus, s_objet_evalue); 3529: } 3530: 3531: (*s_etat_processus).erreur_execution = 3532: d_ex_manque_argument; 3533: (*s_etat_processus).instruction_courante = 3534: instruction_courante; 3535: (*s_etat_processus).mode_execution_programme = 3536: registre_mode_execution_programme; 3537: return(d_erreur); 3538: } 3539: } 3540: else 3541: { 3542: if (presence_variable_partagee == d_vrai) 3543: { 3544: (*(*s_etat_processus) 3545: .pointeur_variable_courante).objet = 3546: NULL; 3547: 3548: if (pthread_mutex_unlock(&((*(*s_etat_processus) 3549: .pointeur_variable_partagee_courante) 3550: .mutex)) != 0) 3551: { 3552: (*s_etat_processus).erreur_systeme = 3553: d_es_processus; 3554: } 3555: } 3556: 3557: if (presence_egalite == d_vrai) 3558: { 3559: liberation(s_etat_processus, s_objet_evalue); 3560: } 3561: 3562: (*s_etat_processus).erreur_execution = 3563: d_ex_element_inexistant; 3564: (*s_etat_processus).instruction_courante = 3565: instruction_courante; 3566: (*s_etat_processus).mode_execution_programme = 3567: registre_mode_execution_programme; 3568: 3569: return(d_erreur); 3570: } 3571: 3572: if (empilement(s_etat_processus, &((*s_etat_processus) 3573: .l_base_pile), s_objet_elementaire) == d_erreur) 3574: { 3575: if (presence_variable_partagee == d_vrai) 3576: { 3577: (*(*s_etat_processus) 3578: .pointeur_variable_courante).objet = 3579: NULL; 3580: 3581: if (pthread_mutex_unlock(&((*(*s_etat_processus) 3582: .pointeur_variable_partagee_courante) 3583: .mutex)) != 0) 3584: { 3585: (*s_etat_processus).erreur_systeme = 3586: d_es_processus; 3587: } 3588: } 3589: 3590: if (presence_egalite == d_vrai) 3591: { 3592: liberation(s_etat_processus, s_objet_evalue); 3593: } 3594: 3595: (*s_etat_processus).instruction_courante = 3596: instruction_courante; 3597: return(d_erreur); 3598: } 3599: 3600: if (presence_variable_partagee == d_vrai) 3601: { 3602: (*(*s_etat_processus) 3603: .pointeur_variable_courante).objet = NULL; 3604: 3605: if (pthread_mutex_unlock(&((*(*s_etat_processus) 3606: .pointeur_variable_partagee_courante).mutex)) 3607: != 0) 3608: { 3609: (*s_etat_processus).erreur_systeme = 3610: d_es_processus; 3611: } 3612: } 3613: } 3614: } 3615: else if (((*(*l_element_courant).donnee).type == ALG) 3616: || ((*(*l_element_courant).donnee).type == RPN)) 3617: { 3618: if (type_evaluation == 'I') 3619: { 3620: if ((s_objet_elementaire = copie_objet(s_etat_processus, 3621: (*l_element_courant).donnee, 'P')) == NULL) 3622: { 3623: if (presence_egalite == d_vrai) 3624: { 3625: liberation(s_etat_processus, s_objet_evalue); 3626: } 3627: 3628: (*s_etat_processus).erreur_systeme = 3629: d_es_allocation_memoire; 3630: (*s_etat_processus).instruction_courante = 3631: instruction_courante; 3632: return(d_erreur); 3633: } 3634: 3635: if (empilement(s_etat_processus, &((*s_etat_processus) 3636: .l_base_pile), s_objet_elementaire) 3637: == d_erreur) 3638: { 3639: if (presence_egalite == d_vrai) 3640: { 3641: liberation(s_etat_processus, s_objet_evalue); 3642: } 3643: 3644: (*s_etat_processus).instruction_courante = 3645: instruction_courante; 3646: return(d_erreur); 3647: } 3648: } 3649: else 3650: { 3651: if ((*s_etat_processus).autorisation_empilement_programme 3652: == 'N') 3653: { 3654: registre_evaluation_expression_compilee = 3655: (*s_etat_processus) 3656: .evaluation_expression_compilee; 3657: 3658: (*s_etat_processus).evaluation_expression_compilee 3659: = 'Y'; 3660: 3661: if (evaluation(s_etat_processus, (*l_element_courant) 3662: .donnee, type_evaluation) == d_erreur) 3663: { 3664: (*s_etat_processus).evaluation_expression_compilee 3665: = registre_evaluation_expression_compilee; 3666: 3667: if (presence_egalite == d_vrai) 3668: { 3669: liberation(s_etat_processus, s_objet_evalue); 3670: } 3671: 3672: (*s_etat_processus).instruction_courante = 3673: instruction_courante; 3674: (*s_etat_processus).mode_execution_programme = 3675: registre_mode_execution_programme; 3676: return(d_erreur); 3677: } 3678: 3679: (*s_etat_processus).evaluation_expression_compilee 3680: = registre_evaluation_expression_compilee; 3681: } 3682: else 3683: { 3684: if ((s_objet_elementaire = 3685: copie_objet(s_etat_processus, 3686: (*l_element_courant).donnee, 'P')) == NULL) 3687: { 3688: if (presence_egalite == d_vrai) 3689: { 3690: liberation(s_etat_processus, s_objet_evalue); 3691: } 3692: 3693: (*s_etat_processus).erreur_systeme = 3694: d_es_allocation_memoire; 3695: (*s_etat_processus).instruction_courante = 3696: instruction_courante; 3697: return(d_erreur); 3698: } 3699: 3700: if (empilement(s_etat_processus, &((*s_etat_processus) 3701: .l_base_pile), s_objet_elementaire) 3702: == d_erreur) 3703: { 3704: if (presence_egalite == d_vrai) 3705: { 3706: liberation(s_etat_processus, s_objet_evalue); 3707: } 3708: 3709: (*s_etat_processus).instruction_courante = 3710: instruction_courante; 3711: return(d_erreur); 3712: } 3713: } 3714: } 3715: } 3716: else if ((*(*l_element_courant).donnee).type == NOM) 3717: { 3718: registre_instruction_valide = (*s_etat_processus) 3719: .instruction_valide; 3720: registre_test = (*s_etat_processus).test_instruction; 3721: (*s_etat_processus).test_instruction = 'Y'; 3722: (*s_etat_processus).instruction_courante = (*((struct_nom *) 3723: (*(*l_element_courant).donnee).objet)).nom; 3724: 3725: analyse(s_etat_processus, NULL); 3726: 3727: (*s_etat_processus).test_instruction = 'N'; 3728: 3729: if ((*s_etat_processus).instruction_valide == 'Y') 3730: { 3731: registre_test_2 = (*s_etat_processus).test_instruction; 3732: (*s_etat_processus).test_instruction = 'N'; 3733: 3734: registre_type_evaluation = (test_cfsf(s_etat_processus, 35) 3735: == d_vrai) ? 'E' : 'N'; 3736: 3737: if (type_evaluation == 'N') 3738: { 3739: cf(s_etat_processus, 35); 3740: } 3741: else 3742: { 3743: sf(s_etat_processus, 35); 3744: } 3745: 3746: analyse(s_etat_processus, NULL); 3747: 3748: if (registre_type_evaluation == 'E') 3749: { 3750: sf(s_etat_processus, 35); 3751: } 3752: else 3753: { 3754: cf(s_etat_processus, 35); 3755: } 3756: 3757: (*s_etat_processus).test_instruction = registre_test_2; 3758: 3759: if ((*s_etat_processus).erreur_systeme != d_es) 3760: { 3761: if (presence_egalite == d_vrai) 3762: { 3763: liberation(s_etat_processus, s_objet_evalue); 3764: } 3765: 3766: if ((*s_etat_processus).var_volatile_processus_pere 3767: == 0) 3768: { 3769: envoi_signal_processus((*s_etat_processus) 3770: .pid_processus_pere, rpl_sigalrm); 3771: } 3772: else 3773: { 3774: (*s_etat_processus).var_volatile_alarme = -1; 3775: } 3776: 3777: (*s_etat_processus).instruction_courante = 3778: instruction_courante; 3779: return(d_erreur); 3780: } 3781: else if (((*s_etat_processus).erreur_execution != d_ex) || 3782: ((*s_etat_processus).exception != d_ep)) 3783: { 3784: if ((*s_etat_processus).arret_si_exception == d_faux) 3785: { 3786: /* 3787: * Reprise sur erreur 3788: */ 3789: 3790: if ((message = messages(s_etat_processus)) == NULL) 3791: { 3792: if (presence_egalite == d_vrai) 3793: { 3794: liberation(s_etat_processus, 3795: s_objet_evalue); 3796: } 3797: 3798: (*s_etat_processus).instruction_courante = 3799: instruction_courante; 3800: return(d_erreur); 3801: } 3802: 3803: free(message); 3804: 3805: while((*(*s_etat_processus).l_base_pile_systeme) 3806: .clause != 'R') 3807: { 3808: l_registre_atome = l_element_courant; 3809: l_element_courant = 3810: (*l_element_courant).suivant; 3811: 3812: if (l_element_courant == NULL) 3813: { 3814: /* 3815: * La fin de l'expression est atteinte, 3816: * le sequenceur reprend la main. 3817: */ 3818: 3819: if (presence_egalite == d_vrai) 3820: { 3821: liberation(s_etat_processus, 3822: s_objet_evalue); 3823: } 3824: 3825: (*s_etat_processus) 3826: .mode_execution_programme = 3827: registre_mode_execution_programme; 3828: return(d_absence_erreur); 3829: } 3830: 3831: if ((*(*l_element_courant).donnee).type == FCT) 3832: { 3833: (*s_etat_processus).instruction_courante = 3834: (*((struct_fonction *) 3835: (*(*l_element_courant).donnee) 3836: .objet)).nom_fonction; 3837: 3838: if (recherche_variable(s_etat_processus, 3839: (*s_etat_processus) 3840: .instruction_courante) == d_faux) 3841: { 3842: (*s_etat_processus).erreur_systeme 3843: = d_es; 3844: fonction = (*((struct_fonction *) 3845: (*(*l_element_courant).donnee) 3846: .objet)).fonction; 3847: 3848: /* 3849: * Traitement de la pile système par les 3850: * différentes instructions. 3851: */ 3852: 3853: if (TEST(instruction_if) || 3854: TEST(instruction_iferr) || 3855: TEST(instruction_do) || 3856: TEST(instruction_while) || 3857: TEST(instruction_for) || 3858: TEST(instruction_forall) || 3859: TEST(instruction_start) || 3860: TEST(instruction_select) || 3861: TEST(instruction_case) || 3862: TEST(instruction_critical) || 3863: TEST(vers_niveau_superieur)) 3864: { 3865: if (TEST(vers_niveau_superieur)) 3866: { 3867: registre_exception = 3868: (*s_etat_processus) 3869: .exception; 3870: registre_erreur_execution = 3871: (*s_etat_processus) 3872: .erreur_execution; 3873: 3874: analyse(s_etat_processus, 3875: vers_niveau_superieur); 3876: 3877: if ((*s_etat_processus) 3878: .erreur_systeme != d_es) 3879: { 3880: if (presence_egalite == 3881: d_vrai) 3882: { 3883: liberation( 3884: s_etat_processus, 3885: s_objet_evalue); 3886: } 3887: 3888: (*s_etat_processus) 3889: .instruction_courante = 3890: instruction_courante; 3891: return(d_erreur); 3892: } 3893: 3894: (*s_etat_processus).exception 3895: = registre_exception; 3896: (*s_etat_processus) 3897: .erreur_execution = 3898: registre_erreur_execution; 3899: } 3900: else if (TEST(instruction_for) || 3901: TEST(instruction_forall) || 3902: TEST(instruction_start)) 3903: { 3904: empilement_pile_systeme( 3905: s_etat_processus); 3906: 3907: if ((*s_etat_processus) 3908: .erreur_systeme != d_es) 3909: { 3910: if (presence_egalite == 3911: d_vrai) 3912: { 3913: liberation( 3914: s_etat_processus, 3915: s_objet_evalue); 3916: } 3917: 3918: (*s_etat_processus) 3919: .instruction_courante = 3920: instruction_courante; 3921: return(d_erreur); 3922: } 3923: 3924: (*(*s_etat_processus) 3925: .l_base_pile_systeme) 3926: .type_cloture = 'L'; 3927: } 3928: else 3929: { 3930: empilement_pile_systeme( 3931: s_etat_processus); 3932: 3933: if ((*s_etat_processus) 3934: .erreur_systeme != d_es) 3935: { 3936: if (presence_egalite == 3937: d_vrai) 3938: { 3939: liberation( 3940: s_etat_processus, 3941: s_objet_evalue); 3942: } 3943: 3944: (*s_etat_processus) 3945: .instruction_courante = 3946: instruction_courante; 3947: return(d_erreur); 3948: } 3949: } 3950: } 3951: else if (TEST(instruction_end) || 3952: TEST(instruction_next) || 3953: TEST(instruction_step) || 3954: TEST(vers_niveau_inferieur)) 3955: { 3956: if (TEST(vers_niveau_inferieur)) 3957: { 3958: registre_exception = 3959: (*s_etat_processus) 3960: .exception; 3961: registre_erreur_execution = 3962: (*s_etat_processus) 3963: .erreur_execution; 3964: 3965: analyse(s_etat_processus, 3966: vers_niveau_inferieur); 3967: 3968: if ((*s_etat_processus) 3969: .erreur_systeme != d_es) 3970: { 3971: if (presence_egalite == 3972: d_vrai) 3973: { 3974: liberation( 3975: s_etat_processus, 3976: s_objet_evalue); 3977: } 3978: 3979: (*s_etat_processus) 3980: .instruction_courante = 3981: instruction_courante; 3982: return(d_erreur); 3983: } 3984: 3985: (*s_etat_processus).exception 3986: = registre_exception; 3987: (*s_etat_processus) 3988: .erreur_execution = 3989: registre_erreur_execution; 3990: } 3991: else if ((TEST(instruction_next) || 3992: TEST(instruction_step)) && 3993: ((*(*s_etat_processus) 3994: .l_base_pile_systeme) 3995: .type_cloture != 'L')) 3996: { 3997: /* 3998: * Libération des compteurs 3999: * de boucle 4000: */ 4001: 4002: presence_compteur = 4003: (((*(*s_etat_processus) 4004: .l_base_pile_systeme) 4005: .type_cloture == 'F') || 4006: ((*(*s_etat_processus) 4007: .l_base_pile_systeme) 4008: .type_cloture == 'A')) 4009: ? d_vrai : d_faux; 4010: 4011: if (((*(*s_etat_processus) 4012: .l_base_pile_systeme) 4013: .type_cloture != 'S') && 4014: (presence_compteur == 4015: d_faux)) 4016: { 4017: (*s_etat_processus) 4018: .erreur_execution = 4019: d_ex_erreur_traitement_boucle; 4020: 4021: if (presence_egalite == 4022: d_vrai) 4023: { 4024: liberation( 4025: s_etat_processus, 4026: s_objet_evalue); 4027: } 4028: 4029: (*s_etat_processus) 4030: .instruction_courante = 4031: instruction_courante; 4032: return(d_erreur); 4033: } 4034: 4035: if (presence_compteur == d_vrai) 4036: { 4037: if (recherche_variable( 4038: s_etat_processus, 4039: (*(*s_etat_processus) 4040: .l_base_pile_systeme) 4041: .nom_variable) == 4042: d_faux) 4043: { 4044: (*s_etat_processus) 4045: .erreur_systeme = d_es; 4046: (*s_etat_processus) 4047: .erreur_execution = 4048: d_ex_erreur_traitement_boucle; 4049: 4050: if (presence_egalite == 4051: d_vrai) 4052: { 4053: liberation( 4054: s_etat_processus, 4055: s_objet_evalue); 4056: } 4057: 4058: (*s_etat_processus) 4059: .instruction_courante = 4060: instruction_courante; 4061: return(d_erreur); 4062: } 4063: 4064: if ((*(*s_etat_processus) 4065: .pointeur_variable_courante) 4066: .objet == NULL) 4067: { 4068: (*s_etat_processus) 4069: .erreur_systeme = d_es; 4070: (*s_etat_processus) 4071: .erreur_execution = 4072: d_ex_variable_partagee; 4073: 4074: if (presence_egalite == 4075: d_vrai) 4076: { 4077: liberation( 4078: s_etat_processus, 4079: s_objet_evalue); 4080: } 4081: 4082: (*s_etat_processus) 4083: .instruction_courante = 4084: instruction_courante; 4085: return(d_erreur); 4086: } 4087: 4088: (*s_etat_processus) 4089: .niveau_courant--; 4090: 4091: if ( 4092: retrait_variables_par_niveau( 4093: s_etat_processus) == d_erreur) 4094: { 4095: if (presence_egalite == 4096: d_vrai) 4097: { 4098: liberation( 4099: s_etat_processus, 4100: s_objet_evalue); 4101: } 4102: 4103: (*s_etat_processus) 4104: .instruction_courante = 4105: instruction_courante; 4106: return(d_erreur); 4107: } 4108: } 4109: 4110: depilement_pile_systeme( 4111: s_etat_processus); 4112: } 4113: else 4114: { 4115: // Traitement spécifique pour la 4116: // fin d'une section critique 4117: 4118: if ((*s_etat_processus) 4119: .l_base_pile_systeme == 4120: NULL) 4121: { 4122: (*s_etat_processus) 4123: .erreur_systeme = 4124: d_es_end_incoherent; 4125: 4126: if (presence_egalite == 4127: d_vrai) 4128: { 4129: liberation( 4130: s_etat_processus, 4131: s_objet_evalue); 4132: } 4133: 4134: (*s_etat_processus) 4135: .instruction_courante = 4136: instruction_courante; 4137: return(d_erreur); 4138: } 4139: 4140: if ((*(*s_etat_processus) 4141: .l_base_pile_systeme) 4142: .type_cloture == 'Q') 4143: { 4144: if (pthread_mutex_unlock( 4145: &mutex_sections_critiques) 4146: != 0) 4147: { 4148: (*s_etat_processus) 4149: .erreur_systeme = 4150: d_es_processus; 4151: 4152: if (presence_egalite == 4153: d_vrai) 4154: { 4155: liberation( 4156: s_etat_processus, 4157: s_objet_evalue); 4158: } 4159: 4160: (*s_etat_processus) 4161: .instruction_courante = 4162: instruction_courante; 4163: return(d_erreur); 4164: } 4165: 4166: (*s_etat_processus) 4167: .sections_critiques--; 4168: } 4169: 4170: depilement_pile_systeme( 4171: s_etat_processus); 4172: 4173: if ((*s_etat_processus) 4174: .erreur_systeme != d_es) 4175: { 4176: if (presence_egalite == 4177: d_vrai) 4178: { 4179: liberation( 4180: s_etat_processus, 4181: s_objet_evalue); 4182: } 4183: 4184: (*s_etat_processus) 4185: .instruction_courante = 4186: instruction_courante; 4187: return(d_erreur); 4188: } 4189: } 4190: } 4191: } 4192: } 4193: } 4194: 4195: (*s_etat_processus).instruction_courante = 4196: instruction_courante; 4197: drapeau_then = d_faux; 4198: 4199: do 4200: { 4201: l_registre_atome = l_element_courant; 4202: 4203: if (l_element_courant == NULL) 4204: { 4205: /* 4206: * La fin de l'expression est atteinte, 4207: * le sequenceur reprend la main. 4208: */ 4209: 4210: if (presence_egalite == d_vrai) 4211: { 4212: liberation(s_etat_processus, 4213: s_objet_evalue); 4214: } 4215: 4216: (*s_etat_processus) 4217: .mode_execution_programme = 4218: registre_mode_execution_programme; 4219: (*s_etat_processus).instruction_courante = 4220: instruction_courante; 4221: return(d_absence_erreur); 4222: } 4223: 4224: if ((*(*l_element_courant).donnee).type == FCT) 4225: { 4226: (*s_etat_processus) 4227: .instruction_courante = 4228: (*((struct_fonction *) 4229: (*(*l_element_courant).donnee) 4230: .objet)).nom_fonction; 4231: fonction = (*((struct_fonction *) 4232: (*(*l_element_courant).donnee) 4233: .objet)).fonction; 4234: (*s_etat_processus).instruction_courante = 4235: instruction_courante; 4236: 4237: drapeau_then = TEST(instruction_then) 4238: ? d_vrai : d_faux; 4239: } 4240: 4241: l_element_courant = (*l_element_courant) 4242: .suivant; 4243: } while(drapeau_then == d_faux); 4244: 4245: (*s_etat_processus).expression_courante = 4246: l_registre_atome; 4247: 4248: (*(*s_etat_processus).l_base_pile_systeme) 4249: .clause = 'X'; 4250: instruction_then(s_etat_processus); 4251: 4252: (*s_etat_processus).exception = d_ep; 4253: (*s_etat_processus).erreur_execution = d_ex; 4254: } 4255: else if ((*s_etat_processus).mode_evaluation_expression 4256: == 'Y') 4257: { 4258: /* 4259: * Reprise sur erreur 4260: */ 4261: 4262: while(l_element_courant != NULL) 4263: { 4264: if ((*(*l_element_courant).donnee).type == FCT) 4265: { 4266: (*s_etat_processus).instruction_courante = 4267: (*((struct_fonction *) 4268: (*(*l_element_courant).donnee) 4269: .objet)).nom_fonction; 4270: fonction = (*((struct_fonction *) 4271: (*(*l_element_courant).donnee) 4272: .objet)).fonction; 4273: 4274: if (recherche_variable(s_etat_processus, 4275: (*s_etat_processus) 4276: .instruction_courante) == d_faux) 4277: { 4278: (*s_etat_processus).erreur_systeme 4279: = d_es; 4280: 4281: /* 4282: * Traitement de la pile système par les 4283: * différentes instructions. 4284: */ 4285: 4286: if (TEST(instruction_if) || 4287: TEST(instruction_iferr) || 4288: TEST(instruction_do) || 4289: TEST(instruction_while) || 4290: TEST(instruction_for) || 4291: TEST(instruction_forall) || 4292: TEST(instruction_start) || 4293: TEST(instruction_select) || 4294: TEST(instruction_case) || 4295: TEST(instruction_critical) || 4296: TEST(vers_niveau_superieur)) 4297: { 4298: if (TEST(vers_niveau_superieur)) 4299: { 4300: analyse(s_etat_processus, 4301: vers_niveau_superieur); 4302: 4303: if ((*s_etat_processus) 4304: .erreur_systeme != d_es) 4305: { 4306: if (presence_egalite == 4307: d_vrai) 4308: { 4309: liberation( 4310: s_etat_processus, 4311: s_objet_evalue); 4312: } 4313: 4314: (*s_etat_processus) 4315: .instruction_courante = 4316: instruction_courante; 4317: return(d_erreur); 4318: } 4319: } 4320: else if (TEST(instruction_for) || 4321: TEST(instruction_forall) || 4322: TEST(instruction_start)) 4323: { 4324: empilement_pile_systeme( 4325: s_etat_processus); 4326: 4327: if ((*s_etat_processus) 4328: .erreur_systeme != d_es) 4329: { 4330: if (presence_egalite == 4331: d_vrai) 4332: { 4333: liberation( 4334: s_etat_processus, 4335: s_objet_evalue); 4336: } 4337: 4338: (*s_etat_processus) 4339: .instruction_courante = 4340: instruction_courante; 4341: return(d_erreur); 4342: } 4343: 4344: (*(*s_etat_processus) 4345: .l_base_pile_systeme) 4346: .type_cloture = 'L'; 4347: } 4348: else 4349: { 4350: empilement_pile_systeme( 4351: s_etat_processus); 4352: 4353: if ((*s_etat_processus) 4354: .erreur_systeme != d_es) 4355: { 4356: if (presence_egalite == 4357: d_vrai) 4358: { 4359: liberation( 4360: s_etat_processus, 4361: s_objet_evalue); 4362: } 4363: 4364: (*s_etat_processus) 4365: .instruction_courante = 4366: instruction_courante; 4367: return(d_erreur); 4368: } 4369: } 4370: } 4371: else if (TEST(instruction_end) || 4372: TEST(instruction_next) || 4373: TEST(instruction_step) || 4374: TEST(vers_niveau_inferieur)) 4375: { 4376: if (TEST(vers_niveau_inferieur)) 4377: { 4378: analyse(s_etat_processus, 4379: vers_niveau_inferieur); 4380: 4381: if ((*s_etat_processus) 4382: .erreur_systeme != d_es) 4383: { 4384: if (presence_egalite == 4385: d_vrai) 4386: { 4387: liberation( 4388: s_etat_processus, 4389: s_objet_evalue); 4390: } 4391: 4392: (*s_etat_processus) 4393: .instruction_courante = 4394: instruction_courante; 4395: return(d_erreur); 4396: } 4397: } 4398: else if ((TEST(instruction_next) || 4399: TEST(instruction_step)) && 4400: ((*(*s_etat_processus) 4401: .l_base_pile_systeme) 4402: .type_cloture != 'L')) 4403: { 4404: /* 4405: * Libération des compteurs 4406: * de boucle 4407: */ 4408: 4409: presence_compteur = 4410: (((*(*s_etat_processus) 4411: .l_base_pile_systeme) 4412: .type_cloture == 'F') || 4413: ((*(*s_etat_processus) 4414: .l_base_pile_systeme) 4415: .type_cloture == 'A')) 4416: ? d_vrai : d_faux; 4417: 4418: if (((*(*s_etat_processus) 4419: .l_base_pile_systeme) 4420: .type_cloture != 'S') && 4421: (presence_compteur == 4422: d_faux)) 4423: { 4424: (*s_etat_processus) 4425: .erreur_execution = 4426: d_ex_erreur_traitement_boucle; 4427: 4428: if (presence_egalite == 4429: d_vrai) 4430: { 4431: liberation( 4432: s_etat_processus, 4433: s_objet_evalue); 4434: } 4435: 4436: (*s_etat_processus) 4437: .instruction_courante = 4438: instruction_courante; 4439: return(d_erreur); 4440: } 4441: 4442: if (presence_compteur == d_vrai) 4443: { 4444: if (recherche_variable( 4445: s_etat_processus, 4446: (*(*s_etat_processus) 4447: .l_base_pile_systeme) 4448: .nom_variable) == 4449: d_faux) 4450: { 4451: (*s_etat_processus) 4452: .erreur_systeme = d_es; 4453: (*s_etat_processus) 4454: .erreur_execution = 4455: d_ex_erreur_traitement_boucle; 4456: 4457: if (presence_egalite == 4458: d_vrai) 4459: { 4460: liberation( 4461: s_etat_processus, 4462: s_objet_evalue); 4463: } 4464: 4465: (*s_etat_processus) 4466: .instruction_courante = 4467: instruction_courante; 4468: return(d_erreur); 4469: } 4470: 4471: if ((*(*s_etat_processus) 4472: .pointeur_variable_courante) 4473: .objet == NULL) 4474: { 4475: (*s_etat_processus) 4476: .erreur_systeme = d_es; 4477: (*s_etat_processus) 4478: .erreur_execution = 4479: d_ex_variable_partagee; 4480: 4481: if (presence_egalite == 4482: d_vrai) 4483: { 4484: liberation( 4485: s_etat_processus, 4486: s_objet_evalue); 4487: } 4488: 4489: (*s_etat_processus) 4490: .instruction_courante = 4491: instruction_courante; 4492: return(d_erreur); 4493: } 4494: 4495: (*s_etat_processus) 4496: .niveau_courant--; 4497: 4498: if ( 4499: retrait_variables_par_niveau( 4500: s_etat_processus) == d_erreur) 4501: { 4502: if (presence_egalite == 4503: d_vrai) 4504: { 4505: liberation( 4506: s_etat_processus, 4507: s_objet_evalue); 4508: } 4509: 4510: (*s_etat_processus) 4511: .instruction_courante = 4512: instruction_courante; 4513: return(d_erreur); 4514: } 4515: } 4516: 4517: depilement_pile_systeme( 4518: s_etat_processus); 4519: } 4520: else 4521: { 4522: // Traitement spécifique pour la 4523: // fin d'une section critique 4524: 4525: if ((*s_etat_processus) 4526: .l_base_pile_systeme == 4527: NULL) 4528: { 4529: (*s_etat_processus) 4530: .erreur_systeme = 4531: d_es_end_incoherent; 4532: 4533: if (presence_egalite == 4534: d_vrai) 4535: { 4536: liberation( 4537: s_etat_processus, 4538: s_objet_evalue); 4539: } 4540: 4541: (*s_etat_processus) 4542: .instruction_courante = 4543: instruction_courante; 4544: return(d_erreur); 4545: } 4546: 4547: if ((*(*s_etat_processus) 4548: .l_base_pile_systeme) 4549: .type_cloture == 'Q') 4550: { 4551: if (pthread_mutex_unlock( 4552: &mutex_sections_critiques) 4553: != 0) 4554: { 4555: (*s_etat_processus) 4556: .erreur_systeme = 4557: d_es_processus; 4558: 4559: if (presence_egalite == 4560: d_vrai) 4561: { 4562: liberation( 4563: s_etat_processus, 4564: s_objet_evalue); 4565: } 4566: 4567: (*s_etat_processus) 4568: .instruction_courante = 4569: instruction_courante; 4570: return(d_erreur); 4571: } 4572: 4573: (*s_etat_processus) 4574: .sections_critiques--; 4575: } 4576: 4577: depilement_pile_systeme( 4578: s_etat_processus); 4579: 4580: if ((*s_etat_processus) 4581: .erreur_systeme != d_es) 4582: { 4583: if (presence_egalite == 4584: d_vrai) 4585: { 4586: liberation( 4587: s_etat_processus, 4588: s_objet_evalue); 4589: } 4590: 4591: (*s_etat_processus) 4592: .instruction_courante = 4593: instruction_courante; 4594: return(d_erreur); 4595: } 4596: } 4597: } 4598: } 4599: } 4600: 4601: l_element_courant = 4602: (*l_element_courant).suivant; 4603: } 4604: 4605: (*s_etat_processus).mode_execution_programme = 4606: registre_mode_execution_programme; 4607: (*s_etat_processus).instruction_courante = 4608: instruction_courante; 4609: 4610: (*s_etat_processus).exception = d_ep; 4611: (*s_etat_processus).erreur_execution = d_ex; 4612: 4613: erreur_evaluation = d_erreur; 4614: } 4615: else 4616: { 4617: // On ne détruit pas les variables pour les inclure 4618: // dans le fichier rpl-core. 4619: 4620: (*s_etat_processus).gel_liste_variables = d_vrai; 4621: 4622: registre_erreur_execution = 4623: (*s_etat_processus).erreur_execution; 4624: registre_exception = 4625: (*s_etat_processus).exception; 4626: registre_erreur_systeme = 4627: (*s_etat_processus).erreur_systeme; 4628: 4629: (*s_etat_processus).s_objet_errone = s_objet; 4630: (*s_etat_processus).s_objet_erreur = 4631: (*l_element_courant).donnee; 4632: 4633: l_element_courant = (*l_element_courant).suivant; 4634: 4635: while(l_element_courant != NULL) 4636: { 4637: if ((*(*l_element_courant).donnee).type == FCT) 4638: { 4639: (*s_etat_processus).instruction_courante = 4640: (*((struct_fonction *) 4641: (*(*l_element_courant).donnee) 4642: .objet)).nom_fonction; 4643: fonction = (*((struct_fonction *) 4644: (*(*l_element_courant).donnee) 4645: .objet)).fonction; 4646: 4647: if (recherche_variable(s_etat_processus, 4648: (*s_etat_processus) 4649: .instruction_courante) == d_faux) 4650: { 4651: (*s_etat_processus).erreur_systeme 4652: = d_es; 4653: 4654: /* 4655: * Traitement de la pile système par les 4656: * différentes instructions. 4657: */ 4658: 4659: if (TEST(instruction_if) || 4660: TEST(instruction_iferr) || 4661: TEST(instruction_do) || 4662: TEST(instruction_while) || 4663: TEST(instruction_for) || 4664: TEST(instruction_forall) || 4665: TEST(instruction_start) || 4666: TEST(instruction_select) || 4667: TEST(instruction_case) || 4668: TEST(instruction_critical) || 4669: TEST(vers_niveau_superieur)) 4670: { 4671: if (TEST(vers_niveau_superieur)) 4672: { 4673: analyse(s_etat_processus, 4674: vers_niveau_superieur); 4675: 4676: if ((*s_etat_processus) 4677: .erreur_systeme != d_es) 4678: { 4679: if (presence_egalite == 4680: d_vrai) 4681: { 4682: liberation( 4683: s_etat_processus, 4684: s_objet_evalue); 4685: } 4686: 4687: (*s_etat_processus) 4688: .instruction_courante = 4689: instruction_courante; 4690: return(d_erreur); 4691: } 4692: } 4693: else if (TEST(instruction_for) || 4694: TEST(instruction_forall) || 4695: TEST(instruction_start)) 4696: { 4697: empilement_pile_systeme( 4698: s_etat_processus); 4699: 4700: if ((*s_etat_processus) 4701: .erreur_systeme != d_es) 4702: { 4703: if (presence_egalite == 4704: d_vrai) 4705: { 4706: liberation( 4707: s_etat_processus, 4708: s_objet_evalue); 4709: } 4710: 4711: (*s_etat_processus) 4712: .instruction_courante = 4713: instruction_courante; 4714: return(d_erreur); 4715: } 4716: 4717: (*(*s_etat_processus) 4718: .l_base_pile_systeme) 4719: .type_cloture = 'L'; 4720: } 4721: else 4722: { 4723: empilement_pile_systeme( 4724: s_etat_processus); 4725: 4726: if ((*s_etat_processus) 4727: .erreur_systeme != d_es) 4728: { 4729: if (presence_egalite == 4730: d_vrai) 4731: { 4732: liberation( 4733: s_etat_processus, 4734: s_objet_evalue); 4735: } 4736: 4737: (*s_etat_processus) 4738: .instruction_courante = 4739: instruction_courante; 4740: return(d_erreur); 4741: } 4742: } 4743: } 4744: else if (TEST(instruction_end) || 4745: TEST(instruction_next) || 4746: TEST(instruction_step) || 4747: TEST(vers_niveau_inferieur)) 4748: { 4749: if (TEST(vers_niveau_inferieur)) 4750: { 4751: analyse(s_etat_processus, 4752: vers_niveau_inferieur); 4753: 4754: if ((*s_etat_processus) 4755: .erreur_systeme != d_es) 4756: { 4757: if (presence_egalite == 4758: d_vrai) 4759: { 4760: liberation( 4761: s_etat_processus, 4762: s_objet_evalue); 4763: } 4764: 4765: (*s_etat_processus) 4766: .instruction_courante = 4767: instruction_courante; 4768: return(d_erreur); 4769: } 4770: } 4771: else if ((TEST(instruction_next) || 4772: TEST(instruction_step)) && 4773: ((*(*s_etat_processus) 4774: .l_base_pile_systeme) 4775: .type_cloture != 'L')) 4776: { 4777: /* 4778: * Libération des compteurs 4779: * de boucle 4780: */ 4781: 4782: presence_compteur = 4783: (((*(*s_etat_processus) 4784: .l_base_pile_systeme) 4785: .type_cloture == 'F') || 4786: ((*(*s_etat_processus) 4787: .l_base_pile_systeme) 4788: .type_cloture == 'A')) 4789: ? d_vrai : d_faux; 4790: 4791: if (((*(*s_etat_processus) 4792: .l_base_pile_systeme) 4793: .type_cloture != 'S') && 4794: (presence_compteur == 4795: d_faux)) 4796: { 4797: (*s_etat_processus) 4798: .erreur_execution = 4799: d_ex_erreur_traitement_boucle; 4800: 4801: if (presence_egalite == 4802: d_vrai) 4803: { 4804: liberation( 4805: s_etat_processus, 4806: s_objet_evalue); 4807: } 4808: 4809: (*s_etat_processus) 4810: .instruction_courante = 4811: instruction_courante; 4812: return(d_erreur); 4813: } 4814: 4815: if (presence_compteur == d_vrai) 4816: { 4817: if (recherche_variable( 4818: s_etat_processus, 4819: (*(*s_etat_processus) 4820: .l_base_pile_systeme) 4821: .nom_variable) == 4822: d_faux) 4823: { 4824: (*s_etat_processus) 4825: .erreur_systeme = d_es; 4826: (*s_etat_processus) 4827: .erreur_execution = 4828: d_ex_erreur_traitement_boucle; 4829: 4830: if (presence_egalite == 4831: d_vrai) 4832: { 4833: liberation( 4834: s_etat_processus, 4835: s_objet_evalue); 4836: } 4837: 4838: (*s_etat_processus) 4839: .instruction_courante = 4840: instruction_courante; 4841: return(d_erreur); 4842: } 4843: 4844: if ((*(*s_etat_processus) 4845: .pointeur_variable_courante) 4846: .objet == NULL) 4847: { 4848: (*s_etat_processus) 4849: .erreur_systeme = d_es; 4850: (*s_etat_processus) 4851: .erreur_execution = 4852: d_ex_variable_partagee; 4853: 4854: if (presence_egalite == 4855: d_vrai) 4856: { 4857: liberation( 4858: s_etat_processus, 4859: s_objet_evalue); 4860: } 4861: 4862: (*s_etat_processus) 4863: .instruction_courante = 4864: instruction_courante; 4865: return(d_erreur); 4866: } 4867: 4868: (*s_etat_processus) 4869: .niveau_courant--; 4870: 4871: if ( 4872: retrait_variables_par_niveau( 4873: s_etat_processus) == d_erreur) 4874: { 4875: if (presence_egalite == 4876: d_vrai) 4877: { 4878: liberation( 4879: s_etat_processus, 4880: s_objet_evalue); 4881: } 4882: 4883: (*s_etat_processus) 4884: .instruction_courante = 4885: instruction_courante; 4886: return(d_erreur); 4887: } 4888: } 4889: 4890: depilement_pile_systeme( 4891: s_etat_processus); 4892: } 4893: else 4894: { 4895: // Traitement spécifique pour la 4896: // fin d'une section critique 4897: 4898: if ((*s_etat_processus) 4899: .l_base_pile_systeme == 4900: NULL) 4901: { 4902: (*s_etat_processus) 4903: .erreur_systeme = 4904: d_es_end_incoherent; 4905: 4906: if (presence_egalite == 4907: d_vrai) 4908: { 4909: liberation( 4910: s_etat_processus, 4911: s_objet_evalue); 4912: } 4913: 4914: (*s_etat_processus) 4915: .instruction_courante = 4916: instruction_courante; 4917: return(d_erreur); 4918: } 4919: 4920: if ((*(*s_etat_processus) 4921: .l_base_pile_systeme) 4922: .type_cloture == 'Q') 4923: { 4924: if (pthread_mutex_unlock( 4925: &mutex_sections_critiques) 4926: != 0) 4927: { 4928: (*s_etat_processus) 4929: .erreur_systeme = 4930: d_es_processus; 4931: 4932: if (presence_egalite == 4933: d_vrai) 4934: { 4935: liberation( 4936: s_etat_processus, 4937: s_objet_evalue); 4938: } 4939: 4940: (*s_etat_processus) 4941: .instruction_courante = 4942: instruction_courante; 4943: return(d_erreur); 4944: } 4945: 4946: (*s_etat_processus) 4947: .sections_critiques--; 4948: } 4949: 4950: depilement_pile_systeme( 4951: s_etat_processus); 4952: 4953: if ((*s_etat_processus) 4954: .erreur_systeme != d_es) 4955: { 4956: if (presence_egalite == 4957: d_vrai) 4958: { 4959: liberation( 4960: s_etat_processus, 4961: s_objet_evalue); 4962: } 4963: 4964: (*s_etat_processus) 4965: .instruction_courante = 4966: instruction_courante; 4967: return(d_erreur); 4968: } 4969: } 4970: } 4971: } 4972: } 4973: 4974: l_element_courant = 4975: (*l_element_courant).suivant; 4976: } 4977: 4978: (*s_etat_processus).mode_execution_programme = 4979: registre_mode_execution_programme; 4980: (*s_etat_processus).instruction_courante = 4981: instruction_courante; 4982: 4983: if (presence_egalite == d_vrai) 4984: { 4985: liberation(s_etat_processus, s_objet_evalue); 4986: } 4987: 4988: if ((*s_etat_processus) 4989: .var_volatile_processus_pere == 0) 4990: { 4991: envoi_signal_processus((*s_etat_processus) 4992: .pid_processus_pere, rpl_sigalrm); 4993: } 4994: else 4995: { 4996: (*s_etat_processus).var_volatile_alarme = -1; 4997: } 4998: 4999: (*s_etat_processus).erreur_execution = 5000: registre_erreur_execution; 5001: (*s_etat_processus).erreur_systeme = 5002: registre_erreur_systeme; 5003: (*s_etat_processus).exception = 5004: registre_exception; 5005: return(d_erreur); 5006: } 5007: } 5008: 5009: if ((*s_etat_processus).erreur_systeme != d_es) 5010: { 5011: if (presence_egalite == d_vrai) 5012: { 5013: liberation(s_etat_processus, s_objet_evalue); 5014: } 5015: 5016: if ((*s_etat_processus).var_volatile_processus_pere 5017: == 0) 5018: { 5019: envoi_signal_processus((*s_etat_processus) 5020: .pid_processus_pere, rpl_sigalrm); 5021: } 5022: else 5023: { 5024: (*s_etat_processus).var_volatile_alarme = -1; 5025: } 5026: 5027: (*s_etat_processus).instruction_courante = 5028: instruction_courante; 5029: return(d_erreur); 5030: } 5031: else if (((*s_etat_processus).erreur_execution != d_ex) || 5032: ((*s_etat_processus).exception != d_ep)) 5033: { 5034: if ((*s_etat_processus).arret_si_exception == d_faux) 5035: { 5036: /* 5037: * Reprise sur erreur 5038: */ 5039: 5040: if ((message = messages(s_etat_processus)) == NULL) 5041: { 5042: if (presence_egalite == d_vrai) 5043: { 5044: liberation(s_etat_processus, 5045: s_objet_evalue); 5046: } 5047: 5048: (*s_etat_processus).instruction_courante = 5049: instruction_courante; 5050: return(d_erreur); 5051: } 5052: 5053: free(message); 5054: 5055: while((*(*s_etat_processus).l_base_pile_systeme) 5056: .clause != 'R') 5057: { 5058: l_registre_atome = l_element_courant; 5059: l_element_courant = 5060: (*l_element_courant).suivant; 5061: 5062: if (l_element_courant == NULL) 5063: { 5064: /* 5065: * La fin de l'expression est atteinte, 5066: * le sequenceur reprend la main. 5067: */ 5068: 5069: if (presence_egalite == d_vrai) 5070: { 5071: liberation(s_etat_processus, 5072: s_objet_evalue); 5073: } 5074: 5075: (*s_etat_processus) 5076: .mode_execution_programme = 5077: registre_mode_execution_programme; 5078: return(d_absence_erreur); 5079: } 5080: 5081: if ((*(*l_element_courant).donnee).type == FCT) 5082: { 5083: (*s_etat_processus).instruction_courante = 5084: (*((struct_fonction *) 5085: (*(*l_element_courant).donnee) 5086: .objet)).nom_fonction; 5087: 5088: if (recherche_variable(s_etat_processus, 5089: (*s_etat_processus) 5090: .instruction_courante) == d_faux) 5091: { 5092: (*s_etat_processus).erreur_systeme 5093: = d_es; 5094: fonction = (*((struct_fonction *) 5095: (*(*l_element_courant).donnee) 5096: .objet)).fonction; 5097: 5098: /* 5099: * Traitement de la pile système par les 5100: * différentes instructions. 5101: */ 5102: 5103: if (TEST(instruction_if) || 5104: TEST(instruction_iferr) || 5105: TEST(instruction_do) || 5106: TEST(instruction_while) || 5107: TEST(instruction_for) || 5108: TEST(instruction_forall) || 5109: TEST(instruction_start) || 5110: TEST(instruction_select) || 5111: TEST(instruction_case) || 5112: TEST(instruction_critical) || 5113: TEST(vers_niveau_superieur)) 5114: { 5115: if (TEST(vers_niveau_superieur)) 5116: { 5117: registre_exception = 5118: (*s_etat_processus) 5119: .exception; 5120: registre_erreur_execution = 5121: (*s_etat_processus) 5122: .erreur_execution; 5123: 5124: analyse(s_etat_processus, 5125: vers_niveau_superieur); 5126: 5127: if ((*s_etat_processus) 5128: .erreur_systeme != d_es) 5129: { 5130: if (presence_egalite == 5131: d_vrai) 5132: { 5133: liberation( 5134: s_etat_processus, 5135: s_objet_evalue); 5136: } 5137: 5138: (*s_etat_processus) 5139: .instruction_courante = 5140: instruction_courante; 5141: return(d_erreur); 5142: } 5143: 5144: (*s_etat_processus).exception 5145: = registre_exception; 5146: (*s_etat_processus) 5147: .erreur_execution = 5148: registre_erreur_execution; 5149: } 5150: else if (TEST(instruction_for) || 5151: TEST(instruction_forall) || 5152: TEST(instruction_start)) 5153: { 5154: empilement_pile_systeme( 5155: s_etat_processus); 5156: 5157: if ((*s_etat_processus) 5158: .erreur_systeme != d_es) 5159: { 5160: if (presence_egalite == 5161: d_vrai) 5162: { 5163: liberation( 5164: s_etat_processus, 5165: s_objet_evalue); 5166: } 5167: 5168: (*s_etat_processus) 5169: .instruction_courante = 5170: instruction_courante; 5171: return(d_erreur); 5172: } 5173: 5174: (*(*s_etat_processus) 5175: .l_base_pile_systeme) 5176: .type_cloture = 'L'; 5177: } 5178: else 5179: { 5180: empilement_pile_systeme( 5181: s_etat_processus); 5182: 5183: if ((*s_etat_processus) 5184: .erreur_systeme != d_es) 5185: { 5186: if (presence_egalite == 5187: d_vrai) 5188: { 5189: liberation( 5190: s_etat_processus, 5191: s_objet_evalue); 5192: } 5193: 5194: (*s_etat_processus) 5195: .instruction_courante = 5196: instruction_courante; 5197: return(d_erreur); 5198: } 5199: } 5200: } 5201: else if (TEST(instruction_end) || 5202: TEST(instruction_next) || 5203: TEST(instruction_step) || 5204: TEST(vers_niveau_inferieur)) 5205: { 5206: if (TEST(vers_niveau_inferieur)) 5207: { 5208: registre_exception = 5209: (*s_etat_processus) 5210: .exception; 5211: registre_erreur_execution = 5212: (*s_etat_processus) 5213: .erreur_execution; 5214: 5215: analyse(s_etat_processus, 5216: vers_niveau_inferieur); 5217: 5218: if ((*s_etat_processus) 5219: .erreur_systeme != d_es) 5220: { 5221: if (presence_egalite == 5222: d_vrai) 5223: { 5224: liberation( 5225: s_etat_processus, 5226: s_objet_evalue); 5227: } 5228: 5229: (*s_etat_processus) 5230: .instruction_courante = 5231: instruction_courante; 5232: return(d_erreur); 5233: } 5234: 5235: (*s_etat_processus).exception 5236: = registre_exception; 5237: (*s_etat_processus) 5238: .erreur_execution = 5239: registre_erreur_execution; 5240: } 5241: else if ((TEST(instruction_next) || 5242: TEST(instruction_step)) && 5243: ((*(*s_etat_processus) 5244: .l_base_pile_systeme) 5245: .type_cloture != 'L')) 5246: { 5247: /* 5248: * Libération des compteurs 5249: * de boucle 5250: */ 5251: 5252: presence_compteur = 5253: (((*(*s_etat_processus) 5254: .l_base_pile_systeme) 5255: .type_cloture == 'F') || 5256: ((*(*s_etat_processus) 5257: .l_base_pile_systeme) 5258: .type_cloture == 'A')) 5259: ? d_vrai : d_faux; 5260: 5261: if (((*(*s_etat_processus) 5262: .l_base_pile_systeme) 5263: .type_cloture != 'S') && 5264: (presence_compteur == 5265: d_faux)) 5266: { 5267: (*s_etat_processus) 5268: .erreur_execution = 5269: d_ex_erreur_traitement_boucle; 5270: 5271: if (presence_egalite == 5272: d_vrai) 5273: { 5274: liberation( 5275: s_etat_processus, 5276: s_objet_evalue); 5277: } 5278: 5279: (*s_etat_processus) 5280: .instruction_courante = 5281: instruction_courante; 5282: return(d_erreur); 5283: } 5284: 5285: if (presence_compteur == d_vrai) 5286: { 5287: if (recherche_variable( 5288: s_etat_processus, 5289: (*(*s_etat_processus) 5290: .l_base_pile_systeme) 5291: .nom_variable) == 5292: d_faux) 5293: { 5294: (*s_etat_processus) 5295: .erreur_systeme = d_es; 5296: (*s_etat_processus) 5297: .erreur_execution = 5298: d_ex_erreur_traitement_boucle; 5299: 5300: if (presence_egalite == 5301: d_vrai) 5302: { 5303: liberation( 5304: s_etat_processus, 5305: s_objet_evalue); 5306: } 5307: 5308: (*s_etat_processus) 5309: .instruction_courante = 5310: instruction_courante; 5311: return(d_erreur); 5312: } 5313: 5314: if ((*(*s_etat_processus) 5315: .pointeur_variable_courante) 5316: .objet == NULL) 5317: { 5318: (*s_etat_processus) 5319: .erreur_systeme = d_es; 5320: (*s_etat_processus) 5321: .erreur_execution = 5322: d_ex_variable_partagee; 5323: 5324: if (presence_egalite == 5325: d_vrai) 5326: { 5327: liberation( 5328: s_etat_processus, 5329: s_objet_evalue); 5330: } 5331: 5332: (*s_etat_processus) 5333: .instruction_courante = 5334: instruction_courante; 5335: return(d_erreur); 5336: } 5337: 5338: (*s_etat_processus) 5339: .niveau_courant--; 5340: 5341: if ( 5342: retrait_variables_par_niveau( 5343: s_etat_processus) == d_erreur) 5344: { 5345: if (presence_egalite == 5346: d_vrai) 5347: { 5348: liberation( 5349: s_etat_processus, 5350: s_objet_evalue); 5351: } 5352: 5353: (*s_etat_processus) 5354: .instruction_courante = 5355: instruction_courante; 5356: return(d_erreur); 5357: } 5358: } 5359: 5360: depilement_pile_systeme( 5361: s_etat_processus); 5362: } 5363: else 5364: { 5365: // Traitement spécifique pour la 5366: // fin d'une section critique 5367: 5368: if ((*s_etat_processus) 5369: .l_base_pile_systeme == 5370: NULL) 5371: { 5372: (*s_etat_processus) 5373: .erreur_systeme = 5374: d_es_end_incoherent; 5375: 5376: if (presence_egalite == 5377: d_vrai) 5378: { 5379: liberation( 5380: s_etat_processus, 5381: s_objet_evalue); 5382: } 5383: 5384: (*s_etat_processus) 5385: .instruction_courante = 5386: instruction_courante; 5387: return(d_erreur); 5388: } 5389: 5390: if ((*(*s_etat_processus) 5391: .l_base_pile_systeme) 5392: .type_cloture == 'Q') 5393: { 5394: if (pthread_mutex_unlock( 5395: &mutex_sections_critiques) 5396: != 0) 5397: { 5398: (*s_etat_processus) 5399: .erreur_systeme = 5400: d_es_processus; 5401: 5402: if (presence_egalite == 5403: d_vrai) 5404: { 5405: liberation( 5406: s_etat_processus, 5407: s_objet_evalue); 5408: } 5409: 5410: (*s_etat_processus) 5411: .instruction_courante = 5412: instruction_courante; 5413: return(d_erreur); 5414: } 5415: 5416: (*s_etat_processus) 5417: .sections_critiques--; 5418: } 5419: 5420: depilement_pile_systeme( 5421: s_etat_processus); 5422: 5423: if ((*s_etat_processus) 5424: .erreur_systeme != d_es) 5425: { 5426: if (presence_egalite == 5427: d_vrai) 5428: { 5429: liberation( 5430: s_etat_processus, 5431: s_objet_evalue); 5432: } 5433: 5434: (*s_etat_processus) 5435: .instruction_courante = 5436: instruction_courante; 5437: return(d_erreur); 5438: } 5439: } 5440: } 5441: } 5442: } 5443: } 5444: 5445: (*s_etat_processus).instruction_courante = 5446: instruction_courante; 5447: drapeau_then = d_faux; 5448: 5449: do 5450: { 5451: l_registre_atome = l_element_courant; 5452: 5453: if (l_element_courant == NULL) 5454: { 5455: /* 5456: * La fin de l'expression est atteinte, 5457: * le séquenceur reprend la main. 5458: */ 5459: 5460: if (presence_egalite == d_vrai) 5461: { 5462: liberation(s_etat_processus, 5463: s_objet_evalue); 5464: } 5465: 5466: (*s_etat_processus) 5467: .mode_execution_programme = 5468: registre_mode_execution_programme; 5469: (*s_etat_processus).instruction_courante = 5470: instruction_courante; 5471: return(d_absence_erreur); 5472: } 5473: 5474: if ((*(*l_element_courant).donnee).type == FCT) 5475: { 5476: (*s_etat_processus) 5477: .instruction_courante = 5478: (*((struct_fonction *) 5479: (*(*l_element_courant).donnee) 5480: .objet)).nom_fonction; 5481: fonction = (*((struct_fonction *) 5482: (*(*l_element_courant).donnee) 5483: .objet)).fonction; 5484: (*s_etat_processus).instruction_courante = 5485: instruction_courante; 5486: 5487: drapeau_then = TEST(instruction_then) 5488: ? d_vrai : d_faux; 5489: } 5490: 5491: l_element_courant = (*l_element_courant) 5492: .suivant; 5493: } while(drapeau_then == d_faux); 5494: 5495: (*s_etat_processus).expression_courante = 5496: l_registre_atome; 5497: 5498: (*(*s_etat_processus).l_base_pile_systeme) 5499: .clause = 'X'; 5500: instruction_then(s_etat_processus); 5501: 5502: (*s_etat_processus).exception = d_ep; 5503: (*s_etat_processus).erreur_execution = d_ex; 5504: } 5505: else if ((*s_etat_processus).mode_evaluation_expression 5506: == 'Y') 5507: { 5508: /* 5509: * Reprise sur erreur 5510: */ 5511: 5512: while(l_element_courant != NULL) 5513: { 5514: if ((*(*l_element_courant).donnee).type == FCT) 5515: { 5516: (*s_etat_processus).instruction_courante = 5517: (*((struct_fonction *) 5518: (*(*l_element_courant).donnee) 5519: .objet)).nom_fonction; 5520: fonction = (*((struct_fonction *) 5521: (*(*l_element_courant).donnee) 5522: .objet)).fonction; 5523: 5524: if (recherche_variable(s_etat_processus, 5525: (*s_etat_processus) 5526: .instruction_courante) == d_faux) 5527: { 5528: (*s_etat_processus).erreur_systeme 5529: = d_es; 5530: 5531: /* 5532: * Traitement de la pile système par les 5533: * différentes instructions. 5534: */ 5535: 5536: if (TEST(instruction_if) || 5537: TEST(instruction_iferr) || 5538: TEST(instruction_do) || 5539: TEST(instruction_while) || 5540: TEST(instruction_for) || 5541: TEST(instruction_forall) || 5542: TEST(instruction_start) || 5543: TEST(instruction_select) || 5544: TEST(instruction_case) || 5545: TEST(instruction_critical) || 5546: TEST(vers_niveau_superieur)) 5547: { 5548: if (TEST(vers_niveau_superieur)) 5549: { 5550: analyse(s_etat_processus, 5551: vers_niveau_superieur); 5552: 5553: if ((*s_etat_processus) 5554: .erreur_systeme != d_es) 5555: { 5556: if (presence_egalite == 5557: d_vrai) 5558: { 5559: liberation( 5560: s_etat_processus, 5561: s_objet_evalue); 5562: } 5563: 5564: (*s_etat_processus) 5565: .instruction_courante = 5566: instruction_courante; 5567: return(d_erreur); 5568: } 5569: } 5570: else if (TEST(instruction_for) || 5571: TEST(instruction_forall) || 5572: TEST(instruction_start)) 5573: { 5574: empilement_pile_systeme( 5575: s_etat_processus); 5576: 5577: if ((*s_etat_processus) 5578: .erreur_systeme != d_es) 5579: { 5580: if (presence_egalite == 5581: d_vrai) 5582: { 5583: liberation( 5584: s_etat_processus, 5585: s_objet_evalue); 5586: } 5587: 5588: (*s_etat_processus) 5589: .instruction_courante = 5590: instruction_courante; 5591: return(d_erreur); 5592: } 5593: 5594: (*(*s_etat_processus) 5595: .l_base_pile_systeme) 5596: .type_cloture = 'L'; 5597: } 5598: else 5599: { 5600: empilement_pile_systeme( 5601: s_etat_processus); 5602: 5603: if ((*s_etat_processus) 5604: .erreur_systeme != d_es) 5605: { 5606: if (presence_egalite == 5607: d_vrai) 5608: { 5609: liberation( 5610: s_etat_processus, 5611: s_objet_evalue); 5612: } 5613: 5614: (*s_etat_processus) 5615: .instruction_courante = 5616: instruction_courante; 5617: return(d_erreur); 5618: } 5619: } 5620: } 5621: else if (TEST(instruction_end) || 5622: TEST(instruction_next) || 5623: TEST(instruction_step) || 5624: TEST(vers_niveau_inferieur)) 5625: { 5626: if (TEST(vers_niveau_inferieur)) 5627: { 5628: analyse(s_etat_processus, 5629: vers_niveau_inferieur); 5630: 5631: if ((*s_etat_processus) 5632: .erreur_systeme != d_es) 5633: { 5634: if (presence_egalite == 5635: d_vrai) 5636: { 5637: liberation( 5638: s_etat_processus, 5639: s_objet_evalue); 5640: } 5641: 5642: (*s_etat_processus) 5643: .instruction_courante = 5644: instruction_courante; 5645: return(d_erreur); 5646: } 5647: } 5648: else if ((TEST(instruction_next) || 5649: TEST(instruction_step)) && 5650: ((*(*s_etat_processus) 5651: .l_base_pile_systeme) 5652: .type_cloture != 'L')) 5653: { 5654: /* 5655: * Libération des compteurs 5656: * de boucle 5657: */ 5658: 5659: presence_compteur = 5660: (((*(*s_etat_processus) 5661: .l_base_pile_systeme) 5662: .type_cloture == 'F') || 5663: ((*(*s_etat_processus) 5664: .l_base_pile_systeme) 5665: .type_cloture == 'A')) 5666: ? d_vrai : d_faux; 5667: 5668: if (((*(*s_etat_processus) 5669: .l_base_pile_systeme) 5670: .type_cloture != 'S') && 5671: (presence_compteur == 5672: d_faux)) 5673: { 5674: (*s_etat_processus) 5675: .erreur_execution = 5676: d_ex_erreur_traitement_boucle; 5677: 5678: if (presence_egalite == 5679: d_vrai) 5680: { 5681: liberation( 5682: s_etat_processus, 5683: s_objet_evalue); 5684: } 5685: 5686: (*s_etat_processus) 5687: .instruction_courante = 5688: instruction_courante; 5689: return(d_erreur); 5690: } 5691: 5692: if (presence_compteur == d_vrai) 5693: { 5694: if (recherche_variable( 5695: s_etat_processus, 5696: (*(*s_etat_processus) 5697: .l_base_pile_systeme) 5698: .nom_variable) == 5699: d_faux) 5700: { 5701: (*s_etat_processus) 5702: .erreur_systeme = d_es; 5703: (*s_etat_processus) 5704: .erreur_execution = 5705: d_ex_erreur_traitement_boucle; 5706: 5707: if (presence_egalite == 5708: d_vrai) 5709: { 5710: liberation( 5711: s_etat_processus, 5712: s_objet_evalue); 5713: } 5714: 5715: (*s_etat_processus) 5716: .instruction_courante = 5717: instruction_courante; 5718: return(d_erreur); 5719: } 5720: 5721: if ((*(*s_etat_processus) 5722: .pointeur_variable_courante) 5723: .objet == NULL) 5724: { 5725: (*s_etat_processus) 5726: .erreur_systeme = d_es; 5727: (*s_etat_processus) 5728: .erreur_execution = 5729: d_ex_variable_partagee; 5730: 5731: if (presence_egalite == 5732: d_vrai) 5733: { 5734: liberation( 5735: s_etat_processus, 5736: s_objet_evalue); 5737: } 5738: 5739: (*s_etat_processus) 5740: .instruction_courante = 5741: instruction_courante; 5742: return(d_erreur); 5743: } 5744: 5745: (*s_etat_processus) 5746: .niveau_courant--; 5747: 5748: if ( 5749: retrait_variables_par_niveau( 5750: s_etat_processus) == d_erreur) 5751: { 5752: if (presence_egalite == 5753: d_vrai) 5754: { 5755: liberation( 5756: s_etat_processus, 5757: s_objet_evalue); 5758: } 5759: 5760: (*s_etat_processus) 5761: .instruction_courante = 5762: instruction_courante; 5763: return(d_erreur); 5764: } 5765: } 5766: 5767: depilement_pile_systeme( 5768: s_etat_processus); 5769: } 5770: else 5771: { 5772: // Traitement spécifique pour la 5773: // fin d'une section critique 5774: 5775: if ((*s_etat_processus) 5776: .l_base_pile_systeme == 5777: NULL) 5778: { 5779: (*s_etat_processus) 5780: .erreur_systeme = 5781: d_es_end_incoherent; 5782: 5783: if (presence_egalite == 5784: d_vrai) 5785: { 5786: liberation( 5787: s_etat_processus, 5788: s_objet_evalue); 5789: } 5790: 5791: (*s_etat_processus) 5792: .instruction_courante = 5793: instruction_courante; 5794: return(d_erreur); 5795: } 5796: 5797: if ((*(*s_etat_processus) 5798: .l_base_pile_systeme) 5799: .type_cloture == 'Q') 5800: { 5801: if (pthread_mutex_unlock( 5802: &mutex_sections_critiques) 5803: != 0) 5804: { 5805: (*s_etat_processus) 5806: .erreur_systeme = 5807: d_es_processus; 5808: 5809: if (presence_egalite == 5810: d_vrai) 5811: { 5812: liberation( 5813: s_etat_processus, 5814: s_objet_evalue); 5815: } 5816: 5817: (*s_etat_processus) 5818: .instruction_courante = 5819: instruction_courante; 5820: return(d_erreur); 5821: } 5822: 5823: (*s_etat_processus) 5824: .sections_critiques--; 5825: } 5826: 5827: depilement_pile_systeme( 5828: s_etat_processus); 5829: 5830: if ((*s_etat_processus) 5831: .erreur_systeme != d_es) 5832: { 5833: if (presence_egalite == 5834: d_vrai) 5835: { 5836: liberation( 5837: s_etat_processus, 5838: s_objet_evalue); 5839: } 5840: 5841: (*s_etat_processus) 5842: .instruction_courante = 5843: instruction_courante; 5844: return(d_erreur); 5845: } 5846: } 5847: } 5848: } 5849: } 5850: 5851: l_element_courant = 5852: (*l_element_courant).suivant; 5853: } 5854: 5855: (*s_etat_processus).mode_execution_programme = 5856: registre_mode_execution_programme; 5857: (*s_etat_processus).instruction_courante = 5858: instruction_courante; 5859: 5860: (*s_etat_processus).exception = d_ep; 5861: (*s_etat_processus).erreur_execution = d_ex; 5862: 5863: erreur_evaluation = d_erreur; 5864: } 5865: else 5866: { 5867: // On ne détruit pas les variables pour les inclure 5868: // dans le fichier rpl-core. 5869: 5870: (*s_etat_processus).gel_liste_variables = d_vrai; 5871: 5872: registre_erreur_execution = 5873: (*s_etat_processus).erreur_execution; 5874: registre_exception = 5875: (*s_etat_processus).exception; 5876: registre_erreur_systeme = 5877: (*s_etat_processus).erreur_systeme; 5878: 5879: (*s_etat_processus).s_objet_errone = s_objet; 5880: (*s_etat_processus).s_objet_erreur = 5881: (*l_element_courant).donnee; 5882: 5883: l_element_courant = (*l_element_courant).suivant; 5884: 5885: while(l_element_courant != NULL) 5886: { 5887: if ((*(*l_element_courant).donnee).type == FCT) 5888: { 5889: (*s_etat_processus).instruction_courante = 5890: (*((struct_fonction *) 5891: (*(*l_element_courant).donnee) 5892: .objet)).nom_fonction; 5893: fonction = (*((struct_fonction *) 5894: (*(*l_element_courant).donnee) 5895: .objet)).fonction; 5896: 5897: if (recherche_variable(s_etat_processus, 5898: (*s_etat_processus) 5899: .instruction_courante) == d_faux) 5900: { 5901: (*s_etat_processus).erreur_systeme 5902: = d_es; 5903: 5904: /* 5905: * Traitement de la pile système par les 5906: * différentes instructions. 5907: */ 5908: 5909: if (TEST(instruction_if) || 5910: TEST(instruction_iferr) || 5911: TEST(instruction_do) || 5912: TEST(instruction_while) || 5913: TEST(instruction_for) || 5914: TEST(instruction_forall) || 5915: TEST(instruction_start) || 5916: TEST(instruction_select) || 5917: TEST(instruction_case) || 5918: TEST(instruction_critical) || 5919: TEST(vers_niveau_superieur)) 5920: { 5921: if (TEST(vers_niveau_superieur)) 5922: { 5923: analyse(s_etat_processus, 5924: vers_niveau_superieur); 5925: 5926: if ((*s_etat_processus) 5927: .erreur_systeme != d_es) 5928: { 5929: if (presence_egalite == 5930: d_vrai) 5931: { 5932: liberation( 5933: s_etat_processus, 5934: s_objet_evalue); 5935: } 5936: 5937: (*s_etat_processus) 5938: .instruction_courante = 5939: instruction_courante; 5940: return(d_erreur); 5941: } 5942: } 5943: else if (TEST(instruction_for) || 5944: TEST(instruction_forall) || 5945: TEST(instruction_start)) 5946: { 5947: empilement_pile_systeme( 5948: s_etat_processus); 5949: 5950: if ((*s_etat_processus) 5951: .erreur_systeme != d_es) 5952: { 5953: if (presence_egalite == 5954: d_vrai) 5955: { 5956: liberation( 5957: s_etat_processus, 5958: s_objet_evalue); 5959: } 5960: 5961: (*s_etat_processus) 5962: .instruction_courante = 5963: instruction_courante; 5964: return(d_erreur); 5965: } 5966: 5967: (*(*s_etat_processus) 5968: .l_base_pile_systeme) 5969: .type_cloture = 'L'; 5970: } 5971: else 5972: { 5973: empilement_pile_systeme( 5974: s_etat_processus); 5975: 5976: if ((*s_etat_processus) 5977: .erreur_systeme != d_es) 5978: { 5979: if (presence_egalite == 5980: d_vrai) 5981: { 5982: liberation( 5983: s_etat_processus, 5984: s_objet_evalue); 5985: } 5986: 5987: (*s_etat_processus) 5988: .instruction_courante = 5989: instruction_courante; 5990: return(d_erreur); 5991: } 5992: } 5993: } 5994: else if (TEST(instruction_end) || 5995: TEST(instruction_next) || 5996: TEST(instruction_step) || 5997: TEST(vers_niveau_inferieur)) 5998: { 5999: if (TEST(vers_niveau_inferieur)) 6000: { 6001: analyse(s_etat_processus, 6002: vers_niveau_inferieur); 6003: 6004: if ((*s_etat_processus) 6005: .erreur_systeme != d_es) 6006: { 6007: if (presence_egalite == 6008: d_vrai) 6009: { 6010: liberation( 6011: s_etat_processus, 6012: s_objet_evalue); 6013: } 6014: 6015: (*s_etat_processus) 6016: .instruction_courante = 6017: instruction_courante; 6018: return(d_erreur); 6019: } 6020: } 6021: else if ((TEST(instruction_next) || 6022: TEST(instruction_step)) && 6023: ((*(*s_etat_processus) 6024: .l_base_pile_systeme) 6025: .type_cloture != 'L')) 6026: { 6027: /* 6028: * Libération des compteurs 6029: * de boucle 6030: */ 6031: 6032: presence_compteur = 6033: (((*(*s_etat_processus) 6034: .l_base_pile_systeme) 6035: .type_cloture == 'F') || 6036: ((*(*s_etat_processus) 6037: .l_base_pile_systeme) 6038: .type_cloture == 'A')) 6039: ? d_vrai : d_faux; 6040: 6041: if (((*(*s_etat_processus) 6042: .l_base_pile_systeme) 6043: .type_cloture != 'S') && 6044: (presence_compteur == 6045: d_faux)) 6046: { 6047: (*s_etat_processus) 6048: .erreur_execution = 6049: d_ex_erreur_traitement_boucle; 6050: 6051: if (presence_egalite == 6052: d_vrai) 6053: { 6054: liberation( 6055: s_etat_processus, 6056: s_objet_evalue); 6057: } 6058: 6059: (*s_etat_processus) 6060: .instruction_courante = 6061: instruction_courante; 6062: return(d_erreur); 6063: } 6064: 6065: if (presence_compteur == d_vrai) 6066: { 6067: if (recherche_variable( 6068: s_etat_processus, 6069: (*(*s_etat_processus) 6070: .l_base_pile_systeme) 6071: .nom_variable) == 6072: d_faux) 6073: { 6074: (*s_etat_processus) 6075: .erreur_systeme = d_es; 6076: (*s_etat_processus) 6077: .erreur_execution = 6078: d_ex_erreur_traitement_boucle; 6079: 6080: if (presence_egalite == 6081: d_vrai) 6082: { 6083: liberation( 6084: s_etat_processus, 6085: s_objet_evalue); 6086: } 6087: 6088: (*s_etat_processus) 6089: .instruction_courante = 6090: instruction_courante; 6091: return(d_erreur); 6092: } 6093: 6094: if ((*(*s_etat_processus) 6095: .pointeur_variable_courante) 6096: .objet == NULL) 6097: { 6098: (*s_etat_processus) 6099: .erreur_systeme = d_es; 6100: (*s_etat_processus) 6101: .erreur_execution = 6102: d_ex_variable_partagee; 6103: 6104: if (presence_egalite == 6105: d_vrai) 6106: { 6107: liberation( 6108: s_etat_processus, 6109: s_objet_evalue); 6110: } 6111: 6112: (*s_etat_processus) 6113: .instruction_courante = 6114: instruction_courante; 6115: return(d_erreur); 6116: } 6117: 6118: (*s_etat_processus) 6119: .niveau_courant--; 6120: 6121: if ( 6122: retrait_variables_par_niveau( 6123: s_etat_processus) == d_erreur) 6124: { 6125: if (presence_egalite == 6126: d_vrai) 6127: { 6128: liberation( 6129: s_etat_processus, 6130: s_objet_evalue); 6131: } 6132: 6133: (*s_etat_processus) 6134: .instruction_courante = 6135: instruction_courante; 6136: return(d_erreur); 6137: } 6138: } 6139: 6140: depilement_pile_systeme( 6141: s_etat_processus); 6142: } 6143: else 6144: { 6145: // Traitement spécifique pour la 6146: // fin d'une section critique 6147: 6148: if ((*s_etat_processus) 6149: .l_base_pile_systeme == 6150: NULL) 6151: { 6152: (*s_etat_processus) 6153: .erreur_systeme = 6154: d_es_end_incoherent; 6155: 6156: if (presence_egalite == 6157: d_vrai) 6158: { 6159: liberation( 6160: s_etat_processus, 6161: s_objet_evalue); 6162: } 6163: 6164: (*s_etat_processus) 6165: .instruction_courante = 6166: instruction_courante; 6167: return(d_erreur); 6168: } 6169: 6170: if ((*(*s_etat_processus) 6171: .l_base_pile_systeme) 6172: .type_cloture == 'Q') 6173: { 6174: if (pthread_mutex_unlock( 6175: &mutex_sections_critiques) 6176: != 0) 6177: { 6178: (*s_etat_processus) 6179: .erreur_systeme = 6180: d_es_processus; 6181: 6182: if (presence_egalite == 6183: d_vrai) 6184: { 6185: liberation( 6186: s_etat_processus, 6187: s_objet_evalue); 6188: } 6189: 6190: (*s_etat_processus) 6191: .instruction_courante = 6192: instruction_courante; 6193: return(d_erreur); 6194: } 6195: 6196: (*s_etat_processus) 6197: .sections_critiques--; 6198: } 6199: 6200: depilement_pile_systeme( 6201: s_etat_processus); 6202: 6203: if ((*s_etat_processus) 6204: .erreur_systeme != d_es) 6205: { 6206: if (presence_egalite == 6207: d_vrai) 6208: { 6209: liberation( 6210: s_etat_processus, 6211: s_objet_evalue); 6212: } 6213: 6214: (*s_etat_processus) 6215: .instruction_courante = 6216: instruction_courante; 6217: return(d_erreur); 6218: } 6219: } 6220: } 6221: } 6222: } 6223: 6224: l_element_courant = 6225: (*l_element_courant).suivant; 6226: } 6227: 6228: (*s_etat_processus).mode_execution_programme = 6229: registre_mode_execution_programme; 6230: (*s_etat_processus).instruction_courante = 6231: instruction_courante; 6232: if (presence_egalite == d_vrai) 6233: { 6234: liberation(s_etat_processus, s_objet_evalue); 6235: } 6236: 6237: if ((*s_etat_processus) 6238: .var_volatile_processus_pere == 0) 6239: { 6240: envoi_signal_processus((*s_etat_processus) 6241: .pid_processus_pere, rpl_sigalrm); 6242: } 6243: else 6244: { 6245: (*s_etat_processus).var_volatile_alarme = -1; 6246: } 6247: 6248: (*s_etat_processus).erreur_execution = 6249: registre_erreur_execution; 6250: (*s_etat_processus).erreur_systeme = 6251: registre_erreur_systeme; 6252: (*s_etat_processus).exception = 6253: registre_exception; 6254: return(d_erreur); 6255: } 6256: } 6257: } 6258: else if ((*s_etat_processus).constante_symbolique == 'N') 6259: { 6260: if ((s_objet_elementaire = copie_objet(s_etat_processus, 6261: (*l_element_courant).donnee, 'P')) == NULL) 6262: { 6263: if (presence_egalite == d_vrai) 6264: { 6265: liberation(s_etat_processus, s_objet_evalue); 6266: } 6267: 6268: (*s_etat_processus).erreur_systeme = 6269: d_es_allocation_memoire; 6270: (*s_etat_processus).instruction_courante = 6271: instruction_courante; 6272: return(d_erreur); 6273: } 6274: 6275: presence_fonction = d_faux; 6276: presence_variable_partagee = d_faux; 6277: 6278: if (recherche_variable(s_etat_processus, (*((struct_nom *) 6279: (*s_objet_elementaire).objet)).nom) == d_faux) 6280: { 6281: (*s_etat_processus).erreur_systeme = d_es; 6282: presence_variable = d_faux; 6283: 6284: if ((*s_etat_processus).autorisation_nom_implicite 6285: == 'N') 6286: { 6287: if ((*((struct_nom *) (*s_objet_elementaire).objet)) 6288: .symbole == d_faux) 6289: { 6290: if (test_cfsf(s_etat_processus, 31) == d_vrai) 6291: { 6292: if (empilement_pile_last(s_etat_processus, 6293: 0) == d_erreur) 6294: { 6295: return(d_erreur); 6296: } 6297: } 6298: 6299: erreur_evaluation = d_erreur; 6300: (*s_etat_processus).erreur_execution = 6301: d_ex_nom_implicite; 6302: 6303: if (type_evaluation == 'I') 6304: { 6305: (*s_etat_processus) 6306: .derniere_erreur_evaluation = 6307: (*s_etat_processus) 6308: .erreur_execution; 6309: } 6310: } 6311: } 6312: } 6313: else 6314: { 6315: if ((*s_etat_processus).traitement_symbolique == 'N') 6316: { 6317: if ((*(*s_etat_processus) 6318: .pointeur_variable_courante).objet == NULL) 6319: { 6320: // Variable partagée 6321: 6322: presence_variable_partagee = d_faux; 6323: 6324: if (recherche_variable_partagee( 6325: s_etat_processus, (*(*s_etat_processus) 6326: .pointeur_variable_courante).nom, 6327: (*(*s_etat_processus) 6328: .pointeur_variable_courante) 6329: .variable_partagee, 'E') != NULL) 6330: { 6331: presence_variable = d_vrai; 6332: presence_variable_partagee = d_vrai; 6333: 6334: if ((*(*(*s_etat_processus) 6335: .pointeur_variable_partagee_courante 6336: ).objet).type == ADR) 6337: { 6338: presence_fonction = d_vrai; 6339: } 6340: 6341: if ((type_evaluation == 'N') || 6342: ((*((struct_nom *) 6343: (*(*l_element_courant).donnee) 6344: .objet)).symbole == d_faux)) 6345: { 6346: if ((s_copie_variable_partagee = 6347: copie_objet(s_etat_processus, 6348: (*(*s_etat_processus) 6349: .pointeur_variable_partagee_courante 6350: ).objet, 'P')) == NULL) 6351: { 6352: if (pthread_mutex_unlock( 6353: &((*(*s_etat_processus) 6354: .pointeur_variable_partagee_courante 6355: ).mutex)) != 0) 6356: { 6357: (*s_etat_processus) 6358: .erreur_systeme = 6359: d_es_processus; 6360: return(d_erreur); 6361: } 6362: } 6363: } 6364: else 6365: { 6366: s_copie_variable_partagee = NULL; 6367: } 6368: 6369: if (pthread_mutex_unlock( 6370: &((*(*s_etat_processus) 6371: .pointeur_variable_partagee_courante 6372: ).mutex)) != 0) 6373: { 6374: (*s_etat_processus).erreur_systeme = 6375: d_es_processus; 6376: return(d_erreur); 6377: } 6378: } 6379: else 6380: { 6381: (*s_etat_processus).erreur_systeme = d_es; 6382: presence_variable = d_faux; 6383: presence_variable_partagee = d_faux; 6384: } 6385: } 6386: else 6387: { 6388: presence_variable = d_vrai; 6389: 6390: if ((*(*(*s_etat_processus) 6391: .pointeur_variable_courante).objet) 6392: .type == ADR) 6393: { 6394: presence_fonction = d_vrai; 6395: } 6396: } 6397: } 6398: else 6399: { 6400: presence_variable = d_faux; 6401: } 6402: } 6403: 6404: liberation(s_etat_processus, s_objet_elementaire); 6405: 6406: if (presence_fonction == d_vrai) 6407: { 6408: if ((*((struct_nom *) (*(*l_element_courant).donnee) 6409: .objet)).symbole == d_vrai) 6410: { 6411: // L'objet apparaît comme un symbole dans 6412: // l'expression en cours d'évaluation. On se 6413: // contente de l'empiler. 6414: 6415: if ((s_sous_objet = copie_objet(s_etat_processus, 6416: (*l_element_courant).donnee, 'P')) == NULL) 6417: { 6418: (*s_etat_processus).instruction_courante = 6419: instruction_courante; 6420: 6421: (*s_etat_processus).erreur_systeme = 6422: d_es_allocation_memoire; 6423: return(d_erreur); 6424: } 6425: 6426: if (empilement(s_etat_processus, 6427: &((*s_etat_processus).l_base_pile), 6428: s_sous_objet) == d_erreur) 6429: { 6430: (*s_etat_processus).instruction_courante = 6431: instruction_courante; 6432: liberation(s_etat_processus, s_sous_objet); 6433: return(d_erreur); 6434: } 6435: } 6436: else 6437: { 6438: autorisation_empilement_programme = 6439: (*s_etat_processus) 6440: .autorisation_empilement_programme; 6441: registre_position_courante = (*s_etat_processus) 6442: .position_courante; 6443: 6444: empilement_pile_systeme(s_etat_processus); 6445: 6446: if ((*s_etat_processus).erreur_systeme != d_es) 6447: { 6448: if (presence_variable_partagee == d_vrai) 6449: { 6450: liberation(s_etat_processus, 6451: s_copie_variable_partagee); 6452: } 6453: 6454: if (presence_egalite == d_vrai) 6455: { 6456: liberation(s_etat_processus, 6457: s_objet_evalue); 6458: } 6459: 6460: (*s_etat_processus).instruction_courante = 6461: instruction_courante; 6462: return(d_erreur); 6463: } 6464: 6465: (*(*s_etat_processus).l_base_pile_systeme) 6466: .retour_definition = 'Y'; 6467: (*(*s_etat_processus).l_base_pile_systeme) 6468: .origine_routine_evaluation = 'Y'; 6469: 6470: (*s_etat_processus).mode_execution_programme = 'Y'; 6471: (*s_etat_processus) 6472: .autorisation_empilement_programme = 'N'; 6473: 6474: (*(*s_etat_processus).l_base_pile_systeme) 6475: .niveau_courant = (*s_etat_processus) 6476: .niveau_courant; 6477: 6478: if (presence_variable_partagee == d_faux) 6479: { 6480: (*s_etat_processus).position_courante = 6481: (*((integer8 *) 6482: ((*(*(*s_etat_processus) 6483: .pointeur_variable_courante) 6484: .objet).objet))); 6485: } 6486: else 6487: { 6488: (*s_etat_processus).position_courante = 6489: (*((integer8 *) 6490: (*s_copie_variable_partagee).objet)); 6491: liberation(s_etat_processus, 6492: s_copie_variable_partagee); 6493: } 6494: 6495: if ((*s_etat_processus).profilage == d_vrai) 6496: { 6497: profilage(s_etat_processus, 6498: (*(*s_etat_processus) 6499: .pointeur_variable_courante).nom); 6500: 6501: if ((*s_etat_processus).erreur_systeme != d_es) 6502: { 6503: return(d_erreur); 6504: } 6505: } 6506: 6507: registre_evaluation_forcee = 6508: (*s_etat_processus).evaluation_forcee; 6509: 6510: if (type_evaluation == 'N') 6511: { 6512: (*s_etat_processus).evaluation_forcee = 'Y'; 6513: } 6514: 6515: if (sequenceur(s_etat_processus) == d_erreur) 6516: { 6517: (*s_etat_processus).evaluation_forcee = 6518: registre_evaluation_forcee; 6519: 6520: if (presence_egalite == d_vrai) 6521: { 6522: liberation(s_etat_processus, 6523: s_objet_evalue); 6524: } 6525: 6526: depilement_pile_systeme(s_etat_processus); 6527: 6528: (*s_etat_processus).instruction_courante = 6529: instruction_courante; 6530: (*s_etat_processus).mode_execution_programme = 6531: registre_mode_execution_programme; 6532: return(d_erreur); 6533: } 6534: 6535: (*s_etat_processus).evaluation_forcee = 6536: registre_evaluation_forcee; 6537: (*s_etat_processus).instruction_courante = 6538: instruction_courante; 6539: (*s_etat_processus).mode_execution_programme = 'N'; 6540: 6541: depilement_pile_systeme(s_etat_processus); 6542: 6543: if ((*s_etat_processus).erreur_systeme != d_es) 6544: { 6545: if (presence_egalite == d_vrai) 6546: { 6547: liberation(s_etat_processus, 6548: s_objet_evalue); 6549: } 6550: 6551: return(d_erreur); 6552: } 6553: 6554: (*s_etat_processus).retour_routine_evaluation = 'N'; 6555: (*s_etat_processus).position_courante = 6556: registre_position_courante; 6557: (*s_etat_processus) 6558: .autorisation_empilement_programme = 6559: autorisation_empilement_programme; 6560: } 6561: } 6562: else if (((type_evaluation == 'N') || ((*((struct_nom *) 6563: (*(*l_element_courant).donnee).objet)).symbole == 6564: d_faux)) && (presence_variable == d_vrai)) 6565: { 6566: if (type_evaluation == 'I') 6567: { 6568: if (presence_variable_partagee == d_faux) 6569: { 6570: if ((s_sous_objet = 6571: copie_objet(s_etat_processus, 6572: (*(*s_etat_processus) 6573: .pointeur_variable_courante).objet, 6574: 'P')) == NULL) 6575: { 6576: if (presence_variable_partagee == d_vrai) 6577: { 6578: liberation(s_etat_processus, 6579: s_copie_variable_partagee); 6580: } 6581: 6582: if (presence_egalite == d_vrai) 6583: { 6584: liberation(s_etat_processus, 6585: s_objet_evalue); 6586: } 6587: 6588: (*s_etat_processus).erreur_systeme = 6589: d_es_allocation_memoire; 6590: (*s_etat_processus).instruction_courante = 6591: instruction_courante; 6592: return(d_erreur); 6593: } 6594: 6595: if (empilement(s_etat_processus, 6596: &((*s_etat_processus).l_base_pile), 6597: s_sous_objet) == d_erreur) 6598: { 6599: if (presence_variable_partagee == d_vrai) 6600: { 6601: liberation(s_etat_processus, 6602: s_copie_variable_partagee); 6603: } 6604: 6605: if (presence_egalite == d_vrai) 6606: { 6607: liberation(s_etat_processus, 6608: s_objet_evalue); 6609: } 6610: 6611: return(d_erreur); 6612: } 6613: } 6614: else 6615: { 6616: if (empilement(s_etat_processus, 6617: &((*s_etat_processus).l_base_pile), 6618: s_copie_variable_partagee) == d_erreur) 6619: { 6620: if (presence_variable_partagee == d_vrai) 6621: { 6622: liberation(s_etat_processus, 6623: s_copie_variable_partagee); 6624: } 6625: 6626: if (presence_egalite == d_vrai) 6627: { 6628: liberation(s_etat_processus, 6629: s_objet_evalue); 6630: } 6631: 6632: return(d_erreur); 6633: } 6634: } 6635: } 6636: else 6637: { 6638: registre_evaluation_expression_compilee = 6639: (*s_etat_processus) 6640: .evaluation_expression_compilee; 6641: 6642: if (((*(*s_etat_processus) 6643: .pointeur_variable_courante) 6644: .origine == 'E') && ((*(*s_etat_processus) 6645: .pointeur_variable_courante).niveau == 0)) 6646: { 6647: (*s_etat_processus) 6648: .evaluation_expression_compilee = 'Y'; 6649: } 6650: else 6651: { 6652: (*s_etat_processus) 6653: .evaluation_expression_compilee = 'N'; 6654: } 6655: 6656: if (presence_variable_partagee == d_faux) 6657: { 6658: if ((*s_etat_processus).profilage == d_vrai) 6659: { 6660: profilage(s_etat_processus, 6661: (*(*s_etat_processus) 6662: .pointeur_variable_courante).nom); 6663: 6664: if ((*s_etat_processus).erreur_systeme 6665: != d_es) 6666: { 6667: return(d_erreur); 6668: } 6669: } 6670: 6671: empilement_pile_systeme(s_etat_processus); 6672: 6673: (*(*s_etat_processus).l_base_pile_systeme) 6674: .retour_definition = 'Y'; 6675: (*(*s_etat_processus).l_base_pile_systeme) 6676: .niveau_courant = (*s_etat_processus) 6677: .niveau_courant; 6678: (*(*s_etat_processus).l_base_pile_systeme) 6679: .pointeur_objet_retour = 6680: l_element_courant; 6681: (*(*s_etat_processus).l_base_pile_systeme) 6682: .origine_routine_evaluation = 'Y'; 6683: 6684: if (evaluation(s_etat_processus, 6685: (*(*s_etat_processus) 6686: .pointeur_variable_courante).objet, 6687: type_evaluation) == d_erreur) 6688: { 6689: depilement_pile_systeme(s_etat_processus); 6690: 6691: if ((*s_etat_processus).profilage == d_vrai) 6692: { 6693: profilage(s_etat_processus, NULL); 6694: } 6695: 6696: (*s_etat_processus) 6697: .evaluation_expression_compilee = 6698: registre_evaluation_expression_compilee; 6699: 6700: if (presence_egalite == d_vrai) 6701: { 6702: liberation(s_etat_processus, 6703: s_objet_evalue); 6704: } 6705: 6706: (*s_etat_processus).instruction_courante = 6707: instruction_courante; 6708: (*s_etat_processus).mode_execution_programme 6709: = registre_mode_execution_programme; 6710: return(d_erreur); 6711: } 6712: 6713: depilement_pile_systeme(s_etat_processus); 6714: 6715: if ((((*s_etat_processus).erreur_execution != 6716: d_ex) || ((*s_etat_processus) 6717: .erreur_systeme != d_es)) && 6718: ((*s_etat_processus).arret_si_exception 6719: == d_faux)) 6720: { 6721: // Reprise sur erreur. 6722: 6723: //============================================================================== 6724: // Réindentation 6725: //============================================================================== 6726: 6727: drapeau_then = d_faux; 6728: 6729: while(drapeau_then == d_faux) 6730: { 6731: l_registre_atome = l_element_courant; 6732: l_element_courant = (*l_element_courant).suivant; 6733: 6734: if (l_element_courant == NULL) 6735: { 6736: /* 6737: * La fin de l'expression est atteinte, 6738: * le sequenceur reprend la main. 6739: */ 6740: 6741: if (presence_egalite == d_vrai) 6742: { 6743: liberation(s_etat_processus, s_objet_evalue); 6744: } 6745: 6746: (*s_etat_processus).mode_execution_programme = 6747: registre_mode_execution_programme; 6748: return(d_absence_erreur); 6749: } 6750: 6751: if ((*(*l_element_courant).donnee).type == FCT) 6752: { 6753: (*s_etat_processus).instruction_courante = 6754: (*((struct_fonction *) 6755: (*(*l_element_courant).donnee) 6756: .objet)).nom_fonction; 6757: 6758: if (recherche_variable(s_etat_processus, 6759: (*s_etat_processus).instruction_courante) == d_faux) 6760: { 6761: (*s_etat_processus).erreur_systeme = d_es; 6762: fonction = (*((struct_fonction *) 6763: (*(*l_element_courant).donnee) 6764: .objet)).fonction; 6765: 6766: /* 6767: * Traitement de la pile système par les 6768: * différentes instructions. 6769: */ 6770: 6771: if (TEST(instruction_if) || 6772: TEST(instruction_iferr) || 6773: TEST(instruction_do) || 6774: TEST(instruction_while) || 6775: TEST(instruction_for) || 6776: TEST(instruction_forall) || 6777: TEST(instruction_start) || 6778: TEST(instruction_select) || 6779: TEST(instruction_case) || 6780: TEST(instruction_critical) || 6781: TEST(vers_niveau_superieur)) 6782: { 6783: if (TEST(vers_niveau_superieur)) 6784: { 6785: registre_exception = (*s_etat_processus) 6786: .exception; 6787: registre_erreur_execution = (*s_etat_processus) 6788: .erreur_execution; 6789: 6790: analyse(s_etat_processus, 6791: vers_niveau_superieur); 6792: 6793: if ((*s_etat_processus).erreur_systeme != d_es) 6794: { 6795: if (presence_egalite == d_vrai) 6796: { 6797: liberation(s_etat_processus, 6798: s_objet_evalue); 6799: } 6800: 6801: (*s_etat_processus).instruction_courante = 6802: instruction_courante; 6803: return(d_erreur); 6804: } 6805: 6806: (*s_etat_processus).exception 6807: = registre_exception; 6808: (*s_etat_processus).erreur_execution = 6809: registre_erreur_execution; 6810: } 6811: else if (TEST(instruction_for) || 6812: TEST(instruction_forall) || 6813: TEST(instruction_start)) 6814: { 6815: empilement_pile_systeme(s_etat_processus); 6816: 6817: if ((*s_etat_processus).erreur_systeme != d_es) 6818: { 6819: if (presence_egalite == d_vrai) 6820: { 6821: liberation(s_etat_processus, 6822: s_objet_evalue); 6823: } 6824: 6825: (*s_etat_processus).instruction_courante = 6826: instruction_courante; 6827: return(d_erreur); 6828: } 6829: 6830: (*(*s_etat_processus).l_base_pile_systeme) 6831: .type_cloture = 'L'; 6832: } 6833: else 6834: { 6835: empilement_pile_systeme(s_etat_processus); 6836: 6837: if ((*s_etat_processus).erreur_systeme != d_es) 6838: { 6839: if (presence_egalite == d_vrai) 6840: { 6841: liberation(s_etat_processus, 6842: s_objet_evalue); 6843: } 6844: 6845: (*s_etat_processus).instruction_courante = 6846: instruction_courante; 6847: return(d_erreur); 6848: } 6849: } 6850: } 6851: else if (TEST(instruction_end) || 6852: TEST(instruction_next) || 6853: TEST(instruction_step) || 6854: TEST(vers_niveau_inferieur)) 6855: { 6856: if (TEST(vers_niveau_inferieur)) 6857: { 6858: registre_exception = (*s_etat_processus) 6859: .exception; 6860: registre_erreur_execution = (*s_etat_processus) 6861: .erreur_execution; 6862: 6863: analyse(s_etat_processus, 6864: vers_niveau_inferieur); 6865: 6866: if ((*s_etat_processus).erreur_systeme != d_es) 6867: { 6868: if (presence_egalite == d_vrai) 6869: { 6870: liberation(s_etat_processus, 6871: s_objet_evalue); 6872: } 6873: 6874: (*s_etat_processus).instruction_courante = 6875: instruction_courante; 6876: return(d_erreur); 6877: } 6878: 6879: (*s_etat_processus).exception 6880: = registre_exception; 6881: (*s_etat_processus).erreur_execution = 6882: registre_erreur_execution; 6883: } 6884: else if ((TEST(instruction_next) || 6885: TEST(instruction_step)) && 6886: ((*(*s_etat_processus) 6887: .l_base_pile_systeme) 6888: .type_cloture != 'L')) 6889: { 6890: /* 6891: * Libération des compteurs 6892: * de boucle 6893: */ 6894: 6895: presence_compteur = (((*(*s_etat_processus) 6896: .l_base_pile_systeme).type_cloture == 'F') 6897: || ((*(*s_etat_processus) 6898: .l_base_pile_systeme).type_cloture == 'A')) 6899: ? d_vrai : d_faux; 6900: 6901: if (((*(*s_etat_processus).l_base_pile_systeme) 6902: .type_cloture != 'S') && (presence_compteur 6903: == d_faux)) 6904: { 6905: (*s_etat_processus).erreur_execution = 6906: d_ex_erreur_traitement_boucle; 6907: 6908: if (presence_egalite == d_vrai) 6909: { 6910: liberation(s_etat_processus, 6911: s_objet_evalue); 6912: } 6913: 6914: (*s_etat_processus).instruction_courante = 6915: instruction_courante; 6916: return(d_erreur); 6917: } 6918: 6919: if (presence_compteur == d_vrai) 6920: { 6921: if (recherche_variable(s_etat_processus, 6922: (*(*s_etat_processus) 6923: .l_base_pile_systeme).nom_variable) 6924: == d_faux) 6925: { 6926: (*s_etat_processus).erreur_systeme = 6927: d_es; 6928: (*s_etat_processus).erreur_execution = 6929: d_ex_erreur_traitement_boucle; 6930: 6931: if (presence_egalite == d_vrai) 6932: { 6933: liberation(s_etat_processus, 6934: s_objet_evalue); 6935: } 6936: 6937: (*s_etat_processus).instruction_courante 6938: = instruction_courante; 6939: return(d_erreur); 6940: } 6941: 6942: if ((*(*s_etat_processus) 6943: .pointeur_variable_courante) 6944: .objet == NULL) 6945: { 6946: (*s_etat_processus).erreur_systeme = 6947: d_es; 6948: (*s_etat_processus).erreur_execution = 6949: d_ex_variable_partagee; 6950: 6951: if (presence_egalite == d_vrai) 6952: { 6953: liberation(s_etat_processus, 6954: s_objet_evalue); 6955: } 6956: 6957: (*s_etat_processus).instruction_courante 6958: = instruction_courante; 6959: return(d_erreur); 6960: } 6961: 6962: (*s_etat_processus) 6963: .niveau_courant--; 6964: 6965: if (retrait_variables_par_niveau( 6966: s_etat_processus) == d_erreur) 6967: { 6968: if (presence_egalite == d_vrai) 6969: { 6970: liberation(s_etat_processus, 6971: s_objet_evalue); 6972: } 6973: 6974: (*s_etat_processus).instruction_courante = instruction_courante; 6975: return(d_erreur); 6976: } 6977: } 6978: 6979: depilement_pile_systeme(s_etat_processus); 6980: } 6981: else 6982: { 6983: // Traitement spécifique pour 6984: // la fin d'une section 6985: // critique 6986: 6987: if ((*s_etat_processus).l_base_pile_systeme 6988: == NULL) 6989: { 6990: (*s_etat_processus).erreur_systeme = 6991: d_es_end_incoherent; 6992: 6993: if (presence_egalite == d_vrai) 6994: { 6995: liberation(s_etat_processus, 6996: s_objet_evalue); 6997: } 6998: 6999: (*s_etat_processus).instruction_courante = 7000: instruction_courante; 7001: return(d_erreur); 7002: } 7003: 7004: if ((*(*s_etat_processus).l_base_pile_systeme) 7005: .type_cloture == 'Q') 7006: { 7007: if (pthread_mutex_unlock( 7008: &mutex_sections_critiques) != 0) 7009: { 7010: (*s_etat_processus).erreur_systeme = 7011: d_es_processus; 7012: 7013: liberation(s_etat_processus, 7014: s_objet_evalue); 7015: 7016: (*s_etat_processus).instruction_courante = instruction_courante; 7017: return(d_erreur); 7018: } 7019: 7020: (*s_etat_processus).sections_critiques--; 7021: } 7022: 7023: depilement_pile_systeme(s_etat_processus); 7024: 7025: if ((*s_etat_processus) 7026: .erreur_systeme != d_es) 7027: { 7028: if (presence_egalite == d_vrai) 7029: { 7030: liberation(s_etat_processus, 7031: s_objet_evalue); 7032: } 7033: 7034: (*s_etat_processus).instruction_courante = 7035: instruction_courante; 7036: return(d_erreur); 7037: } 7038: } 7039: } 7040: else if (TEST(instruction_then)) 7041: { 7042: if ((*(*s_etat_processus).l_base_pile_systeme) 7043: .clause == 'R') 7044: { 7045: (*(*s_etat_processus).l_base_pile_systeme) 7046: .clause = 'X'; 7047: instruction_then(s_etat_processus); 7048: drapeau_then = d_vrai; 7049: } 7050: } 7051: } 7052: } 7053: } 7054: 7055: (*s_etat_processus).expression_courante = 7056: l_element_courant; 7057: (*s_etat_processus).instruction_courante = 7058: instruction_courante; 7059: 7060: (*s_etat_processus).exception = d_ep; 7061: (*s_etat_processus).erreur_execution = d_ex; 7062: 7063: //============================================================================== 7064: // Fin de la réindentation 7065: //============================================================================== 7066: } 7067: } 7068: else 7069: { 7070: if ((*s_etat_processus).profilage == d_vrai) 7071: { 7072: profilage(s_etat_processus, 7073: (*(*s_etat_processus) 7074: .pointeur_variable_courante).nom); 7075: 7076: if ((*s_etat_processus).erreur_systeme 7077: != d_es) 7078: { 7079: return(d_erreur); 7080: } 7081: } 7082: 7083: empilement_pile_systeme(s_etat_processus); 7084: (*(*s_etat_processus).l_base_pile_systeme) 7085: .retour_definition = 'Y'; 7086: (*(*s_etat_processus).l_base_pile_systeme) 7087: .niveau_courant = (*s_etat_processus) 7088: .niveau_courant; 7089: 7090: if (evaluation(s_etat_processus, 7091: s_copie_variable_partagee, 7092: type_evaluation) == d_erreur) 7093: { 7094: depilement_pile_systeme(s_etat_processus); 7095: 7096: liberation(s_etat_processus, 7097: s_copie_variable_partagee); 7098: 7099: if ((*s_etat_processus).profilage == d_vrai) 7100: { 7101: profilage(s_etat_processus, NULL); 7102: } 7103: 7104: (*s_etat_processus) 7105: .evaluation_expression_compilee = 7106: registre_evaluation_expression_compilee; 7107: 7108: if (presence_egalite == d_vrai) 7109: { 7110: liberation(s_etat_processus, 7111: s_objet_evalue); 7112: } 7113: 7114: (*s_etat_processus).instruction_courante = 7115: instruction_courante; 7116: (*s_etat_processus).mode_execution_programme 7117: = registre_mode_execution_programme; 7118: return(d_erreur); 7119: } 7120: 7121: depilement_pile_systeme(s_etat_processus); 7122: 7123: liberation(s_etat_processus, 7124: s_copie_variable_partagee); 7125: } 7126: 7127: if ((*s_etat_processus).profilage == d_vrai) 7128: { 7129: profilage(s_etat_processus, NULL); 7130: } 7131: 7132: (*s_etat_processus) 7133: .evaluation_expression_compilee = 7134: registre_evaluation_expression_compilee; 7135: } 7136: } 7137: else 7138: { 7139: if (presence_variable_partagee == d_vrai) 7140: { 7141: liberation(s_etat_processus, 7142: s_copie_variable_partagee); 7143: } 7144: 7145: if ((s_objet_elementaire = 7146: copie_objet(s_etat_processus, 7147: (*l_element_courant).donnee, 'P')) == NULL) 7148: { 7149: if (presence_egalite == d_vrai) 7150: { 7151: liberation(s_etat_processus, s_objet_evalue); 7152: } 7153: 7154: (*s_etat_processus).erreur_systeme = 7155: d_es_allocation_memoire; 7156: (*s_etat_processus).instruction_courante = 7157: instruction_courante; 7158: return(d_erreur); 7159: } 7160: 7161: /* 7162: * Vérification du drapeau symbole pour 7163: * savoir si l'on met dans la pile le nom 7164: * ou le contenu de la variable. 7165: */ 7166: 7167: if (((*((struct_nom *) (*s_objet_elementaire).objet)) 7168: .symbole == d_faux) && ((*s_etat_processus) 7169: .traitement_symbolique == 'N')) 7170: { 7171: if (recherche_variable(s_etat_processus, 7172: (*((struct_nom *) (*s_objet_elementaire) 7173: .objet)).nom) == d_vrai) 7174: { 7175: if ((*(*s_etat_processus) 7176: .pointeur_variable_courante).objet 7177: == NULL) 7178: { 7179: // Variable partagée 7180: 7181: if (recherche_variable_partagee( 7182: s_etat_processus, 7183: (*(*s_etat_processus) 7184: .pointeur_variable_courante).nom, 7185: (*(*s_etat_processus) 7186: .pointeur_variable_courante) 7187: .variable_partagee, 'E') != NULL) 7188: { 7189: liberation(s_etat_processus, 7190: s_objet_elementaire); 7191: 7192: if ((s_objet_elementaire = 7193: copie_objet(s_etat_processus, 7194: (*(*s_etat_processus) 7195: .pointeur_variable_partagee_courante 7196: ).objet, 'P')) == NULL) 7197: { 7198: if (pthread_mutex_unlock( 7199: &((*(*s_etat_processus) 7200: .pointeur_variable_partagee_courante 7201: ).mutex)) != 0) 7202: { 7203: (*s_etat_processus) 7204: .erreur_systeme = 7205: d_es_processus; 7206: return(d_erreur); 7207: } 7208: 7209: if (presence_egalite == d_vrai) 7210: { 7211: liberation(s_etat_processus, 7212: s_objet_evalue); 7213: } 7214: 7215: (*s_etat_processus).erreur_systeme = 7216: d_es_allocation_memoire; 7217: (*s_etat_processus) 7218: .instruction_courante = 7219: instruction_courante; 7220: return(d_erreur); 7221: } 7222: 7223: if (pthread_mutex_unlock( 7224: &((*(*s_etat_processus) 7225: .pointeur_variable_partagee_courante 7226: ).mutex)) != 0) 7227: { 7228: (*s_etat_processus).erreur_systeme = 7229: d_es_processus; 7230: return(d_erreur); 7231: } 7232: } 7233: } 7234: else 7235: { 7236: // Variable privée 7237: 7238: liberation(s_etat_processus, 7239: s_objet_elementaire); 7240: 7241: if ((s_objet_elementaire = 7242: copie_objet(s_etat_processus, 7243: (*(*s_etat_processus) 7244: .pointeur_variable_courante).objet, 7245: 'P')) == NULL) 7246: { 7247: if (presence_egalite == d_vrai) 7248: { 7249: liberation(s_etat_processus, 7250: s_objet_evalue); 7251: } 7252: 7253: (*s_etat_processus).erreur_systeme = 7254: d_es_allocation_memoire; 7255: (*s_etat_processus) 7256: .instruction_courante = 7257: instruction_courante; 7258: return(d_erreur); 7259: } 7260: } 7261: } 7262: else 7263: { 7264: (*s_etat_processus).erreur_systeme = d_es; 7265: 7266: (*((struct_nom *) (*s_objet_elementaire) 7267: .objet)).symbole = d_vrai; 7268: } 7269: } 7270: 7271: if (empilement(s_etat_processus, &((*s_etat_processus) 7272: .l_base_pile), s_objet_elementaire) == d_erreur) 7273: { 7274: if (presence_egalite == d_vrai) 7275: { 7276: liberation(s_etat_processus, s_objet_evalue); 7277: } 7278: 7279: (*s_etat_processus).instruction_courante = 7280: instruction_courante; 7281: return(d_erreur); 7282: } 7283: 7284: if ((*s_etat_processus).erreur_execution == 7285: d_ex_variable_non_definie) 7286: { 7287: (*s_etat_processus).erreur_execution = d_ex; 7288: } 7289: } 7290: } 7291: else 7292: { 7293: registre_type_evaluation = (test_cfsf(s_etat_processus, 35) 7294: == d_vrai) ? 'E' : 'N'; 7295: 7296: if (type_evaluation == 'N') 7297: { 7298: cf(s_etat_processus, 35); 7299: } 7300: else 7301: { 7302: sf(s_etat_processus, 35); 7303: } 7304: 7305: analyse(s_etat_processus, NULL); 7306: 7307: if (registre_type_evaluation == 'E') 7308: { 7309: sf(s_etat_processus, 35); 7310: } 7311: else 7312: { 7313: cf(s_etat_processus, 35); 7314: } 7315: 7316: if (((*s_etat_processus).erreur_systeme != d_es) || 7317: ((*s_etat_processus).erreur_execution != d_ex) || 7318: ((*s_etat_processus).exception != d_ep)) 7319: { 7320: // Il est anormal de récupérer ici une erreur 7321: // d'exécution puisqu'on empile une constante 7322: // symbolique. 7323: 7324: if (presence_egalite == d_vrai) 7325: { 7326: liberation(s_etat_processus, s_objet_evalue); 7327: } 7328: 7329: (*s_etat_processus).instruction_courante = 7330: instruction_courante; 7331: (*s_etat_processus).mode_execution_programme = 7332: registre_mode_execution_programme; 7333: return(d_erreur); 7334: } 7335: } 7336: 7337: (*s_etat_processus).instruction_courante = 7338: instruction_courante; 7339: (*s_etat_processus).test_instruction = registre_test; 7340: (*s_etat_processus).instruction_valide = 7341: registre_instruction_valide; 7342: } 7343: else 7344: { 7345: if ((s_objet_tampon = copie_objet(s_etat_processus, 7346: (*l_element_courant).donnee, 'P')) == NULL) 7347: { 7348: (*s_etat_processus).erreur_systeme = 7349: d_es_allocation_memoire; 7350: (*s_etat_processus).instruction_courante = 7351: instruction_courante; 7352: return(d_erreur); 7353: } 7354: 7355: if (empilement(s_etat_processus, &((*s_etat_processus) 7356: .l_base_pile), s_objet_tampon) == d_erreur) 7357: { 7358: if (presence_egalite == d_vrai) 7359: { 7360: liberation(s_etat_processus, s_objet_evalue); 7361: } 7362: 7363: (*s_etat_processus).instruction_courante = 7364: instruction_courante; 7365: return(d_erreur); 7366: } 7367: } 7368: 7369: // Traitement de l'instruction EXIT en mode interactif 7370: 7371: if ((*s_etat_processus).traitement_cycle_exit != 'N') 7372: { 7373: registre_expression_courante = 7374: (*s_etat_processus).expression_courante; 7375: (*s_etat_processus).expression_courante = 7376: l_element_courant; 7377: 7378: switch((*s_etat_processus).traitement_cycle_exit) 7379: { 7380: case 'C' : 7381: { 7382: instruction_cycle(s_etat_processus); 7383: break; 7384: } 7385: 7386: case 'E' : 7387: { 7388: instruction_exit(s_etat_processus); 7389: break; 7390: } 7391: } 7392: 7393: l_element_courant = (*s_etat_processus).expression_courante; 7394: (*s_etat_processus).expression_courante = 7395: registre_expression_courante; 7396: } 7397: 7398: if (l_element_courant != NULL) 7399: { 7400: l_element_courant = (*l_element_courant).suivant; 7401: } 7402: else 7403: { 7404: (*s_etat_processus).mode_execution_programme = 'Y'; 7405: 7406: if ((*s_etat_processus).niveau_courant == 1) 7407: { 7408: (*s_etat_processus).debug_programme = d_faux; 7409: (*s_etat_processus).execution_pas_suivant = d_vrai; 7410: } 7411: } 7412: 7413: } 7414: 7415: if (niveau_initial < (*s_etat_processus).niveau_courant) 7416: { 7417: /* 7418: * Retrait des variables dans le cas où l'évaluation de 7419: * l'expression a été interrompue 7420: */ 7421: 7422: (*s_etat_processus).niveau_courant = niveau_initial; 7423: 7424: if (retrait_variables_par_niveau(s_etat_processus) == d_erreur) 7425: { 7426: if (presence_egalite == d_vrai) 7427: { 7428: liberation(s_etat_processus, s_objet_evalue); 7429: } 7430: 7431: (*s_etat_processus).instruction_courante = 7432: instruction_courante; 7433: (*s_etat_processus).mode_execution_programme = 7434: registre_mode_execution_programme; 7435: return(d_erreur); 7436: } 7437: } 7438: 7439: /* 7440: * Retrait des variables statiques créées dans l'expression 7441: */ 7442: 7443: if (retrait_variables_statiques_locales(s_etat_processus) == d_erreur) 7444: { 7445: if (presence_egalite == d_vrai) 7446: { 7447: liberation(s_etat_processus, s_objet_evalue); 7448: } 7449: 7450: (*s_etat_processus).instruction_courante = 7451: instruction_courante; 7452: (*s_etat_processus).mode_execution_programme = 7453: registre_mode_execution_programme; 7454: return(d_erreur); 7455: } 7456: 7457: /* 7458: * Retrait des variables partagées créées dans l'expression 7459: */ 7460: 7461: if (retrait_variables_partagees_locales(s_etat_processus) == d_erreur) 7462: { 7463: if (presence_egalite == d_vrai) 7464: { 7465: liberation(s_etat_processus, s_objet_evalue); 7466: } 7467: 7468: (*s_etat_processus).instruction_courante = 7469: instruction_courante; 7470: (*s_etat_processus).mode_execution_programme = 7471: registre_mode_execution_programme; 7472: return(d_erreur); 7473: } 7474: 7475: if ((*s_etat_processus).var_volatile_requete_arret != 0) 7476: { 7477: // Restauration de la pile système 7478: 7479: while(pile_systeme_originelle != 7480: (*s_etat_processus).l_base_pile_systeme) 7481: { 7482: depilement_pile_systeme(s_etat_processus); 7483: } 7484: } 7485: 7486: if (presence_egalite == d_vrai) 7487: { 7488: // Ajout du membre évalué lors de la première passe 7489: 7490: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 7491: s_objet_evalue) == d_erreur) 7492: { 7493: (*s_etat_processus).instruction_courante = 7494: instruction_courante; 7495: return(d_erreur); 7496: } 7497: 7498: instruction_swap(s_etat_processus); 7499: 7500: if ((*s_etat_processus).erreur_execution != d_ex) 7501: { 7502: (*s_etat_processus).mode_execution_programme = 7503: registre_mode_execution_programme; 7504: (*s_etat_processus).autorisation_empilement_programme = 7505: autorisation_empilement_programme; 7506: (*s_etat_processus).instruction_courante = instruction_courante; 7507: return(d_erreur); 7508: } 7509: 7510: instruction_egalite(s_etat_processus); 7511: 7512: if ((*s_etat_processus).erreur_execution != d_ex) 7513: { 7514: (*s_etat_processus).mode_execution_programme = 7515: registre_mode_execution_programme; 7516: (*s_etat_processus).autorisation_empilement_programme = 7517: autorisation_empilement_programme; 7518: (*s_etat_processus).instruction_courante = instruction_courante; 7519: return(d_erreur); 7520: } 7521: } 7522: 7523: (*s_etat_processus).autorisation_empilement_programme = 7524: autorisation_empilement_programme; 7525: (*s_etat_processus).instruction_courante = instruction_courante; 7526: } 7527: else if ((*s_objet).type == FCT) 7528: { 7529: (*s_etat_processus).instruction_courante = 7530: (*((struct_fonction *) (*s_objet).objet)).nom_fonction; 7531: 7532: registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai) 7533: ? 'E' : 'N'; 7534: cf(s_etat_processus, 35); 7535: 7536: analyse(s_etat_processus, (*((struct_fonction *) 7537: (*s_objet).objet)).fonction); 7538: (*s_etat_processus).instruction_courante = instruction_courante; 7539: 7540: if (registre_type_evaluation == 'E') 7541: { 7542: sf(s_etat_processus, 35); 7543: } 7544: else 7545: { 7546: cf(s_etat_processus, 35); 7547: } 7548: 7549: if (((*s_etat_processus).erreur_systeme != d_es) || 7550: ((*s_etat_processus).erreur_execution != d_ex) || 7551: ((*s_etat_processus).exception != d_ep)) 7552: { 7553: (*s_etat_processus).mode_execution_programme = 7554: registre_mode_execution_programme; 7555: return(d_erreur); 7556: } 7557: } 7558: else 7559: { 7560: (*s_etat_processus).instruction_courante = instruction_courante; 7561: 7562: if ((s_objet_tampon = copie_objet(s_etat_processus, s_objet, 'P')) 7563: == NULL) 7564: { 7565: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 7566: return(d_erreur); 7567: } 7568: 7569: if (empilement(s_etat_processus, &((*s_etat_processus) 7570: .l_base_pile), s_objet_tampon) == d_erreur) 7571: { 7572: return(d_erreur); 7573: } 7574: } 7575: 7576: (*s_etat_processus).mode_execution_programme = 7577: registre_mode_execution_programme; 7578: 7579: return((erreur_evaluation == d_absence_erreur) 7580: ? d_absence_erreur : d_erreur); 7581: } 7582: 7583: // vim: ts=4