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