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