1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.24
4: Copyright (C) 1989-2011 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 '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:
50: unsigned long nombre_elements;
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))
148: != 0)))
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))
163: != 0)))
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))
181: != 0)))
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))
196: != 0)))
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)
793: floor(log10((*((integer8 *) (*s_objet_argument).objet))));
794: }
795:
796: /*
797: --------------------------------------------------------------------------------
798: Exposant d'un réel
799: --------------------------------------------------------------------------------
800: */
801:
802: else if ((*s_objet_argument).type == REL)
803: {
804: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
805: {
806: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
807: return;
808: }
809:
810: (*((integer8 *) (*s_objet_resultat).objet)) = (integer8)
811: floor(log10((*((real8 *) (*s_objet_argument).objet))));
812: }
813:
814: /*
815: --------------------------------------------------------------------------------
816: Exposant d'un nom
817: --------------------------------------------------------------------------------
818: */
819:
820: else if ((*s_objet_argument).type == NOM)
821: {
822: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
823: {
824: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
825: return;
826: }
827:
828: if (((*s_objet_resultat).objet =
829: allocation_maillon(s_etat_processus)) == NULL)
830: {
831: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
832: return;
833: }
834:
835: l_element_courant = (*s_objet_resultat).objet;
836:
837: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
838: == NULL)
839: {
840: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
841: return;
842: }
843:
844: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
845: .nombre_arguments = 0;
846: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
847: .fonction = instruction_vers_niveau_superieur;
848:
849: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
850: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
851: {
852: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
853: return;
854: }
855:
856: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
857: .nom_fonction, "<<");
858:
859: if (((*l_element_courant).suivant =
860: allocation_maillon(s_etat_processus)) == NULL)
861: {
862: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
863: return;
864: }
865:
866: l_element_courant = (*l_element_courant).suivant;
867: (*l_element_courant).donnee = s_objet_argument;
868:
869: if (((*l_element_courant).suivant =
870: allocation_maillon(s_etat_processus)) == NULL)
871: {
872: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
873: return;
874: }
875:
876: l_element_courant = (*l_element_courant).suivant;
877:
878: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
879: == NULL)
880: {
881: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
882: return;
883: }
884:
885: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
886: .nombre_arguments = 1;
887: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
888: .fonction = instruction_xpon;
889:
890: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
891: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
892: {
893: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
894: return;
895: }
896:
897: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
898: .nom_fonction, "XPON");
899:
900: if (((*l_element_courant).suivant =
901: allocation_maillon(s_etat_processus)) == NULL)
902: {
903: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
904: return;
905: }
906:
907: l_element_courant = (*l_element_courant).suivant;
908:
909: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
910: == NULL)
911: {
912: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
913: return;
914: }
915:
916: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
917: .nombre_arguments = 0;
918: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
919: .fonction = instruction_vers_niveau_inferieur;
920:
921: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
922: .nom_fonction = malloc(3 *
923: sizeof(unsigned char))) == NULL)
924: {
925: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
926: return;
927: }
928:
929: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
930: .nom_fonction, ">>");
931:
932: (*l_element_courant).suivant = NULL;
933: s_objet_argument = NULL;
934: }
935:
936: /*
937: --------------------------------------------------------------------------------
938: Exposant d'une expression
939: --------------------------------------------------------------------------------
940: */
941:
942: else if (((*s_objet_argument).type == ALG) ||
943: ((*s_objet_argument).type == RPN))
944: {
945: if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument,
946: 'N')) == NULL)
947: {
948: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
949: return;
950: }
951:
952: l_element_courant = (struct_liste_chainee *)
953: (*s_copie_argument).objet;
954: l_element_precedent = l_element_courant;
955:
956: while((*l_element_courant).suivant != NULL)
957: {
958: l_element_precedent = l_element_courant;
959: l_element_courant = (*l_element_courant).suivant;
960: }
961:
962: if (((*l_element_precedent).suivant =
963: allocation_maillon(s_etat_processus)) == NULL)
964: {
965: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
966: return;
967: }
968:
969: if (((*(*l_element_precedent).suivant).donnee =
970: allocation(s_etat_processus, FCT)) == NULL)
971: {
972: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
973: return;
974: }
975:
976: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
977: .donnee).objet)).nombre_arguments = 1;
978: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
979: .donnee).objet)).fonction = instruction_xpon;
980:
981: if (((*((struct_fonction *) (*(*(*l_element_precedent)
982: .suivant).donnee).objet)).nom_fonction =
983: malloc(5 * sizeof(unsigned char))) == NULL)
984: {
985: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
986: return;
987: }
988:
989: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
990: .suivant).donnee).objet)).nom_fonction, "XPON");
991:
992: (*(*l_element_precedent).suivant).suivant = l_element_courant;
993:
994: s_objet_resultat = s_copie_argument;
995: }
996:
997: /*
998: --------------------------------------------------------------------------------
999: Fonction exposant impossible à réaliser
1000: --------------------------------------------------------------------------------
1001: */
1002:
1003: else
1004: {
1005: liberation(s_etat_processus, s_objet_argument);
1006:
1007: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1008: return;
1009: }
1010:
1011: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1012: s_objet_resultat) == d_erreur)
1013: {
1014: return;
1015: }
1016:
1017: liberation(s_etat_processus, s_objet_argument);
1018:
1019: return;
1020: }
1021:
1022: // 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