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