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