Annotation of rpl/src/instructions_s2.c, revision 1.73
1.1 bertrand 1: /*
2: ================================================================================
1.72 bertrand 3: RPL/2 (R) version 4.1.32
1.73 ! bertrand 4: Copyright (C) 1989-2020 Dr. BERTRAND Joël
1.1 bertrand 5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
1.17 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'sin'
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_sin(struct_processus *s_etat_processus)
40: {
41: real8 angle;
42:
43: struct_liste_chainee *l_element_courant;
44: struct_liste_chainee *l_element_precedent;
45:
46: struct_objet *s_copie_argument;
47: struct_objet *s_objet_argument;
48: struct_objet *s_objet_resultat;
49:
50: (*s_etat_processus).erreur_execution = d_ex;
51:
52: if ((*s_etat_processus).affichage_arguments == 'Y')
53: {
54: printf("\n SIN ");
55:
56: if ((*s_etat_processus).langue == 'F')
57: {
58: printf("(sinus)\n\n");
59: }
60: else
61: {
62: printf("(sine)\n\n");
63: }
64:
65: printf(" 1: %s, %s\n", d_INT, d_REL);
66: printf("-> 1: %s\n\n", d_REL);
67:
68: printf(" 1: %s\n", d_CPL);
69: printf("-> 1: %s\n\n", d_CPL);
70:
71: printf(" 1: %s, %s\n", d_NOM, d_ALG);
72: printf("-> 1: %s\n\n", d_ALG);
73:
74: printf(" 1: %s\n", d_RPN);
75: printf("-> 1: %s\n", d_RPN);
76:
77: return;
78: }
79: else if ((*s_etat_processus).test_instruction == 'Y')
80: {
81: (*s_etat_processus).nombre_arguments = 1;
82: return;
83: }
84:
85: if (test_cfsf(s_etat_processus, 31) == d_vrai)
86: {
87: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
88: {
89: return;
90: }
91: }
92:
93: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
94: &s_objet_argument) == d_erreur)
95: {
96: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
97: return;
98: }
99:
100: /*
101: --------------------------------------------------------------------------------
102: Sinus d'un entier ou d'un réel
103: --------------------------------------------------------------------------------
104: */
105:
106: if (((*s_objet_argument).type == INT) ||
107: ((*s_objet_argument).type == REL))
108: {
109: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
110: {
111: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
112: return;
113: }
114:
115: if ((*s_objet_argument).type == INT)
116: {
117: angle = (real8) (*((integer8 *) (*s_objet_argument).objet));
118: }
119: else
120: {
121: angle = (*((real8 *) (*s_objet_argument).objet));
122: }
123:
124: if (test_cfsf(s_etat_processus, 60) == d_faux)
125: {
126: conversion_degres_vers_radians(&angle);
127: }
128:
129: (*((real8 *) (*s_objet_resultat).objet)) = sin(angle);
130: }
131:
132: /*
133: --------------------------------------------------------------------------------
134: Sinus d'un complexe
135: --------------------------------------------------------------------------------
136: */
137:
138: else if ((*s_objet_argument).type == CPL)
139: {
140: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL)
141: {
142: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
143: return;
144: }
145:
146: f77sin_((struct_complexe16 *) (*s_objet_argument).objet,
147: (struct_complexe16 *) (*s_objet_resultat).objet);
148: }
149:
150: /*
151: --------------------------------------------------------------------------------
152: Sinus d'un nom
153: --------------------------------------------------------------------------------
154: */
155:
156: else if ((*s_objet_argument).type == NOM)
157: {
158: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
159: {
160: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
161: return;
162: }
163:
164: if (((*s_objet_resultat).objet =
165: allocation_maillon(s_etat_processus)) == NULL)
166: {
167: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
168: return;
169: }
170:
171: l_element_courant = (*s_objet_resultat).objet;
172:
173: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
174: == NULL)
175: {
176: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
177: return;
178: }
179:
180: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
181: .nombre_arguments = 0;
182: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
183: .fonction = instruction_vers_niveau_superieur;
184:
185: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
186: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
187: {
188: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
189: return;
190: }
191:
192: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
193: .nom_fonction, "<<");
194:
195: if (((*l_element_courant).suivant =
196: allocation_maillon(s_etat_processus)) == NULL)
197: {
198: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
199: return;
200: }
201:
202: l_element_courant = (*l_element_courant).suivant;
203: (*l_element_courant).donnee = s_objet_argument;
204:
205: if (((*l_element_courant).suivant =
206: allocation_maillon(s_etat_processus)) == NULL)
207: {
208: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
209: return;
210: }
211:
212: l_element_courant = (*l_element_courant).suivant;
213:
214: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
215: == NULL)
216: {
217: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
218: return;
219: }
220:
221: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
222: .nombre_arguments = 1;
223: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
224: .fonction = instruction_sin;
225:
226: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
227: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
228: {
229: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
230: return;
231: }
232:
233: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
234: .nom_fonction, "SIN");
235:
236: if (((*l_element_courant).suivant =
237: allocation_maillon(s_etat_processus)) == NULL)
238: {
239: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
240: return;
241: }
242:
243: l_element_courant = (*l_element_courant).suivant;
244:
245: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
246: == NULL)
247: {
248: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
249: return;
250: }
251:
252: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
253: .nombre_arguments = 0;
254: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
255: .fonction = instruction_vers_niveau_inferieur;
256:
257: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
258: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
259: {
260: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
261: return;
262: }
263:
264: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
265: .nom_fonction, ">>");
266:
267: (*l_element_courant).suivant = NULL;
268: s_objet_argument = NULL;
269: }
270:
271: /*
272: --------------------------------------------------------------------------------
273: Sinus d'une expression
274: --------------------------------------------------------------------------------
275: */
276:
277: else if (((*s_objet_argument).type == ALG) ||
278: ((*s_objet_argument).type == RPN))
279: {
280: if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument,
281: 'N')) == NULL)
282: {
283: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
284: return;
285: }
286:
287: l_element_courant = (struct_liste_chainee *)
288: (*s_copie_argument).objet;
289: l_element_precedent = l_element_courant;
290:
291: while((*l_element_courant).suivant != NULL)
292: {
293: l_element_precedent = l_element_courant;
294: l_element_courant = (*l_element_courant).suivant;
295: }
296:
297: if (((*l_element_precedent).suivant =
298: allocation_maillon(s_etat_processus)) == NULL)
299: {
300: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
301: return;
302: }
303:
304: if (((*(*l_element_precedent).suivant).donnee =
305: allocation(s_etat_processus, FCT)) == NULL)
306: {
307: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
308: return;
309: }
310:
311: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
312: .donnee).objet)).nombre_arguments = 1;
313: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
314: .donnee).objet)).fonction = instruction_sin;
315:
316: if (((*((struct_fonction *) (*(*(*l_element_precedent)
317: .suivant).donnee).objet)).nom_fonction =
318: malloc(4 * sizeof(unsigned char))) == NULL)
319: {
320: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
321: return;
322: }
323:
324: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
325: .suivant).donnee).objet)).nom_fonction, "SIN");
326:
327: (*(*l_element_precedent).suivant).suivant = l_element_courant;
328:
329: s_objet_resultat = s_copie_argument;
330: }
331:
332: /*
333: --------------------------------------------------------------------------------
334: Réalisation impossible de la fonction sinus
335: --------------------------------------------------------------------------------
336: */
337:
338: else
339: {
340: liberation(s_etat_processus, s_objet_argument);
341:
342: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
343: return;
344: }
345:
346: liberation(s_etat_processus, s_objet_argument);
347:
348: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
349: s_objet_resultat) == d_erreur)
350: {
351: return;
352: }
353:
354: return;
355: }
356:
357:
358: /*
359: ================================================================================
360: Fonction 'sinh'
361: ================================================================================
362: Entrées : pointeur sur une structure struct_processus
363: --------------------------------------------------------------------------------
364: Sorties :
365: --------------------------------------------------------------------------------
366: Effets de bord : néant
367: ================================================================================
368: */
369:
370: void
371: instruction_sinh(struct_processus *s_etat_processus)
372: {
373: real8 argument;
374:
375: struct_liste_chainee *l_element_courant;
376: struct_liste_chainee *l_element_precedent;
377:
378: struct_objet *s_copie_argument;
379: struct_objet *s_objet_argument;
380: struct_objet *s_objet_resultat;
381:
382: (*s_etat_processus).erreur_execution = d_ex;
383:
384: if ((*s_etat_processus).affichage_arguments == 'Y')
385: {
386: printf("\n SINH ");
387:
388: if ((*s_etat_processus).langue == 'F')
389: {
390: printf("(sinus hyperbolique)\n\n");
391: }
392: else
393: {
394: printf("(hyperbolic sine)\n\n");
395: }
396:
397: printf(" 1: %s, %s\n", d_INT, d_REL);
398: printf("-> 1: %s\n\n", d_INT);
399:
400: printf(" 1: %s\n", d_CPL);
401: printf("-> 1: %s\n\n", d_CPL);
402:
403: printf(" 1: %s, %s\n", d_NOM, d_ALG);
404: printf("-> 1: %s\n\n", d_ALG);
405:
406: printf(" 1: %s\n", d_RPN);
407: printf("-> 1: %s\n", d_RPN);
408:
409: return;
410: }
411: else if ((*s_etat_processus).test_instruction == 'Y')
412: {
413: (*s_etat_processus).nombre_arguments = 1;
414: return;
415: }
416:
417: if (test_cfsf(s_etat_processus, 31) == d_vrai)
418: {
419: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
420: {
421: return;
422: }
423: }
424:
425: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
426: &s_objet_argument) == d_erreur)
427: {
428: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
429: return;
430: }
431:
432: /*
433: --------------------------------------------------------------------------------
434: Sinus hyperbolique d'un entier ou d'un réel
435: --------------------------------------------------------------------------------
436: */
437:
438: if (((*s_objet_argument).type == INT) ||
439: ((*s_objet_argument).type == REL))
440: {
441: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
442: {
443: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
444: return;
445: }
446:
447: if ((*s_objet_argument).type == INT)
448: {
449: argument = (real8) (*((integer8 *) (*s_objet_argument).objet));
450: }
451: else
452: {
453: argument = (*((real8 *) (*s_objet_argument).objet));
454: }
455:
456: (*((real8 *) (*s_objet_resultat).objet)) = sinh(argument);
457: }
458:
459: /*
460: --------------------------------------------------------------------------------
461: Sinus hyperbolique d'un complexe
462: --------------------------------------------------------------------------------
463: */
464:
465: else if ((*s_objet_argument).type == CPL)
466: {
467: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL)
468: {
469: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
470: return;
471: }
472:
473: f77sinh_((struct_complexe16 *) (*s_objet_argument).objet,
474: (struct_complexe16 *) (*s_objet_resultat).objet);
475: }
476:
477: /*
478: --------------------------------------------------------------------------------
479: Sinus hyperbolique d'un nom
480: --------------------------------------------------------------------------------
481: */
482:
483: else if ((*s_objet_argument).type == NOM)
484: {
485: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
486: {
487: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
488: return;
489: }
490:
491: if (((*s_objet_resultat).objet =
492: allocation_maillon(s_etat_processus)) == NULL)
493: {
494: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
495: return;
496: }
497:
498: l_element_courant = (*s_objet_resultat).objet;
499:
500: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
501: == NULL)
502: {
503: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
504: return;
505: }
506:
507: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
508: .nombre_arguments = 0;
509: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
510: .fonction = instruction_vers_niveau_inferieur;
511:
512: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
513: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
514: {
515: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
516: return;
517: }
518:
519: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
520: .nom_fonction, "<<");
521:
522: if (((*l_element_courant).suivant =
523: allocation_maillon(s_etat_processus)) == NULL)
524: {
525: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
526: return;
527: }
528:
529: l_element_courant = (*l_element_courant).suivant;
530: (*l_element_courant).donnee = s_objet_argument;
531:
532: if (((*l_element_courant).suivant =
533: allocation_maillon(s_etat_processus)) == NULL)
534: {
535: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
536: return;
537: }
538:
539: l_element_courant = (*l_element_courant).suivant;
540:
541: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
542: == NULL)
543: {
544: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
545: return;
546: }
547:
548: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
549: .nombre_arguments = 1;
550: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
551: .fonction = instruction_sinh;
552:
553: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
554: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
555: {
556: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
557: return;
558: }
559:
560: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
561: .nom_fonction, "SINH");
562:
563: if (((*l_element_courant).suivant =
564: allocation_maillon(s_etat_processus)) == NULL)
565: {
566: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
567: return;
568: }
569:
570: l_element_courant = (*l_element_courant).suivant;
571:
572: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
573: == NULL)
574: {
575: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
576: return;
577: }
578:
579: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
580: .nombre_arguments = 0;
581: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
582: .fonction = instruction_vers_niveau_inferieur;
583:
584: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
585: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
586: {
587: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
588: return;
589: }
590:
591: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
592: .nom_fonction, ">>");
593:
594: (*l_element_courant).suivant = NULL;
595: s_objet_argument = NULL;
596: }
597:
598: /*
599: --------------------------------------------------------------------------------
600: Sinus hyperbolique d'une expression
601: --------------------------------------------------------------------------------
602: */
603:
604: else if (((*s_objet_argument).type == ALG) ||
605: ((*s_objet_argument).type == RPN))
606: {
607: if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument,
608: 'N')) == NULL)
609: {
610: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
611: return;
612: }
613:
614: l_element_courant = (struct_liste_chainee *)
615: (*s_copie_argument).objet;
616: l_element_precedent = l_element_courant;
617:
618: while((*l_element_courant).suivant != NULL)
619: {
620: l_element_precedent = l_element_courant;
621: l_element_courant = (*l_element_courant).suivant;
622: }
623:
624: if (((*l_element_precedent).suivant =
625: allocation_maillon(s_etat_processus)) == NULL)
626: {
627: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
628: return;
629: }
630:
631: if (((*(*l_element_precedent).suivant).donnee =
632: allocation(s_etat_processus, FCT)) == NULL)
633: {
634: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
635: return;
636: }
637:
638: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
639: .donnee).objet)).nombre_arguments = 1;
640: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
641: .donnee).objet)).fonction = instruction_sinh;
642:
643: if (((*((struct_fonction *) (*(*(*l_element_precedent)
644: .suivant).donnee).objet)).nom_fonction =
645: malloc(5 * sizeof(unsigned char))) == NULL)
646: {
647: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
648: return;
649: }
650:
651: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
652: .suivant).donnee).objet)).nom_fonction, "SINH");
653:
654: (*(*l_element_precedent).suivant).suivant = l_element_courant;
655:
656: s_objet_resultat = s_copie_argument;
657: }
658:
659: /*
660: --------------------------------------------------------------------------------
661: Réalisation impossible de la fonction sinus hyperbolique
662: --------------------------------------------------------------------------------
663: */
664:
665: else
666: {
667: liberation(s_etat_processus, s_objet_argument);
668:
669: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
670: return;
671: }
672:
673: liberation(s_etat_processus, s_objet_argument);
674:
675: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
676: s_objet_resultat) == d_erreur)
677: {
678: return;
679: }
680:
681: return;
682: }
683:
684:
685: /*
686: ================================================================================
687: Fonction 'size'
688: ================================================================================
689: Entrées : pointeur sur une structure struct_processus
690: --------------------------------------------------------------------------------
691: Sorties :
692: --------------------------------------------------------------------------------
693: Effets de bord : néant
694: ================================================================================
695: */
696:
697: void
698: instruction_size(struct_processus *s_etat_processus)
699: {
700: struct_liste_chainee *l_element_courant;
701:
702: struct_objet *s_objet_argument;
703: struct_objet *s_objet_resultat;
704:
705: (*s_etat_processus).erreur_execution = d_ex;
706:
707: if ((*s_etat_processus).affichage_arguments == 'Y')
708: {
709: printf("\n SIZE ");
710:
711: if ((*s_etat_processus).langue == 'F')
712: {
713: printf("(taille d'un objet)\n\n");
714: }
715: else
716: {
717: printf("(object size)\n\n");
718: }
719:
720: printf(" 1: %s, %s, %s, %s\n", d_CHN, d_LST, d_ALG, d_TAB);
721: printf("-> 1: %s\n\n", d_INT);
722:
723: printf(" 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
724: printf("-> 1: %s\n\n", d_LST);
725:
726: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
727: printf("-> 1: %s\n", d_LST);
728:
729: return;
730: }
731: else if ((*s_etat_processus).test_instruction == 'Y')
732: {
733: (*s_etat_processus).nombre_arguments = -1;
734: return;
735: }
736:
737: if (test_cfsf(s_etat_processus, 31) == d_vrai)
738: {
739: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
740: {
741: return;
742: }
743: }
744:
745: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
746: &s_objet_argument) == d_erreur)
747: {
748: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
749: return;
750: }
751:
752: /*
753: --------------------------------------------------------------------------------
754: Chaîne de caractères
755: --------------------------------------------------------------------------------
756: */
757:
758: if ((*s_objet_argument).type == CHN)
759: {
760: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
761: {
762: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
763: return;
764: }
765:
766: (*((integer8 *) (*s_objet_resultat).objet)) =
1.35 bertrand 767: longueur_chaine(s_etat_processus,
768: (unsigned char *) (*s_objet_argument).objet);
1.1 bertrand 769: }
770:
771: /*
772: --------------------------------------------------------------------------------
773: Liste
774: --------------------------------------------------------------------------------
775: */
776:
777: else if ((*s_objet_argument).type == LST)
778: {
779: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
780: {
781: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
782: return;
783: }
784:
785: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
786: l_element_courant = (*s_objet_argument).objet;
787:
788: while(l_element_courant != NULL)
789: {
790: (*((integer8 *) (*s_objet_resultat).objet))++;
791: l_element_courant = (*l_element_courant).suivant;
792: }
793: }
794:
795: /*
796: --------------------------------------------------------------------------------
797: Expression algébrique
798: --------------------------------------------------------------------------------
799: */
800:
801: else if ((*s_objet_argument).type == ALG)
802: {
803: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
804: {
805: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
806: return;
807: }
808:
809: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
810: l_element_courant = (*s_objet_argument).objet;
811:
812: while(l_element_courant != NULL)
813: {
814: (*((integer8 *) (*s_objet_resultat).objet))++;
815: l_element_courant = (*l_element_courant).suivant;
816: }
817:
818: (*((integer8 *) (*s_objet_resultat).objet)) -= 2;
819: }
820:
821: /*
822: --------------------------------------------------------------------------------
823: Table
824: --------------------------------------------------------------------------------
825: */
826:
827: else if ((*s_objet_argument).type == TBL)
828: {
829: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
830: {
831: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
832: return;
833: }
834:
835: (*((integer8 *) (*s_objet_resultat).objet)) = (*((struct_tableau *)
836: (*s_objet_argument).objet)).nombre_elements;
837: }
838:
839: /*
840: --------------------------------------------------------------------------------
841: Vecteur
842: --------------------------------------------------------------------------------
843: */
844:
845: else if (((*s_objet_argument).type == VIN) ||
846: ((*s_objet_argument).type == VRL) ||
847: ((*s_objet_argument).type == VCX))
848: {
849: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
850: {
851: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
852: return;
853: }
854:
855: if (((*s_objet_resultat).objet =
856: allocation_maillon(s_etat_processus)) == NULL)
857: {
858: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
859: return;
860: }
861:
862: l_element_courant = (*s_objet_resultat).objet;
863: (*l_element_courant).suivant = NULL;
864:
865: if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
866: == NULL)
867: {
868: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
869: return;
870: }
871:
872: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
873: (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
874: }
875:
876: /*
877: --------------------------------------------------------------------------------
878: Matrice
879: --------------------------------------------------------------------------------
880: */
881:
882: else if (((*s_objet_argument).type == MIN) ||
883: ((*s_objet_argument).type == MRL) ||
884: ((*s_objet_argument).type == MCX))
885: {
886: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
887: {
888: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
889: return;
890: }
891:
892: if (((*s_objet_resultat).objet =
893: allocation_maillon(s_etat_processus)) == NULL)
894: {
895: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
896: return;
897: }
898:
899: l_element_courant = (*s_objet_resultat).objet;
900:
901: if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
902: == NULL)
903: {
904: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
905: return;
906: }
907:
908: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
909: (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;
910:
911: if (((*l_element_courant).suivant =
912: allocation_maillon(s_etat_processus)) == NULL)
913: {
914: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
915: return;
916: }
917:
918: l_element_courant = (*l_element_courant).suivant;
919: (*l_element_courant).suivant = NULL;
920:
921: if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
922: == NULL)
923: {
924: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
925: return;
926: }
927:
928: (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
929: (*((struct_matrice *) (*s_objet_argument).objet))
930: .nombre_colonnes;
931: }
932:
933: /*
934: --------------------------------------------------------------------------------
935: Type d'argument invalide
936: --------------------------------------------------------------------------------
937: */
938:
939: else
940: {
941: liberation(s_etat_processus, s_objet_argument);
942:
943: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
944: return;
945: }
946:
947: liberation(s_etat_processus, s_objet_argument);
948:
949: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
950: s_objet_resultat) == d_erreur)
951: {
952: return;
953: }
954:
955: return;
956: }
957:
958:
959: /*
960: ================================================================================
961: Fonction 'sst'
962: ================================================================================
963: Entrées : pointeur sur une structure struct_processus
964: --------------------------------------------------------------------------------
965: Sorties :
966: --------------------------------------------------------------------------------
967: Effets de bord : néant
968: ================================================================================
969: */
970:
971: void
972: instruction_sst(struct_processus *s_etat_processus)
973: {
974: (*s_etat_processus).erreur_execution = d_ex;
975:
976: if ((*s_etat_processus).affichage_arguments == 'Y')
977: {
978: printf("\n SST ");
979:
980: if ((*s_etat_processus).langue == 'F')
981: {
982: printf("(avance d'un pas)\n\n");
983: printf(" Aucun argument\n");
984: }
985: else
986: {
987: printf("(single step)\n\n");
988: printf(" No argument\n");
989: }
990:
991: return;
992: }
993: else if ((*s_etat_processus).test_instruction == 'Y')
994: {
995: (*s_etat_processus).nombre_arguments = -1;
996: return;
997: }
998:
999: if ((*s_etat_processus).traitement_instruction_halt == d_vrai)
1000: {
1001: (*s_etat_processus).execution_pas_suivant = d_vrai;
1002: }
1003:
1004: return;
1005: }
1006:
1007:
1008: /*
1009: ================================================================================
1010: Fonction 'str->'
1011: ================================================================================
1012: Entrées : pointeur sur une structure struct_processus
1013: --------------------------------------------------------------------------------
1014: Sorties :
1015: --------------------------------------------------------------------------------
1016: Effets de bord : néant
1017: ================================================================================
1018: */
1019:
1020: void
1021: instruction_str_fleche(struct_processus *s_etat_processus)
1022: {
1.4 bertrand 1023: logical1 drapeau45;
1024: logical1 presence_chaine;
1025:
1.1 bertrand 1026: struct_objet *s_objet;
1027: struct_objet *s_sous_objet;
1028:
1029: unsigned char *commande;
1.4 bertrand 1030: unsigned char *chaine_convertie;
1031: unsigned char *ptr_e;
1032: unsigned char *ptr_l;
1.1 bertrand 1033: unsigned char *registre_definitions_chainees;
1034: unsigned char *registre_instruction_courante;
1035: unsigned char registre_interruption;
1.4 bertrand 1036: unsigned char *tampon;
1.1 bertrand 1037:
1.48 bertrand 1038: integer8 nombre_caracteres_supplementaires;
1039: integer8 position_courante;
1.1 bertrand 1040:
1041: (*s_etat_processus).erreur_execution = d_ex;
1042:
1043: if ((*s_etat_processus).affichage_arguments == 'Y')
1044: {
1045: printf("\n STR-> ");
1046:
1047: if ((*s_etat_processus).langue == 'F')
1048: {
1049: printf("(conversion d'une chaîne)\n\n");
1050: }
1051: else
1052: {
1053: printf("(conversion from a string of chars)\n\n");
1054: }
1055:
1056: printf(" 1: %s\n", d_INT);
1057: printf("-> n: %s, %s, %s, %s, %s, %s,\n"
1058: " %s, %s, %s, %s, %s,\n"
1059: " %s, %s, %s, %s, %s,\n"
1060: " %s\n",
1061: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
1062: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
1063: printf(" ...\n");
1064: printf("-> 1: %s, %s, %s, %s, %s, %s,\n"
1065: " %s, %s, %s, %s, %s,\n"
1066: " %s, %s, %s, %s, %s,\n"
1067: " %s\n",
1068: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
1069: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
1070:
1071: return;
1072: }
1073: else if ((*s_etat_processus).test_instruction == 'Y')
1074: {
1075: (*s_etat_processus).nombre_arguments = -1;
1076: return;
1077: }
1078:
1079: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1080: {
1081: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1082: {
1083: return;
1084: }
1085: }
1086:
1087: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1088: &s_objet) == d_erreur)
1089: {
1090: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1091: return;
1092: }
1093:
1094: if ((*s_objet).type == CHN)
1095: {
1.4 bertrand 1096: // Comptage des caractères à protéger.
1097:
1098: drapeau45 = test_cfsf(s_etat_processus, 45);
1099: cf(s_etat_processus, 45);
1100:
1101: tampon = formateur(s_etat_processus, 0, s_objet);
1102:
1103: if (drapeau45 == d_vrai)
1104: {
1105: sf(s_etat_processus, 45);
1106: }
1107: else
1108: {
1109: cf(s_etat_processus, 45);
1110: }
1111:
1112: ptr_l = tampon;
1113: presence_chaine = d_faux;
1114: nombre_caracteres_supplementaires = 0;
1115:
1116: while((*ptr_l) != d_code_fin_chaine)
1117: {
1118: if ((*ptr_l) == '"')
1119: {
1120: presence_chaine = (presence_chaine == d_faux) ? d_vrai : d_faux;
1121: }
1122:
1123: if (presence_chaine == d_vrai)
1124: {
1.5 bertrand 1125: switch(*ptr_l)
1.4 bertrand 1126: {
1.5 bertrand 1127: case '\\':
1128: case '\t':
1129: case '\b':
1130: case '\n':
1131: {
1132: nombre_caracteres_supplementaires++;
1133: break;
1134: }
1135: }
1136: }
1137: else
1138: {
1139: switch(*ptr_l)
1140: {
1141: case '\n':
1142: case '\b':
1143: case '\t':
1144: {
1145: nombre_caracteres_supplementaires--;
1146: break;
1147: }
1.4 bertrand 1148: }
1149: }
1150:
1151: ptr_l++;
1152: }
1153:
1154: // Échappement des caractères et remplacement dans les chaînes
1155: // de caractères incluses. Le seul caractère protégé est le '\'
1156: // qui est doublé.
1157:
1.48 bertrand 1158: if ((chaine_convertie = malloc((strlen(tampon) + ((size_t)
1159: nombre_caracteres_supplementaires) + 1) *
1160: sizeof(unsigned char))) == NULL)
1.4 bertrand 1161: {
1162: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1163: return;
1164: }
1165:
1166: ptr_l = tampon;
1167: ptr_e = chaine_convertie;
1168: presence_chaine = d_faux;
1169:
1170: while((*ptr_l) != d_code_fin_chaine)
1171: {
1172: if ((*ptr_l) == '"')
1173: {
1174: presence_chaine = (presence_chaine == d_faux) ? d_vrai : d_faux;
1175: }
1176:
1177: (*ptr_e) = (*ptr_l);
1178:
1179: if (presence_chaine == d_vrai)
1180: {
1.5 bertrand 1181: switch(*ptr_l)
1182: {
1183: case '\\':
1184: {
1185: (*(++ptr_e)) = '\\';
1186: break;
1187: }
1188:
1189: case '\t':
1190: {
1191: (*ptr_e) = '\\';
1192: (*(++ptr_e)) = 't';
1193: break;
1194: }
1195:
1196: case '\b':
1197: {
1198: (*ptr_e) = '\\';
1199: (*(++ptr_e)) = 'b';
1200: break;
1201: }
1202:
1203: case '\n':
1204: {
1205: (*ptr_e) = '\\';
1206: (*(++ptr_e)) = 'n';
1207: break;
1208: }
1209: }
1210: }
1211: else
1212: {
1213: switch(*ptr_l)
1.4 bertrand 1214: {
1.5 bertrand 1215: case '\n':
1216: case '\b':
1217: case '\t':
1218: {
1219: ptr_e--;
1220: break;
1221: }
1.4 bertrand 1222: }
1223: }
1224:
1225: ptr_l++;
1226: ptr_e++;
1227: }
1228:
1229: (*ptr_e) = d_code_fin_chaine;
1230:
1.6 bertrand 1231: position_courante = (*s_etat_processus).position_courante;
1232: registre_definitions_chainees = (*s_etat_processus)
1233: .definitions_chainees;
1234: registre_instruction_courante = (*s_etat_processus)
1235: .instruction_courante;
1236: (*s_etat_processus).position_courante = 0;
1.4 bertrand 1237: (*s_etat_processus).definitions_chainees = chaine_convertie;
1238: free(tampon);
1239:
1240: if ((*s_etat_processus).definitions_chainees == NULL)
1241: {
1242: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1243: return;
1244: }
1.1 bertrand 1245:
1246: if (analyse_syntaxique(s_etat_processus) == d_absence_erreur)
1247: {
1248: if ((commande = malloc((strlen((unsigned char *)
1249: (*s_objet).objet) + 7) * sizeof(unsigned char))) == NULL)
1250: {
1251: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1252: return;
1253: }
1254:
1.4 bertrand 1255: sprintf(commande, "<< %s >>", (*s_etat_processus)
1256: .definitions_chainees);
1.1 bertrand 1257: (*s_etat_processus).instruction_courante = commande;
1258:
1.56 bertrand 1259: (*s_etat_processus).type_en_cours = NON;
1.1 bertrand 1260: recherche_type(s_etat_processus);
1261:
1.13 bertrand 1262: if (((*s_etat_processus).erreur_execution != d_ex) ||
1263: ((*s_etat_processus).erreur_systeme != d_es))
1.1 bertrand 1264: {
1265: liberation(s_etat_processus, s_objet);
1266:
1.4 bertrand 1267: free((*s_etat_processus).definitions_chainees);
1268: free((*s_etat_processus).instruction_courante);
1269:
1.1 bertrand 1270: (*s_etat_processus).definitions_chainees =
1271: registre_definitions_chainees;
1272: (*s_etat_processus).instruction_courante =
1273: registre_instruction_courante;
1274: (*s_etat_processus).position_courante =
1275: position_courante;
1276:
1277: return;
1278: }
1279:
1280: if (depilement(s_etat_processus, &((*s_etat_processus)
1281: .l_base_pile), &s_sous_objet) == d_erreur)
1282: {
1283: liberation(s_etat_processus, s_objet);
1.4 bertrand 1284: free((*s_etat_processus).definitions_chainees);
1285: free((*s_etat_processus).instruction_courante);
1.1 bertrand 1286:
1287: (*s_etat_processus).definitions_chainees =
1288: registre_definitions_chainees;
1289: (*s_etat_processus).instruction_courante =
1290: registre_instruction_courante;
1291: (*s_etat_processus).position_courante =
1292: position_courante;
1293:
1294: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1295: return;
1296: }
1297:
1298: registre_interruption = (*s_etat_processus)
1299: .traitement_interruptible;
1300: (*s_etat_processus).traitement_interruptible = 'N';
1301:
1302: if (evaluation(s_etat_processus, s_sous_objet, 'I') == d_erreur)
1303: {
1.4 bertrand 1304: liberation(s_etat_processus, s_sous_objet);
1305: liberation(s_etat_processus, s_objet);
1306:
1307: free((*s_etat_processus).definitions_chainees);
1308: free((*s_etat_processus).instruction_courante);
1309:
1310: (*s_etat_processus).definitions_chainees =
1311: registre_definitions_chainees;
1312: (*s_etat_processus).instruction_courante =
1313: registre_instruction_courante;
1314: (*s_etat_processus).position_courante =
1315: position_courante;
1316:
1.1 bertrand 1317: (*s_etat_processus).traitement_interruptible =
1318: registre_interruption;
1319:
1320: if ((*s_etat_processus).erreur_systeme == d_es)
1321: {
1322: (*s_etat_processus).erreur_execution =
1323: d_ex_expression_invalide;
1324: }
1325: else
1326: {
1327: (*s_etat_processus).erreur_systeme =
1328: d_es_allocation_memoire;
1329: }
1.4 bertrand 1330:
1331: return;
1.1 bertrand 1332: }
1333: }
1334: else
1335: {
1.4 bertrand 1336: liberation(s_etat_processus, s_objet);
1337:
1338: free((*s_etat_processus).definitions_chainees);
1339: free((*s_etat_processus).instruction_courante);
1340:
1.1 bertrand 1341: (*s_etat_processus).definitions_chainees =
1342: registre_definitions_chainees;
1343: (*s_etat_processus).instruction_courante =
1344: registre_instruction_courante;
1345: (*s_etat_processus).position_courante =
1346: position_courante;
1347:
1348: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1349:
1350: return;
1351: }
1352:
1.4 bertrand 1353:
1354: (*s_etat_processus).traitement_interruptible =
1355: registre_interruption;
1356:
1357: liberation(s_etat_processus, s_sous_objet);
1358:
1359: free((*s_etat_processus).definitions_chainees);
1360: free((*s_etat_processus).instruction_courante);
1361:
1.1 bertrand 1362: (*s_etat_processus).definitions_chainees =
1363: registre_definitions_chainees;
1364: (*s_etat_processus).instruction_courante =
1365: registre_instruction_courante;
1366: (*s_etat_processus).position_courante =
1367: position_courante;
1368: }
1369: else
1370: {
1371: liberation(s_etat_processus, s_objet);
1372:
1373: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1374: return;
1375: }
1376:
1377: liberation(s_etat_processus, s_objet);
1378:
1379: return;
1380: }
1381:
1382: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src