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