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