1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.32
4: Copyright (C) 1989-2020 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'ppar'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_ppar(struct_processus *s_etat_processus)
40: {
41: struct_liste_chainee *l_ancienne_base;
42: struct_liste_chainee *l_nouvelle_base;
43:
44: struct_objet *s_objet_resultat;
45:
46: /*
47: * { { Xmin Xmax } { Ymin Ymax } { Zmin Zmax }
48: * INDEP DEPND RES { EYEPT } }
49: * { "automatic" { Ymin Ymax } "automatic" INDEP DEPND RES { EYEPT } }
50: */
51:
52: (*s_etat_processus).erreur_execution = d_ex;
53:
54: if ((*s_etat_processus).affichage_arguments == 'Y')
55: {
56: printf("\n PPAR ");
57:
58: if ((*s_etat_processus).langue == 'F')
59: {
60: printf("(paramètres graphiques)\n\n");
61: }
62: else
63: {
64: printf("(graphical parameters)\n\n");
65: }
66:
67: printf("-> 1: %s\n", d_LST);
68:
69: return;
70: }
71: else if ((*s_etat_processus).test_instruction == 'Y')
72: {
73: (*s_etat_processus).nombre_arguments = -1;
74: return;
75: }
76:
77: if (test_cfsf(s_etat_processus, 31) == d_vrai)
78: {
79: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
80: {
81: return;
82: }
83: }
84:
85: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
86: {
87: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
88: return;
89: }
90:
91: (*s_objet_resultat).objet = NULL;
92: l_ancienne_base = (*s_objet_resultat).objet;
93:
94: // Paramètres des courbes de niveau
95:
96: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
97: {
98: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
99: return;
100: }
101:
102: if (((*l_nouvelle_base).donnee = copie_objet(s_etat_processus,
103: (*s_etat_processus).parametres_courbes_de_niveau, 'O')) == NULL)
104: {
105: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
106: return;
107: }
108:
109: (*l_nouvelle_base).suivant = l_ancienne_base;
110: (*s_objet_resultat).objet = l_nouvelle_base;
111: l_ancienne_base = (*s_objet_resultat).objet;
112:
113: // Point de vue
114:
115: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
116: {
117: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
118: return;
119: }
120:
121: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, LST))
122: == NULL)
123: {
124: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
125: return;
126: }
127:
128: (*l_nouvelle_base).suivant = l_ancienne_base;
129:
130: if (((*(*l_nouvelle_base).donnee).objet =
131: allocation_maillon(s_etat_processus)) == NULL)
132: {
133: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
134: return;
135: }
136:
137: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)).donnee
138: = allocation(s_etat_processus, REL)) == NULL)
139: {
140: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
141: return;
142: }
143:
144: (*((real8 *) (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
145: .objet)).donnee).objet)) = (*s_etat_processus).point_de_vue_theta;
146:
147: if (test_cfsf(s_etat_processus, 60) == d_faux)
148: {
149: conversion_radians_vers_degres((real8 *) (*(*((struct_liste_chainee *)
150: (*(*l_nouvelle_base).donnee).objet)).donnee).objet);
151: }
152:
153: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
154: .suivant = allocation_maillon(s_etat_processus)) == NULL)
155: {
156: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
157: return;
158: }
159:
160: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
161: .suivant).donnee = allocation(s_etat_processus, REL)) == NULL)
162: {
163: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
164: return;
165: }
166:
167: (*((real8 *) (*(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
168: .objet)).suivant).donnee).objet)) =
169: (*s_etat_processus).point_de_vue_phi;
170:
171: if (test_cfsf(s_etat_processus, 60) == d_faux)
172: {
173: conversion_radians_vers_degres((real8 *) (*(*(*((struct_liste_chainee *)
174: (*(*l_nouvelle_base).donnee).objet)).suivant).donnee).objet);
175: }
176:
177: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
178: .suivant).suivant = allocation_maillon(s_etat_processus)) == NULL)
179: {
180: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
181: return;
182: }
183:
184: if (((*(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
185: .suivant).suivant).donnee = allocation(s_etat_processus, REL))
186: == NULL)
187: {
188: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
189: return;
190: }
191:
192: (*((real8 *) (*(*(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
193: .objet)).suivant).suivant).donnee).objet)) =
194: (*s_etat_processus).echelle_3D;
195:
196: (*((*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
197: .suivant)).suivant)).suivant = NULL;
198:
199: (*s_objet_resultat).objet = l_nouvelle_base;
200: l_ancienne_base = (*s_objet_resultat).objet;
201:
202: // Type en cours
203:
204: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
205: {
206: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
207: return;
208: }
209:
210: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, CHN))
211: == NULL)
212: {
213: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
214: return;
215: }
216:
217: (*l_nouvelle_base).suivant = l_ancienne_base;
218:
219: if (strcmp((*s_etat_processus).type_trace_eq, "FONCTION") == 0)
220: {
221: if (((*(*l_nouvelle_base).donnee).objet = malloc(9 *
222: sizeof(unsigned char))) == NULL)
223: {
224: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
225: return;
226: }
227:
228: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
229: "FUNCTION");
230: }
231: else if (strcmp((*s_etat_processus).type_trace_eq, "PARAMETRIQUE") == 0)
232: {
233: if (((*(*l_nouvelle_base).donnee).objet = malloc(11 *
234: sizeof(unsigned char))) == NULL)
235: {
236: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
237: return;
238: }
239:
240: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
241: "PARAMETRIC");
242: }
243: else if (strcmp((*s_etat_processus).type_trace_eq, "POLAIRE") == 0)
244: {
245: if (((*(*l_nouvelle_base).donnee).objet = malloc(6 *
246: sizeof(unsigned char))) == NULL)
247: {
248: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
249: return;
250: }
251:
252: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
253: "POLAR");
254: }
255: else if (strcmp((*s_etat_processus).type_trace_eq, "COURBES DE NIVEAU")
256: == 0)
257: {
258: if (((*(*l_nouvelle_base).donnee).objet = malloc(6 *
259: sizeof(unsigned char))) == NULL)
260: {
261: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
262: return;
263: }
264:
265: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
266: "SLICE");
267: }
268: else if (strcmp((*s_etat_processus).type_trace_eq, "GRILLE 3D") == 0)
269: {
270: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
271: sizeof(unsigned char))) == NULL)
272: {
273: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
274: return;
275: }
276:
277: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
278: "WIREFRAME");
279: }
280: else
281: {
282: if (((*(*l_nouvelle_base).donnee).objet = malloc(
283: sizeof(unsigned char))) == NULL)
284: {
285: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
286: return;
287: }
288:
289: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, "");
290: }
291:
292: (*s_objet_resultat).objet = l_nouvelle_base;
293: l_ancienne_base = (*s_objet_resultat).objet;
294:
295: // Résolution
296:
297: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
298: {
299: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
300: return;
301: }
302:
303: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, REL))
304: == NULL)
305: {
306: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
307: return;
308: }
309:
310: (*l_nouvelle_base).suivant = l_ancienne_base;
311: (*((real8 *) (*(*l_nouvelle_base).donnee).objet)) =
312: (*s_etat_processus).resolution;
313: (*s_objet_resultat).objet = l_nouvelle_base;
314: l_ancienne_base = (*s_objet_resultat).objet;
315:
316: // DEPND
317:
318: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
319: {
320: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
321: return;
322: }
323:
324: if (((*l_nouvelle_base).donnee = copie_objet(s_etat_processus,
325: (*s_etat_processus).depend, 'O')) == NULL)
326: {
327: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
328: return;
329: }
330:
331: (*l_nouvelle_base).suivant = l_ancienne_base;
332: (*s_objet_resultat).objet = l_nouvelle_base;
333: l_ancienne_base = (*s_objet_resultat).objet;
334:
335: // INDEP
336:
337: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
338: {
339: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
340: return;
341: }
342:
343: if (((*l_nouvelle_base).donnee = copie_objet(s_etat_processus,
344: (*s_etat_processus).indep, 'O')) == NULL)
345: {
346: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
347: return;
348: }
349:
350: (*l_nouvelle_base).suivant = l_ancienne_base;
351: (*s_objet_resultat).objet = l_nouvelle_base;
352: l_ancienne_base = (*s_objet_resultat).objet;
353:
354: // Coordonnées Z2
355:
356: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
357: {
358: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
359: return;
360: }
361:
362: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
363: == NULL)
364: {
365: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
366: return;
367: }
368:
369: if ((*s_etat_processus).echelle_automatique_z2 == d_vrai)
370: {
371: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
372: sizeof(unsigned char))) == NULL)
373: {
374: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
375: return;
376: }
377:
378: (*(*l_nouvelle_base).donnee).type = CHN;
379: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
380: "AUTOMATIC");
381: }
382: else
383: {
384: (*(*l_nouvelle_base).donnee).type = LST;
385:
386: if (((*(*l_nouvelle_base).donnee).objet =
387: allocation_maillon(s_etat_processus)) == NULL)
388: {
389: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
390: return;
391: }
392:
393: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
394: .donnee = allocation(s_etat_processus, REL)) == NULL)
395: {
396: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
397: return;
398: }
399:
400: (*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
401: .objet)).donnee)).objet)) = (*s_etat_processus).z2_min;
402:
403: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
404: .suivant = allocation_maillon(s_etat_processus)) == NULL)
405: {
406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
407: return;
408: }
409:
410: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
411: .suivant).suivant = NULL;
412:
413: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
414: .suivant).donnee = allocation(s_etat_processus, REL))
415: == NULL)
416: {
417: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
418: return;
419: }
420:
421: (*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base)
422: .donnee).objet)).suivant).donnee)).objet)) =
423: (*s_etat_processus).z2_max;
424: }
425:
426: (*l_nouvelle_base).suivant = l_ancienne_base;
427: (*s_objet_resultat).objet = l_nouvelle_base;
428: l_ancienne_base = (*s_objet_resultat).objet;
429:
430: // Coordonnées Y2
431:
432: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
433: {
434: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
435: return;
436: }
437:
438: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
439: == NULL)
440: {
441: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
442: return;
443: }
444:
445: if ((*s_etat_processus).echelle_automatique_y2 == d_vrai)
446: {
447: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
448: sizeof(unsigned char))) == NULL)
449: {
450: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
451: return;
452: }
453:
454: (*(*l_nouvelle_base).donnee).type = CHN;
455: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
456: "AUTOMATIC");
457: }
458: else
459: {
460: (*(*l_nouvelle_base).donnee).type = LST;
461:
462: if (((*(*l_nouvelle_base).donnee).objet =
463: allocation_maillon(s_etat_processus)) == NULL)
464: {
465: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
466: return;
467: }
468:
469: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
470: .donnee = allocation(s_etat_processus, REL)) == NULL)
471: {
472: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
473: return;
474: }
475:
476: (*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
477: .objet)).donnee)).objet)) = (*s_etat_processus).y2_min;
478:
479: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
480: .suivant = allocation_maillon(s_etat_processus)) == NULL)
481: {
482: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
483: return;
484: }
485:
486: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
487: .suivant).suivant = NULL;
488:
489: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
490: .suivant).donnee = allocation(s_etat_processus, REL))
491: == NULL)
492: {
493: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
494: return;
495: }
496:
497: (*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base)
498: .donnee).objet)).suivant).donnee)).objet)) =
499: (*s_etat_processus).y2_max;
500: }
501:
502: (*l_nouvelle_base).suivant = l_ancienne_base;
503: (*s_objet_resultat).objet = l_nouvelle_base;
504: l_ancienne_base = (*s_objet_resultat).objet;
505:
506: // Coordonnées X2
507:
508: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
509: {
510: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
511: return;
512: }
513:
514: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
515: == NULL)
516: {
517: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
518: return;
519: }
520:
521: if ((*s_etat_processus).echelle_automatique_x2 == d_vrai)
522: {
523: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
524: sizeof(unsigned char))) == NULL)
525: {
526: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
527: return;
528: }
529:
530: (*(*l_nouvelle_base).donnee).type = CHN;
531: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
532: "AUTOMATIC");
533: }
534: else
535: {
536: (*(*l_nouvelle_base).donnee).type = LST;
537:
538: if (((*(*l_nouvelle_base).donnee).objet =
539: allocation_maillon(s_etat_processus)) == NULL)
540: {
541: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
542: return;
543: }
544:
545: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
546: .donnee = allocation(s_etat_processus, REL)) == NULL)
547: {
548: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
549: return;
550: }
551:
552: (*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
553: .objet)).donnee)).objet)) = (*s_etat_processus).x2_min;
554:
555: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
556: .suivant = allocation_maillon(s_etat_processus)) == NULL)
557: {
558: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
559: return;
560: }
561:
562: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
563: .suivant).suivant = NULL;
564:
565: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
566: .suivant).donnee = allocation(s_etat_processus, REL))
567: == NULL)
568: {
569: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
570: return;
571: }
572:
573: (*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base)
574: .donnee).objet)).suivant).donnee)).objet)) =
575: (*s_etat_processus).x2_max;
576: }
577:
578: (*l_nouvelle_base).suivant = l_ancienne_base;
579: (*s_objet_resultat).objet = l_nouvelle_base;
580: l_ancienne_base = (*s_objet_resultat).objet;
581:
582: // Coordonnées Z
583:
584: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
585: {
586: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
587: return;
588: }
589:
590: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
591: == NULL)
592: {
593: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
594: return;
595: }
596:
597: if ((*s_etat_processus).echelle_automatique_z == d_vrai)
598: {
599: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
600: sizeof(unsigned char))) == NULL)
601: {
602: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
603: return;
604: }
605:
606: (*(*l_nouvelle_base).donnee).type = CHN;
607: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
608: "AUTOMATIC");
609: }
610: else
611: {
612: (*(*l_nouvelle_base).donnee).type = LST;
613:
614: if (((*(*l_nouvelle_base).donnee).objet =
615: allocation_maillon(s_etat_processus)) == NULL)
616: {
617: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
618: return;
619: }
620:
621: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
622: .donnee = allocation(s_etat_processus, REL)) == NULL)
623: {
624: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
625: return;
626: }
627:
628: (*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
629: .objet)).donnee)).objet)) = (*s_etat_processus).z_min;
630:
631: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
632: .suivant = allocation_maillon(s_etat_processus)) == NULL)
633: {
634: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
635: return;
636: }
637:
638: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
639: .suivant).suivant = NULL;
640:
641: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
642: .suivant).donnee = allocation(s_etat_processus, REL))
643: == NULL)
644: {
645: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
646: return;
647: }
648:
649: (*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base)
650: .donnee).objet)).suivant).donnee)).objet)) =
651: (*s_etat_processus).z_max;
652: }
653:
654: (*l_nouvelle_base).suivant = l_ancienne_base;
655: (*s_objet_resultat).objet = l_nouvelle_base;
656: l_ancienne_base = (*s_objet_resultat).objet;
657:
658: // Coordonnées Y
659:
660: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
661: {
662: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
663: return;
664: }
665:
666: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
667: == NULL)
668: {
669: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
670: return;
671: }
672:
673: if ((*s_etat_processus).echelle_automatique_y == d_vrai)
674: {
675: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
676: sizeof(unsigned char))) == NULL)
677: {
678: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
679: return;
680: }
681:
682: (*(*l_nouvelle_base).donnee).type = CHN;
683: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
684: "AUTOMATIC");
685: }
686: else
687: {
688: (*(*l_nouvelle_base).donnee).type = LST;
689:
690: if (((*(*l_nouvelle_base).donnee).objet =
691: allocation_maillon(s_etat_processus)) == NULL)
692: {
693: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
694: return;
695: }
696:
697: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
698: .donnee = allocation(s_etat_processus, REL)) == NULL)
699: {
700: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
701: return;
702: }
703:
704: (*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
705: .objet)).donnee)).objet)) = (*s_etat_processus).y_min;
706:
707: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
708: .suivant = allocation_maillon(s_etat_processus)) == NULL)
709: {
710: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
711: return;
712: }
713:
714: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
715: .suivant).suivant = NULL;
716:
717: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
718: .suivant).donnee = allocation(s_etat_processus, REL))
719: == NULL)
720: {
721: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
722: return;
723: }
724:
725: (*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base)
726: .donnee).objet)).suivant).donnee)).objet)) =
727: (*s_etat_processus).y_max;
728: }
729:
730: (*l_nouvelle_base).suivant = l_ancienne_base;
731: (*s_objet_resultat).objet = l_nouvelle_base;
732: l_ancienne_base = (*s_objet_resultat).objet;
733:
734: // Coordonnées X
735:
736: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
737: {
738: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
739: return;
740: }
741:
742: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
743: == NULL)
744: {
745: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
746: return;
747: }
748:
749: if ((*s_etat_processus).echelle_automatique_x == d_vrai)
750: {
751: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
752: sizeof(unsigned char))) == NULL)
753: {
754: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
755: return;
756: }
757:
758: (*(*l_nouvelle_base).donnee).type = CHN;
759: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
760: "AUTOMATIC");
761: }
762: else
763: {
764: (*(*l_nouvelle_base).donnee).type = LST;
765:
766: if (((*(*l_nouvelle_base).donnee).objet =
767: allocation_maillon(s_etat_processus)) == NULL)
768: {
769: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
770: return;
771: }
772:
773: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
774: .donnee = allocation(s_etat_processus, REL)) == NULL)
775: {
776: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
777: return;
778: }
779:
780: (*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
781: .objet)).donnee)).objet)) = (*s_etat_processus).x_min;
782:
783: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
784: .suivant = allocation_maillon(s_etat_processus)) == NULL)
785: {
786: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
787: return;
788: }
789:
790: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
791: .suivant).suivant = NULL;
792:
793: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
794: .suivant).donnee = allocation(s_etat_processus, REL))
795: == NULL)
796: {
797: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
798: return;
799: }
800:
801: (*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base)
802: .donnee).objet)).suivant).donnee)).objet)) =
803: (*s_etat_processus).x_max;
804: }
805:
806: (*l_nouvelle_base).suivant = l_ancienne_base;
807: (*s_objet_resultat).objet = l_nouvelle_base;
808:
809: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
810: s_objet_resultat) == d_erreur)
811: {
812: return;
813: }
814:
815: return;
816: }
817:
818:
819: /*
820: ================================================================================
821: Fonction 'plotter' (passe en mode d'affichage relié)
822: ================================================================================
823: Entrées : structure processus
824: --------------------------------------------------------------------------------
825: Sorties :
826: --------------------------------------------------------------------------------
827: Effets de bord : néant
828: ================================================================================
829: */
830:
831: void
832: instruction_plotter(struct_processus *s_etat_processus)
833: {
834: (*s_etat_processus).erreur_execution = d_ex;
835:
836: if ((*s_etat_processus).affichage_arguments == 'Y')
837: {
838: printf("\n PLOTTER ");
839:
840: if ((*s_etat_processus).langue == 'F')
841: {
842: printf("(nuage de points reliés entre eux)\n\n");
843: printf(" Aucun argument\n");
844: }
845: else
846: {
847: printf("(plotter mode)\n\n");
848: printf(" No argument\n");
849: }
850:
851: return;
852: }
853: else if ((*s_etat_processus).test_instruction == 'Y')
854: {
855: (*s_etat_processus).nombre_arguments = -1;
856: return;
857: }
858:
859: strcpy((*s_etat_processus).type_trace_sigma, "TABLE TRACANTE");
860:
861: return;
862: }
863:
864:
865: /*
866: ================================================================================
867: Fonction 'paper'
868: ================================================================================
869: Entrées :
870: --------------------------------------------------------------------------------
871: Sorties :
872: --------------------------------------------------------------------------------
873: Effets de bord : néant
874: ================================================================================
875: */
876:
877: void
878: instruction_paper(struct_processus *s_etat_processus)
879: {
880: struct_objet *s_objet_argument;
881:
882: unsigned char *tampon;
883:
884: (*s_etat_processus).erreur_execution = d_ex;
885:
886: if ((*s_etat_processus).affichage_arguments == 'Y')
887: {
888: printf("\n PAPER ");
889:
890: if ((*s_etat_processus).langue == 'F')
891: {
892: printf("(format de papier)\n\n");
893: }
894: else
895: {
896: printf("(paper format)\n\n");
897: }
898:
899: printf(" 1: %s\n\n", d_CHN);
900:
901: if ((*s_etat_processus).langue == 'F')
902: {
903: printf(" Formats :\n\n");
904: }
905: else
906: {
907: printf(" Format:\n\n");
908: }
909:
910: printf(" A4, A5, B5, EXECUTIVE, LETTER, LEGAL\n");
911:
912: return;
913: }
914: else if ((*s_etat_processus).test_instruction == 'Y')
915: {
916: (*s_etat_processus).nombre_arguments = -1;
917: return;
918: }
919:
920: if (test_cfsf(s_etat_processus, 31) == d_vrai)
921: {
922: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
923: {
924: return;
925: }
926: }
927:
928: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
929: &s_objet_argument) == d_erreur)
930: {
931: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
932: return;
933: }
934:
935: if ((*s_objet_argument).type == CHN)
936: {
937: if ((tampon = conversion_majuscule(s_etat_processus, (unsigned char *)
938: (*s_objet_argument).objet)) == NULL)
939:
940: {
941: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
942: return;
943: }
944:
945: if (strcmp(tampon, "A4") == 0)
946: {
947: strcpy((*s_etat_processus).format_papier, "a4paper");
948: }
949: else if (strcmp(tampon, "A5") == 0)
950: {
951: strcpy((*s_etat_processus).format_papier, "a5paper");
952: }
953: else if (strcmp(tampon, "B5") == 0)
954: {
955: strcpy((*s_etat_processus).format_papier, "b5paper");
956: }
957: else if (strcmp(tampon, "LETTER") == 0)
958: {
959: strcpy((*s_etat_processus).format_papier, "letterpaper");
960: }
961: else if (strcmp(tampon, "LEGAL") == 0)
962: {
963: strcpy((*s_etat_processus).format_papier, "legalpaper");
964: }
965: else if (strcmp(tampon, "EXECUTIVE") == 0)
966: {
967: strcpy((*s_etat_processus).format_papier, "executivepaper");
968: }
969: else
970: {
971: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
972: }
973:
974: free(tampon);
975: }
976: else
977: {
978: liberation(s_etat_processus, s_objet_argument);
979:
980: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
981: return;
982: }
983:
984: liberation(s_etat_processus, s_objet_argument);
985:
986: return;
987: }
988:
989: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_p6.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src