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