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