![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_a4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_a4.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.15 ! bertrand 3: RPL/2 (R) version 4.0.20
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.12 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'autoscale'
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_autoscale(struct_processus *s_etat_processus)
40: {
41: logical1 presence[3];
42:
43: struct_liste_chainee *l_element_courant;
44:
45: struct_objet *s_objet;
46:
47: unsigned char *tampon;
48:
49: (*s_etat_processus).erreur_execution = d_ex;
50:
51: if ((*s_etat_processus).affichage_arguments == 'Y')
52: {
53: printf("\n AUTOSCALE ");
54:
55: if ((*s_etat_processus).langue == 'F')
56: {
57: printf("(échelles automatiques)\n\n");
58: }
59: else
60: {
61: printf("(automatic scales)\n\n");
62: }
63:
64: printf(" 1: %s\n\n", d_NOM);
65:
66: printf(" 1: %s\n\n", d_LST);
67:
68: if ((*s_etat_processus).langue == 'F')
69: {
70: printf(" Utilisation :\n\n");
71: }
72: else
73: {
74: printf(" Usage:\n\n");
75: }
76:
77: printf(" { X Y } AUTOSCALE\n");
78: printf(" { } AUTOSCALE\n");
79: printf(" 'Z' AUTOSCALE\n");
80:
81: return;
82: }
83: else if ((*s_etat_processus).test_instruction == 'Y')
84: {
85: (*s_etat_processus).nombre_arguments = -1;
86: return;
87: }
88:
89: if (test_cfsf(s_etat_processus, 31) == d_vrai)
90: {
91: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
92: {
93: return;
94: }
95: }
96:
97: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
98: &s_objet) == d_erreur)
99: {
100: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
101: return;
102: }
103:
104: if ((*s_etat_processus).systeme_axes == 0)
105: {
106: (*s_etat_processus).echelle_automatique_x = d_faux;
107: (*s_etat_processus).echelle_automatique_y = d_faux;
108: (*s_etat_processus).echelle_automatique_z = d_faux;
109: }
110: else
111: {
112: (*s_etat_processus).echelle_automatique_x2 = d_faux;
113: (*s_etat_processus).echelle_automatique_y2 = d_faux;
114: (*s_etat_processus).echelle_automatique_z2 = d_faux;
115: }
116:
117: if ((*s_objet).type == NOM)
118: {
119: tampon = conversion_majuscule((*((struct_nom *) (*s_objet).objet)).nom);
120:
121: if (tampon == NULL)
122: {
123: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
124: return;
125: }
126:
127: if ((strcmp(tampon, "X") != 0) && (strcmp(tampon, "Y")!= 0) &&
128: (strcmp(tampon, "Z")!= 0))
129: {
130: liberation(s_etat_processus, s_objet);
131: free(tampon);
132:
133: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
134: return;
135: }
136:
137: if (tampon[0] == 'X')
138: {
139: if ((*s_etat_processus).systeme_axes == 0)
140: {
141: (*s_etat_processus).echelle_automatique_x = d_vrai;
142: }
143: else
144: {
145: (*s_etat_processus).echelle_automatique_x2 = d_vrai;
146: }
147: }
148: else if (tampon[0] == 'Y')
149: {
150: if ((*s_etat_processus).systeme_axes == 0)
151: {
152: (*s_etat_processus).echelle_automatique_y = d_vrai;
153: }
154: else
155: {
156: (*s_etat_processus).echelle_automatique_y2 = d_vrai;
157: }
158: }
159: else
160: {
161: if ((*s_etat_processus).systeme_axes == 0)
162: {
163: (*s_etat_processus).echelle_automatique_z = d_vrai;
164: }
165: else
166: {
167: (*s_etat_processus).echelle_automatique_z2 = d_vrai;
168: }
169: }
170:
171: free(tampon);
172: }
173: else if ((*s_objet).type == LST)
174: {
175: presence[0] = d_faux;
176: presence[1] = d_faux;
177: presence[2] = d_faux;
178:
179: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
180:
181: while(l_element_courant != NULL)
182: {
183: if ((*(*l_element_courant).donnee).type != NOM)
184: {
185: liberation(s_etat_processus, s_objet);
186:
187: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
188: return;
189: }
190:
191: tampon = conversion_majuscule((*((struct_nom *)
192: (*(*l_element_courant).donnee).objet)).nom);
193:
194: if ((strcmp(tampon, "X") != 0) && (strcmp(tampon, "Y")!= 0) &&
195: (strcmp(tampon, "Z")!= 0))
196: {
197: liberation(s_etat_processus, s_objet);
198: free(tampon);
199:
200: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
201: return;
202: }
203:
204: if (tampon[0] == 'X')
205: {
206: if (presence[0] == d_vrai)
207: {
208: free(tampon);
209: liberation(s_etat_processus, s_objet);
210:
211: (*s_etat_processus).erreur_execution =
212: d_ex_argument_invalide;
213: return;
214: }
215:
216: if ((*s_etat_processus).systeme_axes == 0)
217: {
218: (*s_etat_processus).echelle_automatique_x = d_vrai;
219: }
220: else
221: {
222: (*s_etat_processus).echelle_automatique_x2 = d_vrai;
223: }
224:
225: presence[0] = d_vrai;
226: }
227: else if (tampon[0] == 'Y')
228: {
229: if (presence[1] == d_vrai)
230: {
231: free(tampon);
232: liberation(s_etat_processus, s_objet);
233:
234: (*s_etat_processus).erreur_execution =
235: d_ex_argument_invalide;
236: return;
237: }
238:
239: if ((*s_etat_processus).systeme_axes == 0)
240: {
241: (*s_etat_processus).echelle_automatique_y = d_vrai;
242: }
243: else
244: {
245: (*s_etat_processus).echelle_automatique_y2 = d_vrai;
246: }
247:
248: presence[1] = d_vrai;
249: }
250: else
251: {
252: if (presence[2] == d_vrai)
253: {
254: free(tampon);
255: liberation(s_etat_processus, s_objet);
256:
257: (*s_etat_processus).erreur_execution =
258: d_ex_argument_invalide;
259: return;
260: }
261:
262: if ((*s_etat_processus).systeme_axes == 0)
263: {
264: (*s_etat_processus).echelle_automatique_z = d_vrai;
265: }
266: else
267: {
268: (*s_etat_processus).echelle_automatique_z2 = d_vrai;
269: }
270:
271: presence[2] = d_vrai;
272: }
273:
274: l_element_courant = (*l_element_courant).suivant;
275: free(tampon);
276: }
277: }
278: else
279: {
280: liberation(s_etat_processus, s_objet);
281:
282: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
283: return;
284: }
285:
286: liberation(s_etat_processus, s_objet);
287:
288: if (test_cfsf(s_etat_processus, 52) == d_faux)
289: {
290: if ((*s_etat_processus).fichiers_graphiques != NULL)
291: {
292: appel_gnuplot(s_etat_processus, 'N');
293: }
294: }
295:
296: return;
297: }
298:
299:
300: /*
301: ================================================================================
302: Fonction 'asl'
303: ================================================================================
304: Entrées : pointeur sur une structure struct_processus
305: --------------------------------------------------------------------------------
306: Sorties :
307: --------------------------------------------------------------------------------
308: Effets de bord : néant
309: ================================================================================
310: */
311:
312: void
313: instruction_asl(struct_processus *s_etat_processus)
314: {
315: logical8 masque;
316: logical8 retenue;
317: logical8 tampon;
318:
319: struct_objet *s_copie;
320: struct_objet *s_objet;
321:
322: unsigned long i;
323: unsigned long j;
324: unsigned long longueur;
325:
326: (*s_etat_processus).erreur_execution = d_ex;
327:
328: if ((*s_etat_processus).affichage_arguments == 'Y')
329: {
330: printf("\n ASL ");
331:
332: if ((*s_etat_processus).langue == 'F')
333: {
334: printf("(décalage arithmétique à gauche)\n\n");
335: }
336: else
337: {
338: printf("arithmetic shift left)\n\n");
339: }
340:
341: printf(" 1: %s\n", d_BIN);
342: printf("-> 1: %s\n", d_BIN);
343:
344: return;
345: }
346: else if ((*s_etat_processus).test_instruction == 'Y')
347: {
348: (*s_etat_processus).nombre_arguments = -1;
349: return;
350: }
351:
352: if (test_cfsf(s_etat_processus, 31) == d_vrai)
353: {
354: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
355: {
356: return;
357: }
358: }
359:
360: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
361: &s_objet) == d_erreur)
362: {
363: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
364: return;
365: }
366:
367: if ((*s_objet).type == BIN)
368: {
369: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
370: {
371: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
372: return;
373: }
374:
375: longueur = 1;
376: j = 1;
377:
378: for(i = 37; i <= 42; i++)
379: {
380: longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
381: == d_vrai) ? j : 0;
382: j *= 2;
383: }
384:
385: retenue = (tampon = (*((logical8 *) (*s_copie).objet))) & (logical8) 1;
386: tampon <<= 1;
387:
388: for(masque = 0, i = 1; i < longueur; i++)
389: {
390: masque <<= 1;
391: masque |= (logical8) 1;
392: }
393:
394: masque <<= 1;
395: tampon &= masque;
396: (*((logical8 *) (*s_copie).objet)) = tampon | retenue;
397:
398: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
399: s_copie) == d_erreur)
400: {
401: return;
402: }
403: }
404: else
405: {
406: liberation(s_etat_processus, s_objet);
407:
408: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
409: return;
410: }
411:
412: liberation(s_etat_processus, s_objet);
413:
414: return;
415: }
416:
417:
418: /*
419: ================================================================================
420: Fonction 'asr'
421: ================================================================================
422: Entrées : pointeur sur une structure struct_processus
423: --------------------------------------------------------------------------------
424: Sorties :
425: --------------------------------------------------------------------------------
426: Effets de bord : néant
427: ================================================================================
428: */
429:
430: void
431: instruction_asr(struct_processus *s_etat_processus)
432: {
433: logical8 masque;
434: logical8 tampon;
435:
436: struct_objet *s_copie;
437: struct_objet *s_objet;
438:
439: unsigned long i;
440: unsigned long j;
441: unsigned long longueur;
442:
443: (*s_etat_processus).erreur_execution = d_ex;
444:
445: if ((*s_etat_processus).affichage_arguments == 'Y')
446: {
447: printf("\n ASR ");
448:
449: if ((*s_etat_processus).langue == 'F')
450: {
451: printf("(décalage arithmétique à droite)\n\n");
452: }
453: else
454: {
455: printf("(arithmetic shift right)\n\n");
456: }
457:
458: printf(" 1: %s\n", d_BIN);
459: printf("-> 1: %s\n", d_BIN);
460:
461: return;
462: }
463: else if ((*s_etat_processus).test_instruction == 'Y')
464: {
465: (*s_etat_processus).nombre_arguments = -1;
466: return;
467: }
468:
469: if (test_cfsf(s_etat_processus, 31) == d_vrai)
470: {
471: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
472: {
473: return;
474: }
475: }
476:
477: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
478: &s_objet) == d_erreur)
479: {
480: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
481: return;
482: }
483:
484: if ((*s_objet).type == BIN)
485: {
486: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
487: {
488: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
489: return;
490: }
491:
492: longueur = 1;
493: j = 1;
494:
495: for(i = 37; i <= 42; i++)
496: {
497: longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
498: == d_vrai) ? j : 0;
499: j *= 2;
500: }
501:
502: tampon = (*((logical8 *) (*s_copie).objet));
503: masque = ((logical8) 1) << (longueur - 1);
504:
505: if ((tampon & masque) == 0)
506: {
507: tampon >>= 1;
508: }
509: else
510: {
511: tampon >>= 1;
512: tampon |= masque;
513: }
514:
515: for(masque = 0, i = 0; i < longueur; i++)
516: {
517: masque <<= 1;
518: masque |= 1;
519: }
520:
521: tampon &= masque;
522: (*((logical8 *) (*s_copie).objet)) = tampon;
523:
524: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
525: s_copie) == d_erreur)
526: {
527: return;
528: }
529: }
530: else
531: {
532: liberation(s_etat_processus, s_objet);
533:
534: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
535: return;
536: }
537:
538: liberation(s_etat_processus, s_objet);
539:
540: return;
541: }
542:
543:
544: /*
545: ================================================================================
546: Fonction 'append'
547: ================================================================================
548: Entrées : pointeur sur une structure struct_processus
549: --------------------------------------------------------------------------------
550: Sorties :
551: --------------------------------------------------------------------------------
552: Effets de bord : néant
553: ================================================================================
554: */
555:
556: void
557: instruction_append(struct_processus *s_etat_processus)
558: {
1.5 bertrand 559: struct_descripteur_fichier *descripteur;
1.1 bertrand 560:
561: struct_objet *s_objet_argument;
562:
563: (*s_etat_processus).erreur_execution = d_ex;
564:
565: if ((*s_etat_processus).affichage_arguments == 'Y')
566: {
567: printf("\n APPEND ");
568:
569: if ((*s_etat_processus).langue == 'F')
570: {
571: printf("(positionnement à la fin du fichier)\n\n");
572: }
573: else
574: {
575: printf("(to reach the end of the file)\n\n");
576: }
577:
578: printf(" 1: %s\n", d_FCH);
579:
580: return;
581: }
582: else if ((*s_etat_processus).test_instruction == 'Y')
583: {
584: (*s_etat_processus).nombre_arguments = -1;
585: return;
586: }
587:
588: if (test_cfsf(s_etat_processus, 31) == d_vrai)
589: {
590: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
591: {
592: return;
593: }
594: }
595:
596: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
597: &s_objet_argument) == d_erreur)
598: {
599: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
600: return;
601: }
602:
603: if ((*s_objet_argument).type == FCH)
604: {
605: if ((descripteur = descripteur_fichier(s_etat_processus,
606: (struct_fichier *) (*s_objet_argument).objet)) == NULL)
607: {
608: liberation(s_etat_processus, s_objet_argument);
609: return;
610: }
611:
1.5 bertrand 612: if ((*descripteur).type == 'C')
613: {
614: if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END) != 0)
615: {
616: liberation(s_etat_processus, s_objet_argument);
617:
618: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
619: return;
620: }
621: }
622: else
1.1 bertrand 623: {
624: liberation(s_etat_processus, s_objet_argument);
625:
1.5 bertrand 626: (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
1.1 bertrand 627: return;
628: }
629: }
630: else
631: {
632: liberation(s_etat_processus, s_objet_argument);
633:
634: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
635: return;
636: }
637:
638: liberation(s_etat_processus, s_objet_argument);
639:
640: return;
641: }
642:
643:
644: /*
645: ================================================================================
646: Fonction 'axes'
647: ================================================================================
648: Entrées : pointeur sur une structure struct_processus
649: --------------------------------------------------------------------------------
650: Sorties :
651: --------------------------------------------------------------------------------
652: Effets de bord : néant
653: ================================================================================
654: */
655:
656: void
657: instruction_axes(struct_processus *s_etat_processus)
658: {
659: /*
660: * Prend comme argument une liste
661: */
662:
663: logical1 autorisation_trace;
664: logical1 axes_principaux;
665: logical1 presence_type;
666:
667: long nombre_arguments_principaux;
668: long nombre_arguments_auxiliaires;
669:
670: struct_liste_chainee *l_element_courant;
671: struct_liste_chainee *l_element_courant_auxiliaire;
672:
673: struct_objet *s_objet_argument;
674: struct_objet *s_objet_auxiliaire;
675:
676: unsigned char *tampon;
677:
678: (*s_etat_processus).erreur_execution = d_ex;
679:
680: if ((*s_etat_processus).affichage_arguments == 'Y')
681: {
682: printf("\n AXES ");
683:
684: if ((*s_etat_processus).langue == 'F')
685: {
686: printf("(définition des axes)\n\n");
687: }
688: else
689: {
690: printf("(axes definition)\n\n");
691: }
692:
693: printf(" 1: %s\n\n", d_LST);
694:
695: if ((*s_etat_processus).langue == 'F')
696: {
697: printf(" Utilisation :\n\n");
698: }
699: else
700: {
701: printf(" Usage:\n\n");
702: }
703:
704: printf(" { \"MAIN\" } AXES\n");
705: printf(" { \"AUXILIARY\" } AXES\n");
706: printf(" { \"MAIN\" { (expression 1) (expression 2) }\n");
707: printf(" { (expression 3) TICSONLY } } AXES\n\n");
708: printf(" { \"MAIN\" { (expression 1) \"TICSONLY\" }\n");
709: printf(" { (expression 2) } } AXES\n\n");
710: printf(" { \"AUXILIARY\" { \"AUTOMATIC\" }\n");
711: printf(" { \"TICSONLY\" \"AUTOMATIC\" } } AXES\n\n");
712: printf(" { { (expression 1) \"DEFAULT\" } { \"AUTOMATIC\" } }\n");
713: printf(" { \"TICSONLY\" (expression 2) } } AXES\n");
714:
715: return;
716: }
717: else if ((*s_etat_processus).test_instruction == 'Y')
718: {
719: (*s_etat_processus).nombre_arguments = -1;
720: return;
721: }
722:
723: if (test_cfsf(s_etat_processus, 31) == d_vrai)
724: {
725: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
726: {
727: return;
728: }
729: }
730:
731: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
732: &s_objet_argument) == d_erreur)
733: {
734: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
735: return;
736: }
737:
738: if ((*s_objet_argument).type == LST)
739: {
740: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
741: nombre_arguments_principaux = 0;
742: presence_type = d_faux;
743: tampon = NULL;
744:
745: while(l_element_courant != NULL)
746: {
747: if ((*(*l_element_courant).donnee).type == CHN)
748: {
749: if (presence_type == d_vrai)
750: {
751: free(tampon);
752:
753: liberation(s_etat_processus, s_objet_argument);
754:
755: (*s_etat_processus).erreur_execution =
756: d_ex_argument_invalide;
757: return;
758: }
759:
760: if ((tampon = conversion_majuscule((unsigned char *)
761: (*(*l_element_courant).donnee).objet)) == NULL)
762: {
763: (*s_etat_processus).erreur_systeme =
764: d_es_allocation_memoire;
765: return;
766: }
767:
768: presence_type = d_vrai;
769: }
770: else
771: {
772: nombre_arguments_principaux++;
773: }
774:
775: l_element_courant = (*l_element_courant).suivant;
776: }
777:
778: if (presence_type == d_faux)
779: {
780: if ((tampon = malloc(5 * sizeof(unsigned char))) == NULL)
781: {
782: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
783: return;
784: }
785:
786: if ((*s_etat_processus).systeme_axes == 0)
787: {
788: strcpy(tampon, "MAIN");
789: }
790: else
791: {
792: strcpy(tampon, "AUXILIARY");
793: }
794: }
795:
796: if (strcmp(tampon, "MAIN") == 0)
797: {
798: axes_principaux = d_vrai;
799: (*s_etat_processus).systeme_axes = 0;
800: }
801: else if (strcmp(tampon, "AUXILIARY") == 0)
802: {
803: axes_principaux = d_faux;
804: (*s_etat_processus).systeme_axes = 1;
805: }
806: else
807: {
808: free(tampon);
809:
810: liberation(s_etat_processus, s_objet_argument);
811:
812: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
813: return;
814: }
815:
816: free(tampon);
817:
818: if ((nombre_arguments_principaux != 0) &&
819: (nombre_arguments_principaux != 2) &&
820: (nombre_arguments_principaux != 3))
821: {
822: liberation(s_etat_processus, s_objet_argument);
823:
824: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
825: return;
826: }
827:
828: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
829: nombre_arguments_principaux = 0;
830:
831: while(l_element_courant != NULL)
832: {
833: nombre_arguments_principaux++;
834:
835: if ((*(*l_element_courant).donnee).type == CHN)
836: {
837: l_element_courant = (*l_element_courant).suivant;
838: nombre_arguments_principaux--;
839: continue;
840: }
841: else if ((*(*l_element_courant).donnee).type == LST)
842: {
843: l_element_courant_auxiliaire = (struct_liste_chainee *)
844: (*(*l_element_courant).donnee).objet;
845: nombre_arguments_auxiliaires = 0;
846: autorisation_trace = d_vrai;
847:
848: while(l_element_courant_auxiliaire != NULL)
849: {
850: nombre_arguments_auxiliaires++;
851:
852: if (((*(*l_element_courant_auxiliaire).donnee).type ==
853: RPN) || ((*(*l_element_courant_auxiliaire).donnee)
854: .type == ALG) || ((*(*l_element_courant_auxiliaire)
855: .donnee).type == NOM))
856: {
857: if (evaluation(s_etat_processus,
858: (*l_element_courant_auxiliaire).donnee, 'N')
859: == d_erreur)
860: {
861: liberation(s_etat_processus, s_objet_argument);
862:
863: return;
864: }
865:
866: if (depilement(s_etat_processus,
867: &((*s_etat_processus).l_base_pile),
868: &s_objet_auxiliaire) == d_erreur)
869: {
870: liberation(s_etat_processus, s_objet_argument);
871:
872: (*s_etat_processus).erreur_execution =
873: d_ex_manque_argument;
874: return;
875: }
876:
877: liberation(s_etat_processus,
878: (*l_element_courant_auxiliaire).donnee);
879: (*l_element_courant_auxiliaire).donnee =
880: s_objet_auxiliaire;
881: }
882:
883: if ((*(*l_element_courant_auxiliaire).donnee).type == INT)
884: {
885: if ((*((integer8 *) (*(*l_element_courant_auxiliaire)
886: .donnee).objet)) <= 0)
887: {
888: liberation(s_etat_processus, s_objet_argument);
889:
890: (*s_etat_processus).erreur_execution =
891: d_ex_argument_invalide;
892: return;
893: }
894:
895: switch(nombre_arguments_principaux)
896: {
897: case 1 :
898: {
899: if (axes_principaux == d_vrai)
900: {
901: if (nombre_arguments_auxiliaires == 1)
902: {
903: (*s_etat_processus).x_tics = (real8)
904: (*((integer8 *) (*
905: (*l_element_courant_auxiliaire)
906: .donnee).objet));
907: (*s_etat_processus).x_lines =
908: autorisation_trace;
909: }
910: else if (nombre_arguments_auxiliaires == 2)
911: {
912: (*s_etat_processus).mx_tics = (real8)
913: (*((integer8 *) (*
914: (*l_element_courant_auxiliaire)
915: .donnee).objet));
916: (*s_etat_processus).mx_lines =
917: autorisation_trace;
918: }
919: else
920: {
921: liberation(s_etat_processus,
922: s_objet_argument);
923:
924: (*s_etat_processus).erreur_execution =
925: d_ex_argument_invalide;
926: return;
927: }
928: }
929: else
930: {
931: if (nombre_arguments_auxiliaires == 1)
932: {
933: (*s_etat_processus).x2_tics = (real8)
934: (*((integer8 *) (*
935: (*l_element_courant_auxiliaire)
936: .donnee).objet));
937: (*s_etat_processus).x2_lines =
938: autorisation_trace;
939: }
940: else if (nombre_arguments_auxiliaires == 2)
941: {
942: (*s_etat_processus).mx2_tics = (real8)
943: (*((integer8 *) (*
944: (*l_element_courant_auxiliaire)
945: .donnee).objet));
946: (*s_etat_processus).mx2_lines =
947: autorisation_trace;
948: }
949: else
950: {
951: liberation(s_etat_processus,
952: s_objet_argument);
953:
954: (*s_etat_processus).erreur_execution =
955: d_ex_argument_invalide;
956: return;
957: }
958: }
959:
960: break;
961: }
962:
963: case 2 :
964: {
965: if (axes_principaux == d_vrai)
966: {
967: if (nombre_arguments_auxiliaires == 1)
968: {
969: (*s_etat_processus).y_tics = (real8)
970: (*((integer8 *) (*
971: (*l_element_courant_auxiliaire)
972: .donnee).objet));
973: (*s_etat_processus).y_lines =
974: autorisation_trace;
975: }
976: else if (nombre_arguments_auxiliaires == 2)
977: {
978: (*s_etat_processus).my_tics = (real8)
979: (*((integer8 *) (*
980: (*l_element_courant_auxiliaire)
981: .donnee).objet));
982: (*s_etat_processus).my_lines =
983: autorisation_trace;
984: }
985: else
986: {
987: liberation(s_etat_processus,
988: s_objet_argument);
989:
990: (*s_etat_processus).erreur_execution =
991: d_ex_argument_invalide;
992: return;
993: }
994: }
995: else
996: {
997: if (nombre_arguments_auxiliaires == 1)
998: {
999: (*s_etat_processus).y2_tics = (real8)
1000: (*((integer8 *) (*
1001: (*l_element_courant_auxiliaire)
1002: .donnee).objet));
1003: (*s_etat_processus).y2_lines =
1004: autorisation_trace;
1005: }
1006: else if (nombre_arguments_auxiliaires == 2)
1007: {
1008: (*s_etat_processus).my2_tics = (real8)
1009: (*((integer8 *) (*
1010: (*l_element_courant_auxiliaire)
1011: .donnee).objet));
1012: (*s_etat_processus).my2_lines =
1013: autorisation_trace;
1014: }
1015: else
1016: {
1017: liberation(s_etat_processus,
1018: s_objet_argument);
1019:
1020: (*s_etat_processus).erreur_execution =
1021: d_ex_argument_invalide;
1022: return;
1023: }
1024: }
1025:
1026: break;
1027: }
1028:
1029: case 3 :
1030: {
1031: if (axes_principaux == d_vrai)
1032: {
1033: if (nombre_arguments_auxiliaires == 1)
1034: {
1035: (*s_etat_processus).z_tics = (real8)
1036: (*((integer8 *) (*
1037: (*l_element_courant_auxiliaire)
1038: .donnee).objet));
1039: (*s_etat_processus).z_lines =
1040: autorisation_trace;
1041: }
1042: else if (nombre_arguments_auxiliaires == 2)
1043: {
1044: (*s_etat_processus).mz_tics = (real8)
1045: (*((integer8 *) (*
1046: (*l_element_courant_auxiliaire)
1047: .donnee).objet));
1048: (*s_etat_processus).mz_lines =
1049: autorisation_trace;
1050: }
1051: else
1052: {
1053: liberation(s_etat_processus,
1054: s_objet_argument);
1055:
1056: (*s_etat_processus).erreur_execution =
1057: d_ex_argument_invalide;
1058: return;
1059: }
1060: }
1061: else
1062: {
1063: if (nombre_arguments_auxiliaires == 1)
1064: {
1065: (*s_etat_processus).z2_tics = (real8)
1066: (*((integer8 *) (*
1067: (*l_element_courant_auxiliaire)
1068: .donnee).objet));
1069: (*s_etat_processus).z2_lines =
1070: autorisation_trace;
1071: }
1072: else if (nombre_arguments_auxiliaires == 2)
1073: {
1074: (*s_etat_processus).mz2_tics = (real8)
1075: (*((integer8 *) (*
1076: (*l_element_courant_auxiliaire)
1077: .donnee).objet));
1078: (*s_etat_processus).mz2_lines =
1079: autorisation_trace;
1080: }
1081: else
1082: {
1083: liberation(s_etat_processus,
1084: s_objet_argument);
1085:
1086: (*s_etat_processus).erreur_execution =
1087: d_ex_argument_invalide;
1088: return;
1089: }
1090: }
1091:
1092: break;
1093: }
1094:
1095: default :
1096: {
1097: liberation(s_etat_processus, s_objet_argument);
1098:
1099: (*s_etat_processus).erreur_execution =
1100: d_ex_argument_invalide;
1101: return;
1102: }
1103: }
1104: }
1105: else if ((*(*l_element_courant_auxiliaire)
1106: .donnee).type == REL)
1107: {
1108: if ((*((real8 *) (*(*l_element_courant_auxiliaire)
1109: .donnee).objet)) <= 0)
1110: {
1111: liberation(s_etat_processus, s_objet_argument);
1112:
1113: (*s_etat_processus).erreur_execution =
1114: d_ex_argument_invalide;
1115: return;
1116: }
1117:
1118: switch(nombre_arguments_principaux)
1119: {
1120: case 1 :
1121: {
1122: if (axes_principaux == d_vrai)
1123: {
1124: if (nombre_arguments_auxiliaires == 1)
1125: {
1126: (*s_etat_processus).x_tics =
1127: (*((real8 *) (*
1128: (*l_element_courant_auxiliaire)
1129: .donnee).objet));
1130: (*s_etat_processus).x_lines =
1131: autorisation_trace;
1132: }
1133: else if (nombre_arguments_auxiliaires == 2)
1134: {
1135: (*s_etat_processus).mx_tics =
1136: (*((real8 *) (*
1137: (*l_element_courant_auxiliaire)
1138: .donnee).objet));
1139: (*s_etat_processus).mx_lines =
1140: autorisation_trace;
1141: }
1142: else
1143: {
1144: liberation(s_etat_processus,
1145: s_objet_argument);
1146:
1147: (*s_etat_processus).erreur_execution =
1148: d_ex_argument_invalide;
1149: return;
1150: }
1151: }
1152: else
1153: {
1154: if (nombre_arguments_auxiliaires == 1)
1155: {
1156: (*s_etat_processus).x2_tics =
1157: (*((real8 *) (*
1158: (*l_element_courant_auxiliaire)
1159: .donnee).objet));
1160: (*s_etat_processus).x2_lines =
1161: autorisation_trace;
1162: }
1163: else if (nombre_arguments_auxiliaires == 2)
1164: {
1165: (*s_etat_processus).mx2_tics =
1166: (*((real8 *) (*
1167: (*l_element_courant_auxiliaire)
1168: .donnee).objet));
1169: (*s_etat_processus).mx2_lines =
1170: autorisation_trace;
1171: }
1172: else
1173: {
1174: liberation(s_etat_processus,
1175: s_objet_argument);
1176:
1177: (*s_etat_processus).erreur_execution =
1178: d_ex_argument_invalide;
1179: return;
1180: }
1181: }
1182:
1183: break;
1184: }
1185:
1186: case 2 :
1187: {
1188: if (axes_principaux == d_vrai)
1189: {
1190: if (nombre_arguments_auxiliaires == 1)
1191: {
1192: (*s_etat_processus).y_tics =
1193: (*((real8 *) (*
1194: (*l_element_courant_auxiliaire)
1195: .donnee).objet));
1196: (*s_etat_processus).y_lines =
1197: autorisation_trace;
1198: }
1199: else if (nombre_arguments_auxiliaires == 2)
1200: {
1201: (*s_etat_processus).my_tics =
1202: (*((real8 *) (*
1203: (*l_element_courant_auxiliaire)
1204: .donnee).objet));
1205: (*s_etat_processus).my_lines =
1206: autorisation_trace;
1207: }
1208: else
1209: {
1210: liberation(s_etat_processus,
1211: s_objet_argument);
1212:
1213: (*s_etat_processus).erreur_execution =
1214: d_ex_argument_invalide;
1215: return;
1216: }
1217: }
1218: else
1219: {
1220: if (nombre_arguments_auxiliaires == 1)
1221: {
1222: (*s_etat_processus).y2_tics =
1223: (*((real8 *) (*
1224: (*l_element_courant_auxiliaire)
1225: .donnee).objet));
1226: (*s_etat_processus).y2_lines =
1227: autorisation_trace;
1228: }
1229: else if (nombre_arguments_auxiliaires == 2)
1230: {
1231: (*s_etat_processus).my2_tics =
1232: (*((real8 *) (*
1233: (*l_element_courant_auxiliaire)
1234: .donnee).objet));
1235: (*s_etat_processus).my2_lines =
1236: autorisation_trace;
1237: }
1238: else
1239: {
1240: liberation(s_etat_processus,
1241: s_objet_argument);
1242:
1243: (*s_etat_processus).erreur_execution =
1244: d_ex_argument_invalide;
1245: return;
1246: }
1247: }
1248:
1249: break;
1250: }
1251:
1252: case 3 :
1253: {
1254: if (axes_principaux == d_vrai)
1255: {
1256: if (nombre_arguments_auxiliaires == 1)
1257: {
1258: (*s_etat_processus).z_tics =
1259: (*((real8 *) (*
1260: (*l_element_courant_auxiliaire)
1261: .donnee).objet));
1262: (*s_etat_processus).z_lines =
1263: autorisation_trace;
1264: }
1265: else if (nombre_arguments_auxiliaires == 2)
1266: {
1267: (*s_etat_processus).mz_tics =
1268: (*((real8 *) (*
1269: (*l_element_courant_auxiliaire)
1270: .donnee).objet));
1271: (*s_etat_processus).mz_lines =
1272: autorisation_trace;
1273: }
1274: else
1275: {
1276: liberation(s_etat_processus,
1277: s_objet_argument);
1278:
1279: (*s_etat_processus).erreur_execution =
1280: d_ex_argument_invalide;
1281: return;
1282: }
1283: }
1284: else
1285: {
1286: if (nombre_arguments_auxiliaires == 1)
1287: {
1288: (*s_etat_processus).z2_tics =
1289: (*((real8 *) (*
1290: (*l_element_courant_auxiliaire)
1291: .donnee).objet));
1292: (*s_etat_processus).z2_lines =
1293: autorisation_trace;
1294: }
1295: else if (nombre_arguments_auxiliaires == 2)
1296: {
1297: (*s_etat_processus).mz2_tics =
1298: (*((real8 *) (*
1299: (*l_element_courant_auxiliaire)
1300: .donnee).objet));
1301: (*s_etat_processus).mz2_lines =
1302: autorisation_trace;
1303: }
1304: else
1305: {
1306: liberation(s_etat_processus,
1307: s_objet_argument);
1308:
1309: (*s_etat_processus).erreur_execution =
1310: d_ex_argument_invalide;
1311: return;
1312: }
1313: }
1314:
1315: break;
1316: }
1317:
1318: default :
1319: {
1320: liberation(s_etat_processus, s_objet_argument);
1321:
1322: (*s_etat_processus).erreur_execution =
1323: d_ex_argument_invalide;
1324: return;
1325: }
1326: }
1327: }
1328: else if ((*(*l_element_courant_auxiliaire).donnee)
1329: .type == CHN)
1330: {
1331: tampon = conversion_majuscule((unsigned char *)
1332: (*(*l_element_courant_auxiliaire).donnee)
1333: .objet);
1334:
1335: if (tampon == NULL)
1336: {
1337: (*s_etat_processus).erreur_systeme =
1338: d_es_allocation_memoire;
1339: return;
1340: }
1341:
1342: if (strcmp(tampon, "AUTOMATIC") == 0)
1343: {
1344: switch(nombre_arguments_principaux)
1345: {
1346: case 1 :
1347: {
1348: if (axes_principaux == d_vrai)
1349: {
1350: if (nombre_arguments_auxiliaires
1351: == 1)
1352: {
1353: (*s_etat_processus).x_tics = 0;
1354: (*s_etat_processus).x_lines =
1355: autorisation_trace;
1356: }
1357: else
1358: {
1359: liberation(s_etat_processus,
1360: s_objet_argument);
1361:
1362: (*s_etat_processus).erreur_execution
1363: = d_ex_argument_invalide;
1364:
1365: return;
1366: }
1367: }
1368: else
1369: {
1370: if (nombre_arguments_auxiliaires
1371: == 1)
1372: {
1373: (*s_etat_processus).x2_tics = 0;
1374: (*s_etat_processus).x2_lines =
1375: autorisation_trace;
1376: }
1377: else
1378: {
1379: liberation(s_etat_processus,
1380: s_objet_argument);
1381:
1382: (*s_etat_processus).erreur_execution
1383: = d_ex_argument_invalide;
1384:
1385: return;
1386: }
1387: }
1388:
1389: break;
1390: }
1391:
1392: case 2 :
1393: {
1394: if (axes_principaux == d_vrai)
1395: {
1396: if (nombre_arguments_auxiliaires
1397: == 1)
1398: {
1399: (*s_etat_processus).y_tics = 0;
1400: (*s_etat_processus).y_lines =
1401: autorisation_trace;
1402: }
1403: else
1404: {
1405: liberation(s_etat_processus,
1406: s_objet_argument);
1407:
1408: (*s_etat_processus).erreur_execution
1409: = d_ex_argument_invalide;
1410:
1411: return;
1412: }
1413: }
1414: else
1415: {
1416: if (nombre_arguments_auxiliaires
1417: == 1)
1418: {
1419: (*s_etat_processus).y2_tics = 0;
1420: (*s_etat_processus).y2_lines =
1421: autorisation_trace;
1422: }
1423: else
1424: {
1425: liberation(s_etat_processus,
1426: s_objet_argument);
1427:
1428: (*s_etat_processus).erreur_execution
1429: = d_ex_argument_invalide;
1430:
1431: return;
1432: }
1433: }
1434:
1435: break;
1436: }
1437:
1438: case 3 :
1439: {
1440: if (axes_principaux == d_vrai)
1441: {
1442: if (nombre_arguments_auxiliaires
1443: == 1)
1444: {
1445: (*s_etat_processus).z_tics = 0;
1446: (*s_etat_processus).z_lines =
1447: autorisation_trace;
1448: }
1449: else
1450: {
1451: liberation(s_etat_processus,
1452: s_objet_argument);
1453:
1454: (*s_etat_processus).erreur_execution
1455: = d_ex_argument_invalide;
1456:
1457: return;
1458: }
1459: }
1460: else
1461: {
1462: if (nombre_arguments_auxiliaires
1463: == 1)
1464: {
1465: (*s_etat_processus).z2_tics = 0;
1466: (*s_etat_processus).z2_lines =
1467: autorisation_trace;
1468: }
1469: else
1470: {
1471: liberation(s_etat_processus,
1472: s_objet_argument);
1473:
1474: (*s_etat_processus).erreur_execution
1475: = d_ex_argument_invalide;
1476:
1477: return;
1478: }
1479: }
1480:
1481: break;
1482: }
1483:
1484: default :
1485: {
1486: liberation(s_etat_processus,
1487: s_objet_argument);
1488:
1489: free(tampon);
1490:
1491: (*s_etat_processus).erreur_execution =
1492: d_ex_argument_invalide;
1493: return;
1494: }
1495: }
1496: }
1497: else if (strcmp(tampon, "DEFAULT") == 0)
1498: {
1499: switch(nombre_arguments_principaux)
1500: {
1501: case 1 :
1502: {
1503: if (axes_principaux == d_vrai)
1504: {
1505: if (nombre_arguments_auxiliaires
1506: == 2)
1507: {
1508: (*s_etat_processus).mx_tics = 0;
1509: (*s_etat_processus).mx_lines =
1510: autorisation_trace;
1511: }
1512: else
1513: {
1514: liberation(s_etat_processus,
1515: s_objet_argument);
1516:
1517: (*s_etat_processus).erreur_execution
1518: = d_ex_argument_invalide;
1519:
1520: return;
1521: }
1522: }
1523: else
1524: {
1525: if (nombre_arguments_auxiliaires
1526: == 2)
1527: {
1528: (*s_etat_processus).mx2_tics = 0;
1529: (*s_etat_processus).mx2_lines =
1530: autorisation_trace;
1531: }
1532: else
1533: {
1534: liberation(s_etat_processus,
1535: s_objet_argument);
1536:
1537: (*s_etat_processus).erreur_execution
1538: = d_ex_argument_invalide;
1539:
1540: return;
1541: }
1542: }
1543:
1544: break;
1545: }
1546:
1547: case 2 :
1548: {
1549: if (axes_principaux == d_vrai)
1550: {
1551: if (nombre_arguments_auxiliaires
1552: == 2)
1553: {
1554: (*s_etat_processus).my_tics = 0;
1555: (*s_etat_processus).my_lines =
1556: autorisation_trace;
1557: }
1558: else
1559: {
1560: liberation(s_etat_processus,
1561: s_objet_argument);
1562:
1563: (*s_etat_processus).erreur_execution
1564: = d_ex_argument_invalide;
1565:
1566: return;
1567: }
1568: }
1569: else
1570: {
1571: if (nombre_arguments_auxiliaires
1572: == 2)
1573: {
1574: (*s_etat_processus).my2_tics = 0;
1575: (*s_etat_processus).my2_lines =
1576: autorisation_trace;
1577: }
1578: else
1579: {
1580: liberation(s_etat_processus,
1581: s_objet_argument);
1582:
1583: (*s_etat_processus).erreur_execution
1584: = d_ex_argument_invalide;
1585:
1586: return;
1587: }
1588: }
1589:
1590: break;
1591: }
1592:
1593: case 3 :
1594: {
1595: if (axes_principaux == d_vrai)
1596: {
1597: if (nombre_arguments_auxiliaires
1598: == 2)
1599: {
1600: (*s_etat_processus).mz_tics = 0;
1601: (*s_etat_processus).mz_lines =
1602: autorisation_trace;
1603: }
1604: else
1605: {
1606: liberation(s_etat_processus,
1607: s_objet_argument);
1608:
1609: (*s_etat_processus).erreur_execution
1610: = d_ex_argument_invalide;
1611:
1612: return;
1613: }
1614: }
1615: else
1616: {
1617: if (nombre_arguments_auxiliaires
1618: == 2)
1619: {
1620: (*s_etat_processus).mz2_tics = 0;
1621: (*s_etat_processus).mz2_lines =
1622: autorisation_trace;
1623: }
1624: else
1625: {
1626: liberation(s_etat_processus,
1627: s_objet_argument);
1628:
1629: (*s_etat_processus).erreur_execution
1630: = d_ex_argument_invalide;
1631:
1632: return;
1633: }
1634: }
1635:
1636: break;
1637: }
1638:
1639: default :
1640: {
1641: liberation(s_etat_processus,
1642: s_objet_argument);
1643:
1644: free(tampon);
1645:
1646: (*s_etat_processus).erreur_execution =
1647: d_ex_argument_invalide;
1648: return;
1649: }
1650: }
1651: }
1652: else if (strcmp(tampon, "TICSONLY") == 0)
1653: {
1654: nombre_arguments_auxiliaires--;
1655: autorisation_trace = d_faux;
1656: }
1657: else
1658: {
1659: liberation(s_etat_processus, s_objet_argument);
1660:
1661: free(tampon);
1662:
1663: (*s_etat_processus).erreur_execution =
1664: d_ex_argument_invalide;
1665: return;
1666: }
1667:
1668: free(tampon);
1669: }
1670: else
1671: {
1672: liberation(s_etat_processus, s_objet_argument);
1673:
1674: (*s_etat_processus).erreur_execution =
1675: d_ex_erreur_type_argument;
1676: return;
1677: }
1678:
1679: l_element_courant_auxiliaire =
1680: (*l_element_courant_auxiliaire).suivant;
1681: }
1682: }
1683: else
1684: {
1685: liberation(s_etat_processus, s_objet_argument);
1686:
1687: (*s_etat_processus).erreur_execution =
1688: d_ex_erreur_type_argument;
1689: return;
1690: }
1691:
1692: l_element_courant = (*l_element_courant).suivant;
1693: }
1694: }
1695: else
1696: {
1697: liberation(s_etat_processus, s_objet_argument);
1698:
1699: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1700: return;
1701: }
1702:
1703: liberation(s_etat_processus, s_objet_argument);
1704:
1705: return;
1706: }
1707:
1708: // vim: ts=4