Annotation of rpl/src/instructions_e3.c, revision 1.11
1.1 bertrand 1: /*
2: ================================================================================
1.10 bertrand 3: RPL/2 (R) version 4.0.18
1.1 bertrand 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:
1.11 ! bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction '='
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_egalite(struct_processus *s_etat_processus)
40: {
41: struct_liste_chainee *l_element_courant;
42: struct_liste_chainee *l_element_precedent;
43:
44: struct_objet *s_copie_argument_1;
45: struct_objet *s_copie_argument_2;
46: struct_objet *s_objet_argument_1;
47: struct_objet *s_objet_argument_2;
48: struct_objet *s_objet_resultat;
49:
50: unsigned long nombre_egalites;
51: unsigned long nombre_elements;
52:
53: (*s_etat_processus).erreur_execution = d_ex;
54:
55: if ((*s_etat_processus).affichage_arguments == 'Y')
56: {
57: printf("\n = ");
58:
59: if ((*s_etat_processus).langue == 'F')
60: {
61: printf("(égalité algébrique)\n\n");
62: }
63: else
64: {
65: printf("(algebraic equality)\n\n");
66: }
67:
68: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_INT, d_REL, d_CPL);
69: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_INT, d_REL, d_CPL);
70: printf("-> 1: %s\n\n", d_ALG);
71:
72: printf(" 2: %s\n", d_ALG);
73: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_INT, d_REL, d_CPL);
74: printf("-> 1: %s\n\n", d_ALG);
75:
76: printf(" 2: %s\n", d_RPN);
77: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_INT, d_REL, d_CPL);
78: printf("-> 1: %s\n\n", d_RPN);
79:
80: printf(" 2: %s, %s, %s, %s, %s\n", d_ALG, d_NOM, d_INT,
81: d_REL, d_CPL);
82: printf(" 1: %s\n", d_ALG);
83: printf("-> 1: %s\n\n", d_ALG);
84:
85: printf(" 2: %s, %s, %s, %s, %s\n", d_RPN, d_NOM, d_INT,
86: d_REL, d_CPL);
87: printf(" 1: %s\n", d_RPN);
88: printf("-> 1: %s\n", d_RPN);
89:
90: return;
91: }
92: else if ((*s_etat_processus).test_instruction == 'Y')
93: {
94: (*s_etat_processus).nombre_arguments = 0;
95: return;
96: }
97:
98: if (test_cfsf(s_etat_processus, 31) == d_vrai)
99: {
100: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
101: {
102: return;
103: }
104: }
105:
106: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
107: &s_objet_argument_1) == d_erreur)
108: {
109: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
110: return;
111: }
112:
113: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
114: &s_objet_argument_2) == d_erreur)
115: {
116: liberation(s_etat_processus, s_objet_argument_1);
117:
118: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
119: return;
120: }
121:
122: /*
123: * Nom ou valeur numérique / Nom ou valeur numérique
124: */
125:
126: if ((((*s_objet_argument_1).type == NOM) ||
127: ((*s_objet_argument_1).type == INT) ||
128: ((*s_objet_argument_1).type == REL) ||
129: ((*s_objet_argument_1).type == CPL)) &&
130: (((*s_objet_argument_2).type == NOM) ||
131: ((*s_objet_argument_2).type == INT) ||
132: ((*s_objet_argument_2).type == REL) ||
133: ((*s_objet_argument_2).type == CPL)))
134: {
135: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
136: {
137: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
138: return;
139: }
140:
141: if (((*s_objet_resultat).objet =
142: allocation_maillon(s_etat_processus)) == NULL)
143: {
144: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
145: return;
146: }
147:
148: l_element_courant = (*s_objet_resultat).objet;
149:
150: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
151: == NULL)
152: {
153: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
154: return;
155: }
156:
157: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
158: .nombre_arguments = 0;
159: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
160: .fonction = instruction_vers_niveau_superieur;
161:
162: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
163: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
164: {
165: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
166: return;
167: }
168:
169: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
170: .nom_fonction, "<<");
171:
172: if (((*l_element_courant).suivant =
173: allocation_maillon(s_etat_processus)) == NULL)
174: {
175: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
176: return;
177: }
178:
179: l_element_courant = (*l_element_courant).suivant;
180: (*l_element_courant).donnee = s_objet_argument_2;
181:
182: if (((*l_element_courant).suivant =
183: allocation_maillon(s_etat_processus)) == NULL)
184: {
185: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
186: return;
187: }
188:
189: l_element_courant = (*l_element_courant).suivant;
190: (*l_element_courant).donnee = s_objet_argument_1;
191:
192: if (((*l_element_courant).suivant =
193: allocation_maillon(s_etat_processus)) == NULL)
194: {
195: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
196: return;
197: }
198:
199: l_element_courant = (*l_element_courant).suivant;
200:
201: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
202: == NULL)
203: {
204: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
205: return;
206: }
207:
208: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
209: .nombre_arguments = 0;
210: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
211: .fonction = instruction_egalite;
212:
213: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
214: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL)
215: {
216: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
217: return;
218: }
219:
220: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
221: .nom_fonction, "=");
222:
223: if (((*l_element_courant).suivant =
224: allocation_maillon(s_etat_processus)) == NULL)
225: {
226: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
227: return;
228: }
229:
230: l_element_courant = (*l_element_courant).suivant;
231:
232: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
233: == NULL)
234: {
235: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
236: return;
237: }
238:
239: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
240: .nombre_arguments = 0;
241: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
242: .fonction = instruction_vers_niveau_inferieur;
243:
244: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
245: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
246: {
247: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
248: return;
249: }
250:
251: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
252: .nom_fonction, ">>");
253:
254: (*l_element_courant).suivant = NULL;
255:
256: s_objet_argument_1 = NULL;
257: s_objet_argument_2 = NULL;
258: }
259:
260: /*
261: * Nom ou valeur numérique / Expression
262: */
263:
264: else if ((((*s_objet_argument_1).type == ALG) ||
265: ((*s_objet_argument_1).type == RPN)) &&
266: (((*s_objet_argument_2).type == NOM) ||
267: ((*s_objet_argument_2).type == INT) ||
268: ((*s_objet_argument_2).type == REL) ||
269: ((*s_objet_argument_2).type == CPL)))
270: {
271: nombre_elements = 0;
272: l_element_courant = (struct_liste_chainee *)
273: (*s_objet_argument_1).objet;
274:
275: while(l_element_courant != NULL)
276: {
277: nombre_elements++;
278: l_element_courant = (*l_element_courant).suivant;
279: }
280:
281: if (nombre_elements == 2)
282: {
283: liberation(s_etat_processus, s_objet_argument_1);
284: liberation(s_etat_processus, s_objet_argument_2);
285:
286: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
287: return;
288: }
289:
290: if ((s_objet_resultat = copie_objet(s_etat_processus,
291: s_objet_argument_1, 'N')) == NULL)
292: {
293: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
294: return;
295: }
296:
297: l_element_courant = (struct_liste_chainee *)
298: (*s_objet_resultat).objet;
299: l_element_precedent = l_element_courant;
300: l_element_courant = (*l_element_courant).suivant;
301:
302: if (((*l_element_precedent).suivant =
303: allocation_maillon(s_etat_processus)) == NULL)
304: {
305: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
306: return;
307: }
308:
309: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
310: (*(*l_element_precedent).suivant).suivant = l_element_courant;
311:
312: while((*l_element_courant).suivant != NULL)
313: {
314: l_element_precedent = l_element_courant;
315: l_element_courant = (*l_element_courant).suivant;
316: }
317:
318: if (((*l_element_precedent).suivant =
319: allocation_maillon(s_etat_processus)) == NULL)
320: {
321: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
322: return;
323: }
324:
325: if (((*(*l_element_precedent).suivant).donnee =
326: allocation(s_etat_processus, FCT)) == NULL)
327: {
328: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
329: return;
330: }
331:
332: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
333: .donnee).objet)).nombre_arguments = 0;
334: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
335: .donnee).objet)).fonction = instruction_egalite;
336:
337: if (((*((struct_fonction *) (*(*(*l_element_precedent)
338: .suivant).donnee).objet)).nom_fonction =
339: malloc(2 * sizeof(unsigned char))) == NULL)
340: {
341: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
342: return;
343: }
344:
345: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
346: .suivant).donnee).objet)).nom_fonction, "=");
347:
348: (*(*l_element_precedent).suivant).suivant = l_element_courant;
349:
350: s_objet_argument_2 = NULL;
351: }
352:
353: /*
354: * Expression / Nom ou valeur numérique
355: */
356:
357: else if ((((*s_objet_argument_1).type == NOM) ||
358: ((*s_objet_argument_1).type == INT) ||
359: ((*s_objet_argument_1).type == REL) ||
360: ((*s_objet_argument_1).type == CPL)) &&
361: (((*s_objet_argument_2).type == ALG) ||
362: ((*s_objet_argument_2).type == RPN)))
363: {
364: nombre_elements = 0;
365: l_element_courant = (struct_liste_chainee *)
366: (*s_objet_argument_2).objet;
367:
368: while(l_element_courant != NULL)
369: {
370: nombre_elements++;
371: l_element_courant = (*l_element_courant).suivant;
372: }
373:
374: if (nombre_elements == 2)
375: {
376: liberation(s_etat_processus, s_objet_argument_1);
377: liberation(s_etat_processus, s_objet_argument_2);
378:
379: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
380: return;
381: }
382:
383: if ((s_objet_resultat = copie_objet(s_etat_processus,
384: s_objet_argument_2, 'N')) == NULL)
385: {
386: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
387: return;
388: }
389:
390: l_element_courant = (struct_liste_chainee *)
391: (*s_objet_resultat).objet;
392: l_element_precedent = l_element_courant;
393:
394: while((*l_element_courant).suivant != NULL)
395: {
396: l_element_precedent = l_element_courant;
397: l_element_courant = (*l_element_courant).suivant;
398: }
399:
400: if (((*l_element_precedent).suivant =
401: allocation_maillon(s_etat_processus)) == NULL)
402: {
403: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
404: return;
405: }
406:
407: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
408: l_element_precedent = (*l_element_precedent).suivant;
409:
410: if (((*l_element_precedent).suivant =
411: allocation_maillon(s_etat_processus)) == NULL)
412: {
413: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
414: return;
415: }
416:
417: if (((*(*l_element_precedent).suivant).donnee =
418: allocation(s_etat_processus, FCT)) == NULL)
419: {
420: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
421: return;
422: }
423:
424: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
425: .donnee).objet)).nombre_arguments = 0;
426: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
427: .donnee).objet)).fonction = instruction_egalite;
428:
429: if (((*((struct_fonction *) (*(*(*l_element_precedent)
430: .suivant).donnee).objet)).nom_fonction =
431: malloc(2 * sizeof(unsigned char))) == NULL)
432: {
433: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
434: return;
435: }
436:
437: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
438: .suivant).donnee).objet)).nom_fonction, "=");
439:
440: (*(*l_element_precedent).suivant).suivant = l_element_courant;
441:
442: s_objet_argument_1 = NULL;
443: }
444:
445: /*
446: * Expression / Expression
447: */
448:
449: else if ((((*s_objet_argument_1).type == ALG) &&
450: ((*s_objet_argument_2).type == ALG)) ||
451: (((*s_objet_argument_1).type == RPN) &&
452: ((*s_objet_argument_2).type == RPN)))
453: {
454: nombre_elements = 0;
455: l_element_courant = (struct_liste_chainee *)
456: (*s_objet_argument_1).objet;
457:
458: while(l_element_courant != NULL)
459: {
460: nombre_elements++;
461: l_element_courant = (*l_element_courant).suivant;
462: }
463:
464: if (nombre_elements == 2)
465: {
466: liberation(s_etat_processus, s_objet_argument_1);
467: liberation(s_etat_processus, s_objet_argument_2);
468:
469: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
470: return;
471: }
472:
473: nombre_elements = 0;
474: l_element_courant = (struct_liste_chainee *)
475: (*s_objet_argument_2).objet;
476:
477: while(l_element_courant != NULL)
478: {
479: nombre_elements++;
480: l_element_courant = (*l_element_courant).suivant;
481: }
482:
483: if (nombre_elements == 2)
484: {
485: liberation(s_etat_processus, s_objet_argument_1);
486: liberation(s_etat_processus, s_objet_argument_2);
487:
488: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
489: return;
490: }
491:
492: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
493: s_objet_argument_1, 'N')) == NULL)
494: {
495: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
496: return;
497: }
498:
499: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
500: s_objet_argument_2, 'N')) == NULL)
501: {
502: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
503: return;
504: }
505:
506: l_element_courant = (struct_liste_chainee *)
507: (*s_copie_argument_1).objet;
508: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
509: (*s_copie_argument_1).objet)).suivant;
510:
511: liberation(s_etat_processus, (*l_element_courant).donnee);
512: free(l_element_courant);
513:
514: l_element_courant = (struct_liste_chainee *)
515: (*s_copie_argument_2).objet;
516: l_element_precedent = l_element_courant;
517: s_objet_resultat = s_copie_argument_2;
518:
519: while((*l_element_courant).suivant != NULL)
520: {
521: l_element_precedent = l_element_courant;
522: l_element_courant = (*l_element_courant).suivant;
523: }
524:
525: liberation(s_etat_processus, (*l_element_courant).donnee);
526: free(l_element_courant);
527:
528: (*l_element_precedent).suivant = (struct_liste_chainee *)
529: (*s_copie_argument_1).objet;
530: free(s_copie_argument_1);
531:
532: l_element_courant = (*l_element_precedent).suivant;
533: while((*l_element_courant).suivant != NULL)
534: {
535: l_element_precedent = l_element_courant;
536: l_element_courant = (*l_element_courant).suivant;
537: }
538:
539: if (((*l_element_precedent).suivant =
540: allocation_maillon(s_etat_processus)) == NULL)
541: {
542: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
543: return;
544: }
545:
546: (*(*l_element_precedent).suivant).suivant = l_element_courant;
547: l_element_courant = (*l_element_precedent).suivant;
548:
549: if (((*l_element_courant).donnee =
550: allocation(s_etat_processus, FCT)) == NULL)
551: {
552: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
553: return;
554: }
555:
556: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
557: .nombre_arguments = 0;
558: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
559: .fonction = instruction_egalite;
560:
561: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
562: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL)
563: {
564: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
565: return;
566: }
567:
568: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
569: .nom_fonction, "=");
570: }
571: else
572: {
573: liberation(s_etat_processus, s_objet_argument_1);
574: liberation(s_etat_processus, s_objet_argument_2);
575:
576: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
577: return;
578: }
579:
580: liberation(s_etat_processus, s_objet_argument_1);
581: liberation(s_etat_processus, s_objet_argument_2);
582:
583: /*
584: * Vérification du nombre d'égalités dans l'expression
585: */
586:
587: l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet;
588: nombre_egalites = 0;
589:
590: while(l_element_courant != NULL)
591: {
592: if ((*(*l_element_courant).donnee).type == FCT)
593: {
594: if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee)
595: .objet)).nom_fonction, "=") == 0)
596: {
597: nombre_egalites++;
598: }
599: }
600:
601: l_element_courant = (*l_element_courant).suivant;
602: }
603:
604: if (nombre_egalites != 1)
605: {
606: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
607:
608: liberation(s_etat_processus, s_objet_resultat);
609: return;
610: }
611:
612: /*
613: * Empilement du résultat
614: */
615:
616: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
617: s_objet_resultat) == d_erreur)
618: {
619: return;
620: }
621:
622: return;
623: }
624:
625:
626: /*
627: ================================================================================
628: Fonction 'eyept'
629: ================================================================================
630: Entrées : pointeur sur une structure struct_processus
631: --------------------------------------------------------------------------------
632: Sorties :
633: --------------------------------------------------------------------------------
634: Effets de bord : néant
635: ================================================================================
636: */
637:
638: void
639: instruction_eyept(struct_processus *s_etat_processus)
640: {
641: double deux_pi;
642:
643: long nombre_arguments;
644:
645: struct_liste_chainee *l_element_courant;
646:
647: struct_objet *s_objet_argument;
648: struct_objet *s_objet_auxiliaire;
649:
650: (*s_etat_processus).erreur_execution = d_ex;
651:
652: if ((*s_etat_processus).affichage_arguments == 'Y')
653: {
654: printf("\n EYEPT ");
655:
656: if ((*s_etat_processus).langue == 'F')
657: {
658: printf("(point de vue)\n\n");
659: }
660: else
661: {
662: printf("(eye point)\n\n");
663: }
664:
665: printf(" 1: %s\n\n", d_LST);
666:
667: if ((*s_etat_processus).langue == 'F')
668: {
669: printf(" Utilisation :\n\n");
670: }
671: else
672: {
673: printf(" Usage:\n\n");
674: }
675:
676: printf(" { theta phi scale } EYEPT\n");
677:
678: return;
679: }
680: else if ((*s_etat_processus).test_instruction == 'Y')
681: {
682: (*s_etat_processus).nombre_arguments = -1;
683: return;
684: }
685:
686: if (test_cfsf(s_etat_processus, 31) == d_vrai)
687: {
688: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
689: {
690: return;
691: }
692: }
693:
694: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
695: &s_objet_argument) == d_erreur)
696: {
697: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
698: return;
699: }
700:
701: if ((*s_objet_argument).type == LST)
702: {
703: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
704: nombre_arguments = 0;
705:
706: while(l_element_courant != NULL)
707: {
708: nombre_arguments++;
709: l_element_courant = (*l_element_courant).suivant;
710: }
711:
712: if ((nombre_arguments != 2) && (nombre_arguments != 3))
713: {
714: liberation(s_etat_processus, s_objet_argument);
715:
716: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
717: return;
718: }
719:
720: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
721: nombre_arguments = 0;
722:
723: while(l_element_courant != NULL)
724: {
725: nombre_arguments++;
726:
727: if (((*(*l_element_courant).donnee).type == RPN) ||
728: ((*(*l_element_courant).donnee).type == ALG) ||
729: ((*(*l_element_courant).donnee).type == NOM))
730: {
731: if (evaluation(s_etat_processus,
732: (*l_element_courant).donnee, 'N') == d_erreur)
733: {
734: liberation(s_etat_processus, s_objet_argument);
735:
736: return;
737: }
738:
739: if (depilement(s_etat_processus,
740: &((*s_etat_processus).l_base_pile),
741: &s_objet_auxiliaire) == d_erreur)
742: {
743: liberation(s_etat_processus, s_objet_argument);
744:
745: (*s_etat_processus).erreur_execution =
746: d_ex_manque_argument;
747:
748: return;
749: }
750:
751: liberation(s_etat_processus, (*l_element_courant).donnee);
752: (*l_element_courant).donnee = s_objet_auxiliaire;
753: }
754:
755: if ((*(*l_element_courant).donnee).type == INT)
756: {
757: switch(nombre_arguments)
758: {
759: case 1 :
760: {
761: (*s_etat_processus).point_de_vue_theta = (real8)
762: (*((integer8 *) (*(*l_element_courant).donnee)
763: .objet));
764: break;
765: }
766:
767: case 2 :
768: {
769: (*s_etat_processus).point_de_vue_phi = (real8)
770: (*((integer8 *) (*(*l_element_courant).donnee)
771: .objet));
772: break;
773: }
774:
775: case 3 :
776: {
777: if ((*((integer8 *) (*(*l_element_courant).donnee)
778: .objet)) <= 0)
779: {
780: liberation(s_etat_processus, s_objet_argument);
781:
782: (*s_etat_processus).erreur_execution =
783: d_ex_argument_invalide;
784: return;
785: }
786:
787: (*s_etat_processus).echelle_3D = (real8) (*((integer8 *)
788: (*(*l_element_courant).donnee).objet));
789: break;
790: }
791: }
792: }
793: else if ((*(*l_element_courant).donnee).type == REL)
794: {
795: switch(nombre_arguments)
796: {
797: case 1 :
798: {
799: (*s_etat_processus).point_de_vue_theta =
800: (*((real8 *) (*(*l_element_courant).donnee)
801: .objet));
802: break;
803: }
804:
805: case 2 :
806: {
807: (*s_etat_processus).point_de_vue_phi =
808: (*((real8 *) (*(*l_element_courant).donnee)
809: .objet));
810: break;
811: }
812:
813: case 3 :
814: {
815: if ((*((real8 *) (*(*l_element_courant).donnee)
816: .objet)) <= 0)
817: {
818: liberation(s_etat_processus, s_objet_argument);
819:
820: (*s_etat_processus).erreur_execution =
821: d_ex_argument_invalide;
822: return;
823: }
824:
825: (*s_etat_processus).echelle_3D = (*((real8 *)
826: (*(*l_element_courant).donnee).objet));
827: break;
828: }
829: }
830: }
831: else
832: {
833: liberation(s_etat_processus, s_objet_argument);
834:
835: (*s_etat_processus).erreur_execution =
836: d_ex_erreur_type_argument;
837: return;
838: }
839:
840: l_element_courant = (*l_element_courant).suivant;
841: }
842:
843: if (test_cfsf(s_etat_processus, 60) == d_faux)
844: {
845: conversion_degres_vers_radians(&((*s_etat_processus)
846: .point_de_vue_theta));
847: conversion_degres_vers_radians(&((*s_etat_processus)
848: .point_de_vue_phi));
849: }
850:
851: deux_pi = 8 * atan((real8) 1);
852:
853: (*s_etat_processus).point_de_vue_theta =
854: (*s_etat_processus).point_de_vue_theta - (deux_pi *
855: floor((*s_etat_processus).point_de_vue_theta / deux_pi));
856: (*s_etat_processus).point_de_vue_phi =
857: (*s_etat_processus).point_de_vue_phi - (deux_pi *
858: floor((*s_etat_processus).point_de_vue_phi / deux_pi));
859:
860: if ((*s_etat_processus).point_de_vue_phi > deux_pi)
861: {
862: (*s_etat_processus).point_de_vue_phi = deux_pi -
863: (*s_etat_processus).point_de_vue_phi;
864: (*s_etat_processus).point_de_vue_theta += (deux_pi / 2);
865: (*s_etat_processus).point_de_vue_theta =
866: (*s_etat_processus).point_de_vue_theta - (deux_pi *
867: floor((*s_etat_processus).point_de_vue_theta / deux_pi));
868: }
869: }
870: else
871: {
872: liberation(s_etat_processus, s_objet_argument);
873:
874: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
875: return;
876: }
877:
878: liberation(s_etat_processus, s_objet_argument);
879:
880: if (test_cfsf(s_etat_processus, 52) == d_faux)
881: {
882: if ((*s_etat_processus).fichiers_graphiques != NULL)
883: {
884: appel_gnuplot(s_etat_processus, 'N');
885: }
886: }
887:
888: return;
889: }
890:
891: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_e3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src