1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.17
4: Copyright (C) 1989-2014 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((*((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: {
559: struct_descripteur_fichier *descripteur;
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:
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
623: {
624: liberation(s_etat_processus, s_objet_argument);
625:
626: (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
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 ((*s_etat_processus).systeme_axes == 0)
781: {
782: if ((tampon = malloc(5 * sizeof(unsigned char))) == NULL)
783: {
784: (*s_etat_processus).erreur_systeme =
785: d_es_allocation_memoire;
786: return;
787: }
788:
789: strcpy(tampon, "MAIN");
790: }
791: else
792: {
793: if ((tampon = malloc(10 * sizeof(unsigned char))) == NULL)
794: {
795: (*s_etat_processus).erreur_systeme =
796: d_es_allocation_memoire;
797: return;
798: }
799:
800: strcpy(tampon, "AUXILIARY");
801: }
802: }
803:
804: if (strcmp(tampon, "MAIN") == 0)
805: {
806: axes_principaux = d_vrai;
807: (*s_etat_processus).systeme_axes = 0;
808: }
809: else if (strcmp(tampon, "AUXILIARY") == 0)
810: {
811: axes_principaux = d_faux;
812: (*s_etat_processus).systeme_axes = 1;
813: }
814: else
815: {
816: free(tampon);
817:
818: liberation(s_etat_processus, s_objet_argument);
819:
820: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
821: return;
822: }
823:
824: free(tampon);
825:
826: if ((nombre_arguments_principaux != 0) &&
827: (nombre_arguments_principaux != 2) &&
828: (nombre_arguments_principaux != 3))
829: {
830: liberation(s_etat_processus, s_objet_argument);
831:
832: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
833: return;
834: }
835:
836: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
837: nombre_arguments_principaux = 0;
838:
839: while(l_element_courant != NULL)
840: {
841: nombre_arguments_principaux++;
842:
843: if ((*(*l_element_courant).donnee).type == CHN)
844: {
845: l_element_courant = (*l_element_courant).suivant;
846: nombre_arguments_principaux--;
847: continue;
848: }
849: else if ((*(*l_element_courant).donnee).type == LST)
850: {
851: l_element_courant_auxiliaire = (struct_liste_chainee *)
852: (*(*l_element_courant).donnee).objet;
853: nombre_arguments_auxiliaires = 0;
854: autorisation_trace = d_vrai;
855:
856: while(l_element_courant_auxiliaire != NULL)
857: {
858: nombre_arguments_auxiliaires++;
859:
860: if (((*(*l_element_courant_auxiliaire).donnee).type ==
861: RPN) || ((*(*l_element_courant_auxiliaire).donnee)
862: .type == ALG) || ((*(*l_element_courant_auxiliaire)
863: .donnee).type == NOM))
864: {
865: if (evaluation(s_etat_processus,
866: (*l_element_courant_auxiliaire).donnee, 'N')
867: == d_erreur)
868: {
869: liberation(s_etat_processus, s_objet_argument);
870:
871: return;
872: }
873:
874: if (depilement(s_etat_processus,
875: &((*s_etat_processus).l_base_pile),
876: &s_objet_auxiliaire) == d_erreur)
877: {
878: liberation(s_etat_processus, s_objet_argument);
879:
880: (*s_etat_processus).erreur_execution =
881: d_ex_manque_argument;
882: return;
883: }
884:
885: liberation(s_etat_processus,
886: (*l_element_courant_auxiliaire).donnee);
887: (*l_element_courant_auxiliaire).donnee =
888: s_objet_auxiliaire;
889: }
890:
891: if ((*(*l_element_courant_auxiliaire).donnee).type == INT)
892: {
893: if ((*((integer8 *) (*(*l_element_courant_auxiliaire)
894: .donnee).objet)) <= 0)
895: {
896: liberation(s_etat_processus, s_objet_argument);
897:
898: (*s_etat_processus).erreur_execution =
899: d_ex_argument_invalide;
900: return;
901: }
902:
903: switch(nombre_arguments_principaux)
904: {
905: case 1 :
906: {
907: if (axes_principaux == d_vrai)
908: {
909: if (nombre_arguments_auxiliaires == 1)
910: {
911: (*s_etat_processus).x_tics = (real8)
912: (*((integer8 *) (*
913: (*l_element_courant_auxiliaire)
914: .donnee).objet));
915: (*s_etat_processus).x_lines =
916: autorisation_trace;
917: }
918: else if (nombre_arguments_auxiliaires == 2)
919: {
920: (*s_etat_processus).mx_tics =
921: (*((integer8 *) (*
922: (*l_element_courant_auxiliaire)
923: .donnee).objet));
924: (*s_etat_processus).mx_lines =
925: autorisation_trace;
926: }
927: else
928: {
929: liberation(s_etat_processus,
930: s_objet_argument);
931:
932: (*s_etat_processus).erreur_execution =
933: d_ex_argument_invalide;
934: return;
935: }
936: }
937: else
938: {
939: if (nombre_arguments_auxiliaires == 1)
940: {
941: (*s_etat_processus).x2_tics = (real8)
942: (*((integer8 *) (*
943: (*l_element_courant_auxiliaire)
944: .donnee).objet));
945: (*s_etat_processus).x2_lines =
946: autorisation_trace;
947: }
948: else if (nombre_arguments_auxiliaires == 2)
949: {
950: (*s_etat_processus).mx2_tics =
951: (*((integer8 *) (*
952: (*l_element_courant_auxiliaire)
953: .donnee).objet));
954: (*s_etat_processus).mx2_lines =
955: autorisation_trace;
956: }
957: else
958: {
959: liberation(s_etat_processus,
960: s_objet_argument);
961:
962: (*s_etat_processus).erreur_execution =
963: d_ex_argument_invalide;
964: return;
965: }
966: }
967:
968: break;
969: }
970:
971: case 2 :
972: {
973: if (axes_principaux == d_vrai)
974: {
975: if (nombre_arguments_auxiliaires == 1)
976: {
977: (*s_etat_processus).y_tics = (real8)
978: (*((integer8 *) (*
979: (*l_element_courant_auxiliaire)
980: .donnee).objet));
981: (*s_etat_processus).y_lines =
982: autorisation_trace;
983: }
984: else if (nombre_arguments_auxiliaires == 2)
985: {
986: (*s_etat_processus).my_tics =
987: (*((integer8 *) (*
988: (*l_element_courant_auxiliaire)
989: .donnee).objet));
990: (*s_etat_processus).my_lines =
991: autorisation_trace;
992: }
993: else
994: {
995: liberation(s_etat_processus,
996: s_objet_argument);
997:
998: (*s_etat_processus).erreur_execution =
999: d_ex_argument_invalide;
1000: return;
1001: }
1002: }
1003: else
1004: {
1005: if (nombre_arguments_auxiliaires == 1)
1006: {
1007: (*s_etat_processus).y2_tics = (real8)
1008: (*((integer8 *) (*
1009: (*l_element_courant_auxiliaire)
1010: .donnee).objet));
1011: (*s_etat_processus).y2_lines =
1012: autorisation_trace;
1013: }
1014: else if (nombre_arguments_auxiliaires == 2)
1015: {
1016: (*s_etat_processus).my2_tics =
1017: (*((integer8 *) (*
1018: (*l_element_courant_auxiliaire)
1019: .donnee).objet));
1020: (*s_etat_processus).my2_lines =
1021: autorisation_trace;
1022: }
1023: else
1024: {
1025: liberation(s_etat_processus,
1026: s_objet_argument);
1027:
1028: (*s_etat_processus).erreur_execution =
1029: d_ex_argument_invalide;
1030: return;
1031: }
1032: }
1033:
1034: break;
1035: }
1036:
1037: case 3 :
1038: {
1039: if (axes_principaux == d_vrai)
1040: {
1041: if (nombre_arguments_auxiliaires == 1)
1042: {
1043: (*s_etat_processus).z_tics = (real8)
1044: (*((integer8 *) (*
1045: (*l_element_courant_auxiliaire)
1046: .donnee).objet));
1047: (*s_etat_processus).z_lines =
1048: autorisation_trace;
1049: }
1050: else if (nombre_arguments_auxiliaires == 2)
1051: {
1052: (*s_etat_processus).mz_tics =
1053: (*((integer8 *) (*
1054: (*l_element_courant_auxiliaire)
1055: .donnee).objet));
1056: (*s_etat_processus).mz_lines =
1057: autorisation_trace;
1058: }
1059: else
1060: {
1061: liberation(s_etat_processus,
1062: s_objet_argument);
1063:
1064: (*s_etat_processus).erreur_execution =
1065: d_ex_argument_invalide;
1066: return;
1067: }
1068: }
1069: else
1070: {
1071: if (nombre_arguments_auxiliaires == 1)
1072: {
1073: (*s_etat_processus).z2_tics = (real8)
1074: (*((integer8 *) (*
1075: (*l_element_courant_auxiliaire)
1076: .donnee).objet));
1077: (*s_etat_processus).z2_lines =
1078: autorisation_trace;
1079: }
1080: else if (nombre_arguments_auxiliaires == 2)
1081: {
1082: (*s_etat_processus).mz2_tics =
1083: (*((integer8 *) (*
1084: (*l_element_courant_auxiliaire)
1085: .donnee).objet));
1086: (*s_etat_processus).mz2_lines =
1087: autorisation_trace;
1088: }
1089: else
1090: {
1091: liberation(s_etat_processus,
1092: s_objet_argument);
1093:
1094: (*s_etat_processus).erreur_execution =
1095: d_ex_argument_invalide;
1096: return;
1097: }
1098: }
1099:
1100: break;
1101: }
1102:
1103: default :
1104: {
1105: liberation(s_etat_processus, s_objet_argument);
1106:
1107: (*s_etat_processus).erreur_execution =
1108: d_ex_argument_invalide;
1109: return;
1110: }
1111: }
1112: }
1113: else if ((*(*l_element_courant_auxiliaire)
1114: .donnee).type == REL)
1115: {
1116: if ((*((real8 *) (*(*l_element_courant_auxiliaire)
1117: .donnee).objet)) <= 0)
1118: {
1119: liberation(s_etat_processus, s_objet_argument);
1120:
1121: (*s_etat_processus).erreur_execution =
1122: d_ex_argument_invalide;
1123: return;
1124: }
1125:
1126: switch(nombre_arguments_principaux)
1127: {
1128: case 1 :
1129: {
1130: if (axes_principaux == d_vrai)
1131: {
1132: if (nombre_arguments_auxiliaires == 1)
1133: {
1134: (*s_etat_processus).x_tics =
1135: (*((real8 *) (*
1136: (*l_element_courant_auxiliaire)
1137: .donnee).objet));
1138: (*s_etat_processus).x_lines =
1139: autorisation_trace;
1140: }
1141: else if (nombre_arguments_auxiliaires == 2)
1142: {
1143: (*s_etat_processus).mx_tics =
1144: (integer8) (*((real8 *) (*
1145: (*l_element_courant_auxiliaire)
1146: .donnee).objet));
1147: (*s_etat_processus).mx_lines =
1148: autorisation_trace;
1149: }
1150: else
1151: {
1152: liberation(s_etat_processus,
1153: s_objet_argument);
1154:
1155: (*s_etat_processus).erreur_execution =
1156: d_ex_argument_invalide;
1157: return;
1158: }
1159: }
1160: else
1161: {
1162: if (nombre_arguments_auxiliaires == 1)
1163: {
1164: (*s_etat_processus).x2_tics =
1165: (*((real8 *) (*
1166: (*l_element_courant_auxiliaire)
1167: .donnee).objet));
1168: (*s_etat_processus).x2_lines =
1169: autorisation_trace;
1170: }
1171: else if (nombre_arguments_auxiliaires == 2)
1172: {
1173: (*s_etat_processus).mx2_tics =
1174: (integer8) (*((real8 *) (*
1175: (*l_element_courant_auxiliaire)
1176: .donnee).objet));
1177: (*s_etat_processus).mx2_lines =
1178: autorisation_trace;
1179: }
1180: else
1181: {
1182: liberation(s_etat_processus,
1183: s_objet_argument);
1184:
1185: (*s_etat_processus).erreur_execution =
1186: d_ex_argument_invalide;
1187: return;
1188: }
1189: }
1190:
1191: break;
1192: }
1193:
1194: case 2 :
1195: {
1196: if (axes_principaux == d_vrai)
1197: {
1198: if (nombre_arguments_auxiliaires == 1)
1199: {
1200: (*s_etat_processus).y_tics =
1201: (*((real8 *) (*
1202: (*l_element_courant_auxiliaire)
1203: .donnee).objet));
1204: (*s_etat_processus).y_lines =
1205: autorisation_trace;
1206: }
1207: else if (nombre_arguments_auxiliaires == 2)
1208: {
1209: (*s_etat_processus).my_tics =
1210: (integer8) (*((real8 *) (*
1211: (*l_element_courant_auxiliaire)
1212: .donnee).objet));
1213: (*s_etat_processus).my_lines =
1214: autorisation_trace;
1215: }
1216: else
1217: {
1218: liberation(s_etat_processus,
1219: s_objet_argument);
1220:
1221: (*s_etat_processus).erreur_execution =
1222: d_ex_argument_invalide;
1223: return;
1224: }
1225: }
1226: else
1227: {
1228: if (nombre_arguments_auxiliaires == 1)
1229: {
1230: (*s_etat_processus).y2_tics =
1231: (*((real8 *) (*
1232: (*l_element_courant_auxiliaire)
1233: .donnee).objet));
1234: (*s_etat_processus).y2_lines =
1235: autorisation_trace;
1236: }
1237: else if (nombre_arguments_auxiliaires == 2)
1238: {
1239: (*s_etat_processus).my2_tics =
1240: (integer8) (*((real8 *) (*
1241: (*l_element_courant_auxiliaire)
1242: .donnee).objet));
1243: (*s_etat_processus).my2_lines =
1244: autorisation_trace;
1245: }
1246: else
1247: {
1248: liberation(s_etat_processus,
1249: s_objet_argument);
1250:
1251: (*s_etat_processus).erreur_execution =
1252: d_ex_argument_invalide;
1253: return;
1254: }
1255: }
1256:
1257: break;
1258: }
1259:
1260: case 3 :
1261: {
1262: if (axes_principaux == d_vrai)
1263: {
1264: if (nombre_arguments_auxiliaires == 1)
1265: {
1266: (*s_etat_processus).z_tics =
1267: (*((real8 *) (*
1268: (*l_element_courant_auxiliaire)
1269: .donnee).objet));
1270: (*s_etat_processus).z_lines =
1271: autorisation_trace;
1272: }
1273: else if (nombre_arguments_auxiliaires == 2)
1274: {
1275: (*s_etat_processus).mz_tics =
1276: (integer8) (*((real8 *) (*
1277: (*l_element_courant_auxiliaire)
1278: .donnee).objet));
1279: (*s_etat_processus).mz_lines =
1280: autorisation_trace;
1281: }
1282: else
1283: {
1284: liberation(s_etat_processus,
1285: s_objet_argument);
1286:
1287: (*s_etat_processus).erreur_execution =
1288: d_ex_argument_invalide;
1289: return;
1290: }
1291: }
1292: else
1293: {
1294: if (nombre_arguments_auxiliaires == 1)
1295: {
1296: (*s_etat_processus).z2_tics =
1297: (*((real8 *) (*
1298: (*l_element_courant_auxiliaire)
1299: .donnee).objet));
1300: (*s_etat_processus).z2_lines =
1301: autorisation_trace;
1302: }
1303: else if (nombre_arguments_auxiliaires == 2)
1304: {
1305: (*s_etat_processus).mz2_tics =
1306: (integer8) (*((real8 *) (*
1307: (*l_element_courant_auxiliaire)
1308: .donnee).objet));
1309: (*s_etat_processus).mz2_lines =
1310: autorisation_trace;
1311: }
1312: else
1313: {
1314: liberation(s_etat_processus,
1315: s_objet_argument);
1316:
1317: (*s_etat_processus).erreur_execution =
1318: d_ex_argument_invalide;
1319: return;
1320: }
1321: }
1322:
1323: break;
1324: }
1325:
1326: default :
1327: {
1328: liberation(s_etat_processus, s_objet_argument);
1329:
1330: (*s_etat_processus).erreur_execution =
1331: d_ex_argument_invalide;
1332: return;
1333: }
1334: }
1335: }
1336: else if ((*(*l_element_courant_auxiliaire).donnee)
1337: .type == CHN)
1338: {
1339: tampon = conversion_majuscule((unsigned char *)
1340: (*(*l_element_courant_auxiliaire).donnee)
1341: .objet);
1342:
1343: if (tampon == NULL)
1344: {
1345: (*s_etat_processus).erreur_systeme =
1346: d_es_allocation_memoire;
1347: return;
1348: }
1349:
1350: if (strcmp(tampon, "AUTOMATIC") == 0)
1351: {
1352: switch(nombre_arguments_principaux)
1353: {
1354: case 1 :
1355: {
1356: if (axes_principaux == d_vrai)
1357: {
1358: if (nombre_arguments_auxiliaires
1359: == 1)
1360: {
1361: (*s_etat_processus).x_tics = 0;
1362: (*s_etat_processus).x_lines =
1363: autorisation_trace;
1364: }
1365: else
1366: {
1367: liberation(s_etat_processus,
1368: s_objet_argument);
1369:
1370: (*s_etat_processus).erreur_execution
1371: = d_ex_argument_invalide;
1372:
1373: return;
1374: }
1375: }
1376: else
1377: {
1378: if (nombre_arguments_auxiliaires
1379: == 1)
1380: {
1381: (*s_etat_processus).x2_tics = 0;
1382: (*s_etat_processus).x2_lines =
1383: autorisation_trace;
1384: }
1385: else
1386: {
1387: liberation(s_etat_processus,
1388: s_objet_argument);
1389:
1390: (*s_etat_processus).erreur_execution
1391: = d_ex_argument_invalide;
1392:
1393: return;
1394: }
1395: }
1396:
1397: break;
1398: }
1399:
1400: case 2 :
1401: {
1402: if (axes_principaux == d_vrai)
1403: {
1404: if (nombre_arguments_auxiliaires
1405: == 1)
1406: {
1407: (*s_etat_processus).y_tics = 0;
1408: (*s_etat_processus).y_lines =
1409: autorisation_trace;
1410: }
1411: else
1412: {
1413: liberation(s_etat_processus,
1414: s_objet_argument);
1415:
1416: (*s_etat_processus).erreur_execution
1417: = d_ex_argument_invalide;
1418:
1419: return;
1420: }
1421: }
1422: else
1423: {
1424: if (nombre_arguments_auxiliaires
1425: == 1)
1426: {
1427: (*s_etat_processus).y2_tics = 0;
1428: (*s_etat_processus).y2_lines =
1429: autorisation_trace;
1430: }
1431: else
1432: {
1433: liberation(s_etat_processus,
1434: s_objet_argument);
1435:
1436: (*s_etat_processus).erreur_execution
1437: = d_ex_argument_invalide;
1438:
1439: return;
1440: }
1441: }
1442:
1443: break;
1444: }
1445:
1446: case 3 :
1447: {
1448: if (axes_principaux == d_vrai)
1449: {
1450: if (nombre_arguments_auxiliaires
1451: == 1)
1452: {
1453: (*s_etat_processus).z_tics = 0;
1454: (*s_etat_processus).z_lines =
1455: autorisation_trace;
1456: }
1457: else
1458: {
1459: liberation(s_etat_processus,
1460: s_objet_argument);
1461:
1462: (*s_etat_processus).erreur_execution
1463: = d_ex_argument_invalide;
1464:
1465: return;
1466: }
1467: }
1468: else
1469: {
1470: if (nombre_arguments_auxiliaires
1471: == 1)
1472: {
1473: (*s_etat_processus).z2_tics = 0;
1474: (*s_etat_processus).z2_lines =
1475: autorisation_trace;
1476: }
1477: else
1478: {
1479: liberation(s_etat_processus,
1480: s_objet_argument);
1481:
1482: (*s_etat_processus).erreur_execution
1483: = d_ex_argument_invalide;
1484:
1485: return;
1486: }
1487: }
1488:
1489: break;
1490: }
1491:
1492: default :
1493: {
1494: liberation(s_etat_processus,
1495: s_objet_argument);
1496:
1497: free(tampon);
1498:
1499: (*s_etat_processus).erreur_execution =
1500: d_ex_argument_invalide;
1501: return;
1502: }
1503: }
1504: }
1505: else if (strcmp(tampon, "DEFAULT") == 0)
1506: {
1507: switch(nombre_arguments_principaux)
1508: {
1509: case 1 :
1510: {
1511: if (axes_principaux == d_vrai)
1512: {
1513: if (nombre_arguments_auxiliaires
1514: == 2)
1515: {
1516: (*s_etat_processus).mx_tics = 0;
1517: (*s_etat_processus).mx_lines =
1518: autorisation_trace;
1519: }
1520: else
1521: {
1522: liberation(s_etat_processus,
1523: s_objet_argument);
1524:
1525: (*s_etat_processus).erreur_execution
1526: = d_ex_argument_invalide;
1527:
1528: return;
1529: }
1530: }
1531: else
1532: {
1533: if (nombre_arguments_auxiliaires
1534: == 2)
1535: {
1536: (*s_etat_processus).mx2_tics = 0;
1537: (*s_etat_processus).mx2_lines =
1538: autorisation_trace;
1539: }
1540: else
1541: {
1542: liberation(s_etat_processus,
1543: s_objet_argument);
1544:
1545: (*s_etat_processus).erreur_execution
1546: = d_ex_argument_invalide;
1547:
1548: return;
1549: }
1550: }
1551:
1552: break;
1553: }
1554:
1555: case 2 :
1556: {
1557: if (axes_principaux == d_vrai)
1558: {
1559: if (nombre_arguments_auxiliaires
1560: == 2)
1561: {
1562: (*s_etat_processus).my_tics = 0;
1563: (*s_etat_processus).my_lines =
1564: autorisation_trace;
1565: }
1566: else
1567: {
1568: liberation(s_etat_processus,
1569: s_objet_argument);
1570:
1571: (*s_etat_processus).erreur_execution
1572: = d_ex_argument_invalide;
1573:
1574: return;
1575: }
1576: }
1577: else
1578: {
1579: if (nombre_arguments_auxiliaires
1580: == 2)
1581: {
1582: (*s_etat_processus).my2_tics = 0;
1583: (*s_etat_processus).my2_lines =
1584: autorisation_trace;
1585: }
1586: else
1587: {
1588: liberation(s_etat_processus,
1589: s_objet_argument);
1590:
1591: (*s_etat_processus).erreur_execution
1592: = d_ex_argument_invalide;
1593:
1594: return;
1595: }
1596: }
1597:
1598: break;
1599: }
1600:
1601: case 3 :
1602: {
1603: if (axes_principaux == d_vrai)
1604: {
1605: if (nombre_arguments_auxiliaires
1606: == 2)
1607: {
1608: (*s_etat_processus).mz_tics = 0;
1609: (*s_etat_processus).mz_lines =
1610: autorisation_trace;
1611: }
1612: else
1613: {
1614: liberation(s_etat_processus,
1615: s_objet_argument);
1616:
1617: (*s_etat_processus).erreur_execution
1618: = d_ex_argument_invalide;
1619:
1620: return;
1621: }
1622: }
1623: else
1624: {
1625: if (nombre_arguments_auxiliaires
1626: == 2)
1627: {
1628: (*s_etat_processus).mz2_tics = 0;
1629: (*s_etat_processus).mz2_lines =
1630: autorisation_trace;
1631: }
1632: else
1633: {
1634: liberation(s_etat_processus,
1635: s_objet_argument);
1636:
1637: (*s_etat_processus).erreur_execution
1638: = d_ex_argument_invalide;
1639:
1640: return;
1641: }
1642: }
1643:
1644: break;
1645: }
1646:
1647: default :
1648: {
1649: liberation(s_etat_processus,
1650: s_objet_argument);
1651:
1652: free(tampon);
1653:
1654: (*s_etat_processus).erreur_execution =
1655: d_ex_argument_invalide;
1656: return;
1657: }
1658: }
1659: }
1660: else if (strcmp(tampon, "TICSONLY") == 0)
1661: {
1662: nombre_arguments_auxiliaires--;
1663: autorisation_trace = d_faux;
1664: }
1665: else
1666: {
1667: liberation(s_etat_processus, s_objet_argument);
1668:
1669: free(tampon);
1670:
1671: (*s_etat_processus).erreur_execution =
1672: d_ex_argument_invalide;
1673: return;
1674: }
1675:
1676: free(tampon);
1677: }
1678: else
1679: {
1680: liberation(s_etat_processus, s_objet_argument);
1681:
1682: (*s_etat_processus).erreur_execution =
1683: d_ex_erreur_type_argument;
1684: return;
1685: }
1686:
1687: l_element_courant_auxiliaire =
1688: (*l_element_courant_auxiliaire).suivant;
1689: }
1690: }
1691: else
1692: {
1693: liberation(s_etat_processus, s_objet_argument);
1694:
1695: (*s_etat_processus).erreur_execution =
1696: d_ex_erreur_type_argument;
1697: return;
1698: }
1699:
1700: l_element_courant = (*l_element_courant).suivant;
1701: }
1702: }
1703: else
1704: {
1705: liberation(s_etat_processus, s_objet_argument);
1706:
1707: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1708: return;
1709: }
1710:
1711: liberation(s_etat_processus, s_objet_argument);
1712:
1713: return;
1714: }
1715:
1716: // 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