Annotation of rpl/src/instructions_x1.c, revision 1.66
1.1 bertrand 1: /*
2: ================================================================================
1.65 bertrand 3: RPL/2 (R) version 4.1.32
1.66 ! 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.11 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'xor'
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_xor(struct_processus *s_etat_processus)
40: {
41: struct_liste_chainee *l_element_courant;
42: struct_liste_chainee *l_element_precedent;
43:
44: struct_objet *s_copie_argument_1;
45: struct_objet *s_copie_argument_2;
46: struct_objet *s_objet_argument_1;
47: struct_objet *s_objet_argument_2;
48: struct_objet *s_objet_resultat;
49:
1.41 bertrand 50: integer8 nombre_elements;
1.1 bertrand 51:
52: (*s_etat_processus).erreur_execution = d_ex;
53:
54: if ((*s_etat_processus).affichage_arguments == 'Y')
55: {
56: printf("\n XOR ");
57:
58: if ((*s_etat_processus).langue == 'F')
59: {
60: printf("(opérateur ou exclusif)\n\n");
61: }
62: else
63: {
64: printf("(exclusive or operator)\n\n");
65: }
66:
67: printf(" 2: %s, %s\n", d_INT, d_REL);
68: printf(" 1: %s, %s\n", d_INT, d_REL);
69: printf("-> 1: %s\n\n", d_INT);
70:
71: printf(" 2: %s\n", d_BIN);
72: printf(" 1: %s\n", d_BIN);
73: printf("-> 1: %s\n\n", d_BIN);
74:
75: printf(" 2: %s\n", d_NOM);
76: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
77: printf("-> 1: %s\n\n", d_ALG);
78:
79: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
80: printf(" 1: %s\n", d_NOM);
81: printf("-> 1: %s\n\n", d_ALG);
82:
83: printf(" 2: %s\n", d_ALG);
84: printf(" 1: %s\n", d_ALG);
85: printf("-> 1: %s\n\n", d_ALG);
86:
87: printf(" 2: %s\n", d_RPN);
88: printf(" 1: %s\n", d_RPN);
89: printf("-> 1: %s\n", d_RPN);
90:
91: return;
92: }
93: else if ((*s_etat_processus).test_instruction == 'Y')
94: {
95: (*s_etat_processus).nombre_arguments = 0;
96: return;
97: }
98:
99: if (test_cfsf(s_etat_processus, 31) == d_vrai)
100: {
101: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
102: {
103: return;
104: }
105: }
106:
107: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
108: &s_objet_argument_1) == d_erreur)
109: {
110: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
111: return;
112: }
113:
114: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
115: &s_objet_argument_2) == d_erreur)
116: {
117: liberation(s_etat_processus, s_objet_argument_1);
118:
119: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
120: return;
121: }
122:
123: /*
124: --------------------------------------------------------------------------------
125: XOR logique
126: --------------------------------------------------------------------------------
127: */
128:
129: if ((((*s_objet_argument_1).type == INT) ||
130: ((*s_objet_argument_1).type == REL)) &&
131: (((*s_objet_argument_2).type == INT) ||
132: ((*s_objet_argument_2).type == REL)))
133: {
134: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
135: {
136: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
137: return;
138: }
139:
140: if ((*s_objet_argument_1).type == INT)
141: {
142: if ((*s_objet_argument_2).type == INT)
143: {
144: if ((((*((integer8 *) (*s_objet_argument_1).objet)) == 0) &&
145: ((*((integer8 *) (*s_objet_argument_2).objet)) != 0))
146: || (((*((integer8 *) (*s_objet_argument_1).objet))
147: != 0) && ((*((integer8 *) (*s_objet_argument_2).objet))
1.49 bertrand 148: == 0)))
1.1 bertrand 149: {
150: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
151: }
152: else
153: {
154: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
155: }
156: }
157: else
158: {
159: if ((((*((integer8 *) (*s_objet_argument_1).objet)) == 0) &&
160: ((*((real8 *) (*s_objet_argument_2).objet)) != 0))
161: || (((*((integer8 *) (*s_objet_argument_1).objet))
162: != 0) && ((*((real8 *) (*s_objet_argument_2).objet))
1.49 bertrand 163: == 0)))
1.1 bertrand 164: {
165: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
166: }
167: else
168: {
169: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
170: }
171: }
172: }
173: else
174: {
175: if ((*s_objet_argument_2).type == INT)
176: {
177: if ((((*((real8 *) (*s_objet_argument_1).objet)) == 0) &&
178: ((*((integer8 *) (*s_objet_argument_2).objet)) != 0))
179: || (((*((real8 *) (*s_objet_argument_1).objet))
180: != 0) && ((*((integer8 *) (*s_objet_argument_2).objet))
1.49 bertrand 181: == 0)))
1.1 bertrand 182: {
183: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
184: }
185: else
186: {
187: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
188: }
189: }
190: else
191: {
192: if ((((*((real8 *) (*s_objet_argument_1).objet)) == 0) &&
193: ((*((real8 *) (*s_objet_argument_2).objet)) != 0))
194: || (((*((real8 *) (*s_objet_argument_1).objet))
195: != 0) && ((*((real8 *) (*s_objet_argument_2).objet))
1.49 bertrand 196: == 0)))
1.1 bertrand 197: {
198: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
199: }
200: else
201: {
202: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
203: }
204: }
205: }
206: }
207:
208: /*
209: --------------------------------------------------------------------------------
210: XOR binaire
211: --------------------------------------------------------------------------------
212: */
213:
214: else if (((*s_objet_argument_1).type == BIN) &&
215: ((*s_objet_argument_2).type == BIN))
216: {
217: if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
218: {
219: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
220: return;
221: }
222:
223: (*((logical8 *) (*s_objet_resultat).objet)) =
224: (*((logical8 *) (*s_objet_argument_1).objet)) ^
225: (*((logical8 *) (*s_objet_argument_2).objet));
226: }
227:
228: /*
229: --------------------------------------------------------------------------------
230: XOR entre des arguments complexes
231: --------------------------------------------------------------------------------
232: */
233:
234: /*
235: * Nom ou valeur numérique / Nom ou valeur numérique
236: */
237:
238: else if ((((*s_objet_argument_1).type == NOM) &&
239: (((*s_objet_argument_2).type == NOM) ||
240: ((*s_objet_argument_2).type == INT) ||
241: ((*s_objet_argument_2).type == REL))) ||
242: (((*s_objet_argument_2).type == NOM) &&
243: (((*s_objet_argument_1).type == INT) ||
244: ((*s_objet_argument_1).type == REL))))
245: {
246: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
247: {
248: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
249: return;
250: }
251:
252: if (((*s_objet_resultat).objet =
253: allocation_maillon(s_etat_processus)) == NULL)
254: {
255: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
256: return;
257: }
258:
259: l_element_courant = (*s_objet_resultat).objet;
260:
261: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
262: == NULL)
263: {
264: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
265: return;
266: }
267:
268: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
269: .nombre_arguments = 0;
270: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
271: .fonction = instruction_vers_niveau_superieur;
272:
273: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
274: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
275: {
276: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
277: return;
278: }
279:
280: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
281: .nom_fonction, "<<");
282:
283: if (((*l_element_courant).suivant =
284: allocation_maillon(s_etat_processus)) == NULL)
285: {
286: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
287: return;
288: }
289:
290: l_element_courant = (*l_element_courant).suivant;
291: (*l_element_courant).donnee = s_objet_argument_2;
292:
293: if (((*l_element_courant).suivant =
294: allocation_maillon(s_etat_processus)) == NULL)
295: {
296: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
297: return;
298: }
299:
300: l_element_courant = (*l_element_courant).suivant;
301: (*l_element_courant).donnee = s_objet_argument_1;
302:
303: if (((*l_element_courant).suivant =
304: allocation_maillon(s_etat_processus)) == NULL)
305: {
306: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
307: return;
308: }
309:
310: l_element_courant = (*l_element_courant).suivant;
311:
312: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
313: == NULL)
314: {
315: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
316: return;
317: }
318:
319: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
320: .nombre_arguments = 0;
321: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
322: .fonction = instruction_xor;
323:
324: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
325: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
326: {
327: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
328: return;
329: }
330:
331: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
332: .nom_fonction, "XOR");
333:
334: if (((*l_element_courant).suivant =
335: allocation_maillon(s_etat_processus)) == NULL)
336: {
337: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
338: return;
339: }
340:
341: l_element_courant = (*l_element_courant).suivant;
342:
343: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
344: == NULL)
345: {
346: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
347: return;
348: }
349:
350: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
351: .nombre_arguments = 0;
352: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
353: .fonction = instruction_vers_niveau_inferieur;
354:
355: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
356: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
357: {
358: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
359: return;
360: }
361:
362: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
363: .nom_fonction, ">>");
364:
365: (*l_element_courant).suivant = NULL;
366:
367: s_objet_argument_1 = NULL;
368: s_objet_argument_2 = NULL;
369: }
370:
371: /*
372: * Nom ou valeur numérique / Expression
373: */
374:
375: else if ((((*s_objet_argument_1).type == ALG) ||
376: ((*s_objet_argument_1).type == RPN)) &&
377: (((*s_objet_argument_2).type == NOM) ||
378: ((*s_objet_argument_2).type == INT) ||
379: ((*s_objet_argument_2).type == REL)))
380: {
381: nombre_elements = 0;
382: l_element_courant = (struct_liste_chainee *)
383: (*s_objet_argument_1).objet;
384:
385: while(l_element_courant != NULL)
386: {
387: nombre_elements++;
388: l_element_courant = (*l_element_courant).suivant;
389: }
390:
391: if (nombre_elements == 2)
392: {
393: liberation(s_etat_processus, s_objet_argument_1);
394: liberation(s_etat_processus, s_objet_argument_2);
395:
396: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
397: return;
398: }
399:
400: if ((s_objet_resultat = copie_objet(s_etat_processus,
401: s_objet_argument_1, 'N')) == NULL)
402: {
403: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
404: return;
405: }
406:
407: l_element_courant = (struct_liste_chainee *)
408: (*s_objet_resultat).objet;
409: l_element_precedent = l_element_courant;
410: l_element_courant = (*l_element_courant).suivant;
411:
412: if (((*l_element_precedent).suivant = (struct_liste_chainee *)
413: allocation_maillon(s_etat_processus)) == NULL)
414: {
415: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
416: return;
417: }
418:
419: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
420: (*(*l_element_precedent).suivant).suivant = l_element_courant;
421:
422: while((*l_element_courant).suivant != NULL)
423: {
424: l_element_precedent = l_element_courant;
425: l_element_courant = (*l_element_courant).suivant;
426: }
427:
428: if (((*l_element_precedent).suivant =
429: allocation_maillon(s_etat_processus)) == NULL)
430: {
431: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
432: return;
433: }
434:
435: if (((*(*l_element_precedent).suivant).donnee =
436: allocation(s_etat_processus, FCT)) == NULL)
437: {
438: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
439: return;
440: }
441:
442: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
443: .donnee).objet)).nombre_arguments = 0;
444: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
445: .donnee).objet)).fonction = instruction_xor;
446:
447: if (((*((struct_fonction *) (*(*(*l_element_precedent)
448: .suivant).donnee).objet)).nom_fonction =
449: malloc(4 * sizeof(unsigned char))) == NULL)
450: {
451: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
452: return;
453: }
454:
455: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
456: .suivant).donnee).objet)).nom_fonction, "XOR");
457:
458: (*(*l_element_precedent).suivant).suivant = l_element_courant;
459:
460: s_objet_argument_2 = NULL;
461: }
462:
463: /*
464: * Expression / Nom ou valeur numérique
465: */
466:
467: else if ((((*s_objet_argument_1).type == NOM) ||
468: ((*s_objet_argument_1).type == INT) ||
469: ((*s_objet_argument_1).type == REL)) &&
470: (((*s_objet_argument_2).type == ALG) ||
471: ((*s_objet_argument_2).type == RPN)))
472: {
473: nombre_elements = 0;
474: l_element_courant = (struct_liste_chainee *)
475: (*s_objet_argument_2).objet;
476:
477: while(l_element_courant != NULL)
478: {
479: nombre_elements++;
480: l_element_courant = (*l_element_courant).suivant;
481: }
482:
483: if (nombre_elements == 2)
484: {
485: liberation(s_etat_processus, s_objet_argument_1);
486: liberation(s_etat_processus, s_objet_argument_2);
487:
488: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
489: return;
490: }
491:
492: if ((s_objet_resultat = copie_objet(s_etat_processus,
493: s_objet_argument_2, 'N')) == NULL)
494: {
495: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
496: return;
497: }
498:
499: l_element_courant = (struct_liste_chainee *)
500: (*s_objet_resultat).objet;
501: l_element_precedent = l_element_courant;
502:
503: while((*l_element_courant).suivant != NULL)
504: {
505: l_element_precedent = l_element_courant;
506: l_element_courant = (*l_element_courant).suivant;
507: }
508:
509: if (((*l_element_precedent).suivant =
510: allocation_maillon(s_etat_processus)) == NULL)
511: {
512: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
513: return;
514: }
515:
516: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
517: l_element_precedent = (*l_element_precedent).suivant;
518:
519: if (((*l_element_precedent).suivant =
520: allocation_maillon(s_etat_processus)) == NULL)
521: {
522: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
523: return;
524: }
525:
526: if (((*(*l_element_precedent).suivant).donnee =
527: allocation(s_etat_processus, FCT)) == NULL)
528: {
529: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
530: return;
531: }
532:
533: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
534: .donnee).objet)).nombre_arguments = 0;
535: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
536: .donnee).objet)).fonction = instruction_xor;
537:
538: if (((*((struct_fonction *) (*(*(*l_element_precedent)
539: .suivant).donnee).objet)).nom_fonction =
540: malloc(4 * sizeof(unsigned char))) == NULL)
541: {
542: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
543: return;
544: }
545:
546: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
547: .suivant).donnee).objet)).nom_fonction, "XOR");
548:
549: (*(*l_element_precedent).suivant).suivant = l_element_courant;
550:
551: s_objet_argument_1 = NULL;
552: }
553:
554: /*
555: * Expression / Expression
556: */
557:
558: else if ((((*s_objet_argument_1).type == ALG) &&
559: ((*s_objet_argument_2).type == ALG)) ||
560: (((*s_objet_argument_1).type == RPN) &&
561: ((*s_objet_argument_2).type == RPN)))
562: {
563: nombre_elements = 0;
564: l_element_courant = (struct_liste_chainee *)
565: (*s_objet_argument_1).objet;
566:
567: while(l_element_courant != NULL)
568: {
569: nombre_elements++;
570: l_element_courant = (*l_element_courant).suivant;
571: }
572:
573: if (nombre_elements == 2)
574: {
575: liberation(s_etat_processus, s_objet_argument_1);
576: liberation(s_etat_processus, s_objet_argument_2);
577:
578: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
579: return;
580: }
581:
582: nombre_elements = 0;
583: l_element_courant = (struct_liste_chainee *)
584: (*s_objet_argument_2).objet;
585:
586: while(l_element_courant != NULL)
587: {
588: nombre_elements++;
589: l_element_courant = (*l_element_courant).suivant;
590: }
591:
592: if (nombre_elements == 2)
593: {
594: liberation(s_etat_processus, s_objet_argument_1);
595: liberation(s_etat_processus, s_objet_argument_2);
596:
597: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
598: return;
599: }
600:
601: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
602: s_objet_argument_1, 'N')) == NULL)
603: {
604: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
605: return;
606: }
607:
608: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
609: s_objet_argument_2, 'N')) == NULL)
610: {
611: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
612: return;
613: }
614:
615: l_element_courant = (struct_liste_chainee *)
616: (*s_copie_argument_1).objet;
617: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
618: (*s_copie_argument_1).objet)).suivant;
619:
620: liberation(s_etat_processus, (*l_element_courant).donnee);
621: free(l_element_courant);
622:
623: l_element_courant = (struct_liste_chainee *)
624: (*s_copie_argument_2).objet;
625: l_element_precedent = l_element_courant;
626: s_objet_resultat = s_copie_argument_2;
627:
628: while((*l_element_courant).suivant != NULL)
629: {
630: l_element_precedent = l_element_courant;
631: l_element_courant = (*l_element_courant).suivant;
632: }
633:
634: liberation(s_etat_processus, (*l_element_courant).donnee);
635: free(l_element_courant);
636:
637: (*l_element_precedent).suivant = (struct_liste_chainee *)
638: (*s_copie_argument_1).objet;
639: free(s_copie_argument_1);
640:
641: l_element_courant = (*l_element_precedent).suivant;
642: while((*l_element_courant).suivant != NULL)
643: {
644: l_element_precedent = l_element_courant;
645: l_element_courant = (*l_element_courant).suivant;
646: }
647:
648: if (((*l_element_precedent).suivant =
649: allocation_maillon(s_etat_processus)) == NULL)
650: {
651: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
652: return;
653: }
654:
655: (*(*l_element_precedent).suivant).suivant = l_element_courant;
656: l_element_courant = (*l_element_precedent).suivant;
657:
658: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
659: == NULL)
660: {
661: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
662: return;
663: }
664:
665: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
666: .nombre_arguments = 0;
667: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
668: .fonction = instruction_xor;
669:
670: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
671: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
672: {
673: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
674: return;
675: }
676:
677: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
678: .nom_fonction, "XOR");
679: }
680:
681: /*
682: --------------------------------------------------------------------------------
683: XOR impossible
684: --------------------------------------------------------------------------------
685: */
686:
687: else
688: {
689: liberation(s_etat_processus, s_objet_argument_1);
690: liberation(s_etat_processus, s_objet_argument_2);
691:
692: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
693: return;
694: }
695:
696: liberation(s_etat_processus, s_objet_argument_1);
697: liberation(s_etat_processus, s_objet_argument_2);
698:
699: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
700: s_objet_resultat) == d_erreur)
701: {
702: return;
703: }
704:
705: return;
706: }
707:
708:
709: /*
710: ================================================================================
711: Fonction 'xpon'
712: ================================================================================
713: Entrées :
714: --------------------------------------------------------------------------------
715: Sorties :
716: --------------------------------------------------------------------------------
717: Effets de bord : néant
718: ================================================================================
719: */
720:
721: void
722: instruction_xpon(struct_processus *s_etat_processus)
723: {
724: struct_liste_chainee *l_element_courant;
725: struct_liste_chainee *l_element_precedent;
726:
727: struct_objet *s_copie_argument;
728: struct_objet *s_objet_argument;
729: struct_objet *s_objet_resultat;
730:
731: (*s_etat_processus).erreur_execution = d_ex;
732:
733: if ((*s_etat_processus).affichage_arguments == 'Y')
734: {
735: printf("\n XPON ");
736:
737: if ((*s_etat_processus).langue == 'F')
738: {
739: printf("(exposant)\n\n");
740: }
741: else
742: {
743: printf("(exponant)\n\n");
744: }
745:
746: printf(" 1: %s, %s\n", d_INT, d_REL);
747: printf("-> 1: %s\n\n", d_INT);
748:
749: printf(" 1: %s, %s\n", d_NOM, d_ALG);
750: printf("-> 1: %s\n\n", d_ALG);
751:
752: printf(" 1: %s\n", d_RPN);
753: printf("-> 1: %s\n", d_RPN);
754:
755: return;
756: }
757: else if ((*s_etat_processus).test_instruction == 'Y')
758: {
759: (*s_etat_processus).nombre_arguments = 1;
760: return;
761: }
762:
763: if (test_cfsf(s_etat_processus, 31) == d_vrai)
764: {
765: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
766: {
767: return;
768: }
769: }
770:
771: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
772: &s_objet_argument) == d_erreur)
773: {
774: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
775: return;
776: }
777:
778: /*
779: --------------------------------------------------------------------------------
780: Exposant d'un entier
781: --------------------------------------------------------------------------------
782: */
783:
784: if ((*s_objet_argument).type == INT)
785: {
786: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
787: {
788: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
789: return;
790: }
791:
792: (*((integer8 *) (*s_objet_resultat).objet)) = (integer8)
1.41 bertrand 793: floor(log10((real8) (*((integer8 *)
794: (*s_objet_argument).objet))));
1.1 bertrand 795: }
796:
797: /*
798: --------------------------------------------------------------------------------
799: Exposant d'un réel
800: --------------------------------------------------------------------------------
801: */
802:
803: else if ((*s_objet_argument).type == REL)
804: {
805: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
806: {
807: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
808: return;
809: }
810:
811: (*((integer8 *) (*s_objet_resultat).objet)) = (integer8)
812: floor(log10((*((real8 *) (*s_objet_argument).objet))));
813: }
814:
815: /*
816: --------------------------------------------------------------------------------
817: Exposant d'un nom
818: --------------------------------------------------------------------------------
819: */
820:
821: else if ((*s_objet_argument).type == NOM)
822: {
823: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
824: {
825: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
826: return;
827: }
828:
829: if (((*s_objet_resultat).objet =
830: allocation_maillon(s_etat_processus)) == NULL)
831: {
832: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
833: return;
834: }
835:
836: l_element_courant = (*s_objet_resultat).objet;
837:
838: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
839: == NULL)
840: {
841: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
842: return;
843: }
844:
845: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
846: .nombre_arguments = 0;
847: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
848: .fonction = instruction_vers_niveau_superieur;
849:
850: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
851: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
852: {
853: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
854: return;
855: }
856:
857: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
858: .nom_fonction, "<<");
859:
860: if (((*l_element_courant).suivant =
861: allocation_maillon(s_etat_processus)) == NULL)
862: {
863: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
864: return;
865: }
866:
867: l_element_courant = (*l_element_courant).suivant;
868: (*l_element_courant).donnee = s_objet_argument;
869:
870: if (((*l_element_courant).suivant =
871: allocation_maillon(s_etat_processus)) == NULL)
872: {
873: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
874: return;
875: }
876:
877: l_element_courant = (*l_element_courant).suivant;
878:
879: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
880: == NULL)
881: {
882: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
883: return;
884: }
885:
886: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
887: .nombre_arguments = 1;
888: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
889: .fonction = instruction_xpon;
890:
891: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
892: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
893: {
894: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
895: return;
896: }
897:
898: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
899: .nom_fonction, "XPON");
900:
901: if (((*l_element_courant).suivant =
902: allocation_maillon(s_etat_processus)) == NULL)
903: {
904: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
905: return;
906: }
907:
908: l_element_courant = (*l_element_courant).suivant;
909:
910: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
911: == NULL)
912: {
913: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
914: return;
915: }
916:
917: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
918: .nombre_arguments = 0;
919: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
920: .fonction = instruction_vers_niveau_inferieur;
921:
922: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
923: .nom_fonction = malloc(3 *
924: sizeof(unsigned char))) == NULL)
925: {
926: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
927: return;
928: }
929:
930: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
931: .nom_fonction, ">>");
932:
933: (*l_element_courant).suivant = NULL;
934: s_objet_argument = NULL;
935: }
936:
937: /*
938: --------------------------------------------------------------------------------
939: Exposant d'une expression
940: --------------------------------------------------------------------------------
941: */
942:
943: else if (((*s_objet_argument).type == ALG) ||
944: ((*s_objet_argument).type == RPN))
945: {
946: if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument,
947: 'N')) == NULL)
948: {
949: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
950: return;
951: }
952:
953: l_element_courant = (struct_liste_chainee *)
954: (*s_copie_argument).objet;
955: l_element_precedent = l_element_courant;
956:
957: while((*l_element_courant).suivant != NULL)
958: {
959: l_element_precedent = l_element_courant;
960: l_element_courant = (*l_element_courant).suivant;
961: }
962:
963: if (((*l_element_precedent).suivant =
964: allocation_maillon(s_etat_processus)) == NULL)
965: {
966: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
967: return;
968: }
969:
970: if (((*(*l_element_precedent).suivant).donnee =
971: allocation(s_etat_processus, FCT)) == NULL)
972: {
973: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
974: return;
975: }
976:
977: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
978: .donnee).objet)).nombre_arguments = 1;
979: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
980: .donnee).objet)).fonction = instruction_xpon;
981:
982: if (((*((struct_fonction *) (*(*(*l_element_precedent)
983: .suivant).donnee).objet)).nom_fonction =
984: malloc(5 * sizeof(unsigned char))) == NULL)
985: {
986: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
987: return;
988: }
989:
990: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
991: .suivant).donnee).objet)).nom_fonction, "XPON");
992:
993: (*(*l_element_precedent).suivant).suivant = l_element_courant;
994:
995: s_objet_resultat = s_copie_argument;
996: }
997:
998: /*
999: --------------------------------------------------------------------------------
1000: Fonction exposant impossible à réaliser
1001: --------------------------------------------------------------------------------
1002: */
1003:
1004: else
1005: {
1006: liberation(s_etat_processus, s_objet_argument);
1007:
1008: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1009: return;
1010: }
1011:
1012: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1013: s_objet_resultat) == d_erreur)
1014: {
1015: return;
1016: }
1017:
1018: liberation(s_etat_processus, s_objet_argument);
1019:
1020: return;
1021: }
1022:
1023: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_x1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src