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