Annotation of rpl/src/instructions_e4.c, revision 1.67
1.1 bertrand 1: /*
2: ================================================================================
1.66 bertrand 3: RPL/2 (R) version 4.1.32
1.67 ! 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.12 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'exsub'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_exsub(struct_processus *s_etat_processus)
40: {
41: integer8 position;
42:
43: struct_liste_chainee *l_element_courant;
44: struct_liste_chainee *ptr_1;
45: struct_liste_chainee *ptr_2;
46: struct_liste_chainee *ptr_3;
47:
48: struct_objet *s_copie_argument_1;
49: struct_objet *s_copie_argument_4;
50: struct_objet *s_objet_argument_1;
51: struct_objet *s_objet_argument_2;
52: struct_objet *s_objet_argument_3;
53: struct_objet *s_objet_argument_4;
54:
55: unsigned char *registre_definitions_chainees;
56: unsigned char *registre_instruction_courante;
57:
1.42 bertrand 58: integer8 position_courante;
1.1 bertrand 59:
60: (*s_etat_processus).erreur_execution = d_ex;
61:
62: if ((*s_etat_processus).affichage_arguments == 'Y')
63: {
64: printf("\n EXSUB ");
65:
66: if ((*s_etat_processus).langue == 'F')
67: {
68: printf("(substitution d'expression)\n\n");
69: }
70: else
71: {
72: printf("(expression substitution)\n\n");
73: }
74:
75: printf(" 4: %s\n", d_RPN);
76: printf(" 3: %s\n", d_INT);
77: printf(" 2: %s\n", d_INT);
78: printf(" 1: %s\n", d_LST);
79: printf("-> 1: %s\n", d_RPN);
80:
81: return;
82: }
83: else if ((*s_etat_processus).test_instruction == 'Y')
84: {
1.8 bertrand 85: (*s_etat_processus).nombre_arguments = -1;
1.1 bertrand 86: return;
87: }
88:
89: if (test_cfsf(s_etat_processus, 31) == d_vrai)
90: {
91: if (empilement_pile_last(s_etat_processus, 4) == d_erreur)
92: {
93: return;
94: }
95: }
96:
97: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
98: &s_objet_argument_1) == d_erreur)
99: {
100: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
101: return;
102: }
103:
104: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
105: &s_objet_argument_2) == d_erreur)
106: {
107: liberation(s_etat_processus, s_objet_argument_1);
108:
109: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
110: return;
111: }
112:
113: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
114: &s_objet_argument_3) == d_erreur)
115: {
116: liberation(s_etat_processus, s_objet_argument_1);
117: liberation(s_etat_processus, s_objet_argument_2);
118:
119: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
120: return;
121: }
122:
123: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
124: &s_objet_argument_4) == d_erreur)
125: {
126: liberation(s_etat_processus, s_objet_argument_1);
127: liberation(s_etat_processus, s_objet_argument_2);
128: liberation(s_etat_processus, s_objet_argument_3);
129:
130: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
131: return;
132: }
133:
134: if (((*s_objet_argument_1).type == LST) &&
135: ((*s_objet_argument_2).type == INT) &&
136: ((*s_objet_argument_3).type == INT) &&
137: ((*s_objet_argument_4).type == RPN))
138: {
139: if ((*((integer8 *) (*s_objet_argument_3).objet)) <= 0)
140: {
141: liberation(s_etat_processus, s_objet_argument_1);
142: liberation(s_etat_processus, s_objet_argument_2);
143: liberation(s_etat_processus, s_objet_argument_3);
144: liberation(s_etat_processus, s_objet_argument_4);
145:
146: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
147: return;
148: }
149:
150: if ((*((integer8 *) (*s_objet_argument_3).objet)) >
151: (*((integer8 *) (*s_objet_argument_2).objet)))
152: {
153: liberation(s_etat_processus, s_objet_argument_1);
154: liberation(s_etat_processus, s_objet_argument_2);
155: liberation(s_etat_processus, s_objet_argument_3);
156: liberation(s_etat_processus, s_objet_argument_4);
157:
158: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
159: return;
160: }
161:
162: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
163: s_objet_argument_1, 'N')) == NULL)
164: {
165: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
166: return;
167: }
168:
169: liberation(s_etat_processus, s_objet_argument_1);
170: s_objet_argument_1 = s_copie_argument_1;
171:
172: if ((s_copie_argument_4 = copie_objet(s_etat_processus,
173: s_objet_argument_4, 'N')) == NULL)
174: {
175: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
176: return;
177: }
178:
179: liberation(s_etat_processus, s_objet_argument_4);
180: s_objet_argument_4 = s_copie_argument_4;
181:
182: l_element_courant = (*s_objet_argument_4).objet;
183: position = 1;
184:
185: /*
186: * ptr_1 : premier élément à substituer
187: * ptr_2 : dernier élément à substituer
188: */
189:
190: ptr_1 = NULL;
191: ptr_2 = NULL;
192:
193: while(l_element_courant != NULL)
194: {
195: if (position == (*((integer8 *) (*s_objet_argument_3).objet)))
196: {
197: ptr_1 = l_element_courant;
198: }
199:
200: if (position == (*((integer8 *) (*s_objet_argument_2).objet)))
201: {
202: ptr_2 = (*l_element_courant).suivant;
203: (*l_element_courant).suivant = NULL;
204: break;
205: }
206:
207: position++;
208: l_element_courant = (*l_element_courant).suivant;
209: }
210:
211: if (l_element_courant != NULL)
212: {
213: /*
214: * Substitution
215: */
216:
217: /*
218: * ptr_3 : objet de substitution
219: * ptr_1 : contient maintenant l'objet allant être substitué
220: * et terminé par un NULL donc libérable par liberation().
221: */
222:
223: ptr_3 = (*s_objet_argument_1).objet;
224: (*s_objet_argument_1).objet = ptr_1;
225:
226: l_element_courant = (*s_objet_argument_4).objet;
227:
228: if (l_element_courant == NULL)
229: {
230: (*s_objet_argument_4).objet = ptr_3;
231:
232: if ((*s_objet_argument_4).objet == NULL)
233: {
234: (*s_objet_argument_4).objet = ptr_2;
235: }
236: else
237: {
238: l_element_courant = (*s_objet_argument_4).objet;
239:
240: while((*l_element_courant).suivant != NULL)
241: {
242: l_element_courant = (*l_element_courant).suivant;
243: }
244:
245: (*l_element_courant).suivant = ptr_2;
246: }
247: }
248: else
249: {
250: if ((*((integer8 *) (*s_objet_argument_3).objet)) == 1)
251: {
252: (*s_objet_argument_4).objet = ptr_3;
253: l_element_courant = (*s_objet_argument_4).objet;
254: }
255: else
256: {
257: position = 1;
258:
259: while((*l_element_courant).suivant != NULL)
260: {
261: position++;
262:
263: if (position == (*((integer8 *) (*s_objet_argument_3)
264: .objet)))
265: {
266: break;
267: }
268:
269: l_element_courant = (*l_element_courant).suivant;
270: }
271:
272: (*l_element_courant).suivant = ptr_3;
273: }
274:
275: if ((*l_element_courant).suivant == NULL)
276: {
277: (*l_element_courant).suivant = ptr_2;
278: }
279: else
280: {
281: while((*l_element_courant).suivant != NULL)
282: {
283: l_element_courant = (*l_element_courant).suivant;
284: }
285:
286: (*l_element_courant).suivant = ptr_2;
287: }
288: }
289:
290: /*
291: * Analyse de l'objet résultant de la substitution
292: */
293:
294: // Recherche de la présence d'un '<<' initial
295:
296: l_element_courant = (*s_objet_argument_4).objet;
297:
298: while(l_element_courant != NULL)
299: {
300: if ((*(*l_element_courant).donnee).type == FCT)
301: {
302: if (strcmp((*((struct_fonction *) (*(*l_element_courant)
303: .donnee).objet)).nom_fonction, "<<") == 0)
304: {
305: break;
306: }
307: }
308:
309: l_element_courant = (*l_element_courant).suivant;
310: }
311:
312: if (l_element_courant != (*s_objet_argument_4).objet)
313: {
314: liberation(s_etat_processus, s_objet_argument_1);
315: liberation(s_etat_processus, s_objet_argument_2);
316: liberation(s_etat_processus, s_objet_argument_3);
317: liberation(s_etat_processus, s_objet_argument_4);
318:
319: (*s_etat_processus).erreur_execution =
320: d_ex_argument_invalide;
321: return;
322: }
323:
324: // Analyse syntaxique
325:
326: position_courante = (*s_etat_processus).position_courante;
327: registre_definitions_chainees = (*s_etat_processus)
328: .definitions_chainees;
329: registre_instruction_courante = (*s_etat_processus)
330: .instruction_courante;
331:
332: if (((*s_etat_processus).definitions_chainees =
333: formateur(s_etat_processus, 0, s_objet_argument_4))
334: == NULL)
335: {
336: (*s_etat_processus).erreur_systeme =
337: d_es_allocation_memoire;
338: return;
339: }
340:
341: if (analyse_syntaxique(s_etat_processus) == d_erreur)
342: {
343: free((*s_etat_processus).definitions_chainees);
344:
345: (*s_etat_processus).definitions_chainees =
346: registre_definitions_chainees;
347: (*s_etat_processus).instruction_courante =
348: registre_instruction_courante;
349: (*s_etat_processus).position_courante =
350: position_courante;
351:
352: liberation(s_etat_processus, s_objet_argument_1);
353: liberation(s_etat_processus, s_objet_argument_2);
354: liberation(s_etat_processus, s_objet_argument_3);
355: liberation(s_etat_processus, s_objet_argument_4);
356:
357: (*s_etat_processus).erreur_execution =
358: d_ex_argument_invalide;
359: return;
360: }
361:
362: free((*s_etat_processus).definitions_chainees);
363:
364: (*s_etat_processus).definitions_chainees =
365: registre_definitions_chainees;
366: (*s_etat_processus).instruction_courante =
367: registre_instruction_courante;
368: (*s_etat_processus).position_courante =
369: position_courante;
370: }
371: else
372: {
373: liberation(s_etat_processus, s_objet_argument_1);
374: liberation(s_etat_processus, s_objet_argument_2);
375: liberation(s_etat_processus, s_objet_argument_3);
376: liberation(s_etat_processus, s_objet_argument_4);
377:
378: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
379: return;
380: }
381: }
382: else
383: {
384: liberation(s_etat_processus, s_objet_argument_1);
385: liberation(s_etat_processus, s_objet_argument_2);
386: liberation(s_etat_processus, s_objet_argument_3);
387: liberation(s_etat_processus, s_objet_argument_4);
388:
389: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
390: return;
391: }
392:
393: liberation(s_etat_processus, s_objet_argument_1);
394: liberation(s_etat_processus, s_objet_argument_2);
395: liberation(s_etat_processus, s_objet_argument_3);
396:
397: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
398: s_objet_argument_4) == d_erreur)
399: {
400: return;
401: }
402:
403: return;
404: }
405:
406:
407: /*
408: ================================================================================
409: Fonction 'exget'
410: ================================================================================
411: Entrées :
412: --------------------------------------------------------------------------------
413: Sorties :
414: --------------------------------------------------------------------------------
415: Effets de bord : néant
416: ================================================================================
417: */
418:
419: void
420: instruction_exget(struct_processus *s_etat_processus)
421: {
422: struct_liste_chainee *l_element_courant;
423: struct_liste_chainee *l_element_suivant;
424:
425: struct_objet *s_copie_argument_3;
426: struct_objet *s_objet_argument_1;
427: struct_objet *s_objet_argument_2;
428: struct_objet *s_objet_argument_3;
429:
430: signed long position;
431:
432: (*s_etat_processus).erreur_execution = d_ex;
433:
434: if ((*s_etat_processus).affichage_arguments == 'Y')
435: {
436: printf("\n EXGET ");
437:
438: if ((*s_etat_processus).langue == 'F')
439: {
440: printf("(extraction d'une expression)\n\n");
441: }
442: else
443: {
444: printf("(get expression)\n\n");
445: }
446:
447: printf(" 3: %s\n", d_RPN);
448: printf(" 2: %s\n", d_INT);
449: printf(" 1: %s\n", d_INT);
450: printf("-> 1: %s\n", d_LST);
451:
452: return;
453: }
454: else if ((*s_etat_processus).test_instruction == 'Y')
455: {
1.8 bertrand 456: (*s_etat_processus).nombre_arguments = -1;
1.1 bertrand 457: return;
458: }
459:
460: if (test_cfsf(s_etat_processus, 31) == d_vrai)
461: {
462: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
463: {
464: return;
465: }
466: }
467:
468: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
469: &s_objet_argument_1) == d_erreur)
470: {
471: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
472: return;
473: }
474:
475: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
476: &s_objet_argument_2) == d_erreur)
477: {
478: liberation(s_etat_processus, s_objet_argument_1);
479:
480: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
481: return;
482: }
483:
484: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
485: &s_objet_argument_3) == d_erreur)
486: {
487: liberation(s_etat_processus, s_objet_argument_1);
488: liberation(s_etat_processus, s_objet_argument_2);
489:
490: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
491: return;
492: }
493:
494: if (((*s_objet_argument_1).type == INT) &&
495: ((*s_objet_argument_2).type == INT) &&
496: ((*s_objet_argument_3).type == RPN))
497: {
498: if ((s_copie_argument_3 = copie_objet(s_etat_processus,
499: s_objet_argument_3, 'N')) == NULL)
500: {
501: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
502: return;
503: }
504:
505: liberation(s_etat_processus, s_objet_argument_3);
506: s_objet_argument_3 = s_copie_argument_3;
507:
508: if ((*((integer8 *) (*s_objet_argument_2).objet)) <= 0)
509: {
510: liberation(s_etat_processus, s_objet_argument_1);
511: liberation(s_etat_processus, s_objet_argument_2);
512: liberation(s_etat_processus, s_objet_argument_3);
513:
514: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
515: return;
516: }
517:
518: if ((*((integer8 *) (*s_objet_argument_2).objet)) >
519: (*((integer8 *) (*s_objet_argument_1).objet)))
520: {
521: liberation(s_etat_processus, s_objet_argument_1);
522: liberation(s_etat_processus, s_objet_argument_2);
523: liberation(s_etat_processus, s_objet_argument_3);
524:
525: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
526: return;
527: }
528:
529: (*s_objet_argument_3).type = LST;
530: l_element_courant = (*s_objet_argument_3).objet;
531: position = 1;
532:
533: while(l_element_courant != NULL)
534: {
535: if (position == (*((integer8 *) (*s_objet_argument_2).objet)))
536: {
537: (*s_objet_argument_3).objet = l_element_courant;
538: break;
539: }
540:
541: l_element_suivant = (*l_element_courant).suivant;
542: liberation(s_etat_processus, (*l_element_courant).donnee);
543: free(l_element_courant);
544: l_element_courant = l_element_suivant;
545:
546: position++;
547: }
548:
549: if (position != (*((integer8 *) (*s_objet_argument_2).objet)))
550: {
551: liberation(s_etat_processus, s_objet_argument_1);
552: liberation(s_etat_processus, s_objet_argument_2);
553: liberation(s_etat_processus, s_objet_argument_3);
554:
555: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
556: return;
557: }
558:
559: while(l_element_courant != NULL)
560: {
561: l_element_suivant = (*l_element_courant).suivant;
562:
563: if (position == (*((integer8 *) (*s_objet_argument_1).objet)))
564: {
565: (*l_element_courant).suivant = NULL;
566: l_element_courant = l_element_suivant;
567:
568: while(l_element_courant != NULL)
569: {
570: l_element_suivant = (*l_element_courant).suivant;
571: liberation(s_etat_processus, (*l_element_courant).donnee);
572: free(l_element_courant);
573: l_element_courant = l_element_suivant;
574: }
575:
576: break;
577: }
578:
579: l_element_courant = l_element_suivant;
580: position++;
581: }
582:
583: if (position != (*((integer8 *) (*s_objet_argument_1).objet)))
584: {
585: liberation(s_etat_processus, s_objet_argument_1);
586: liberation(s_etat_processus, s_objet_argument_2);
587: liberation(s_etat_processus, s_objet_argument_3);
588:
589: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
590: return;
591: }
592:
593: /*
594: * Vérification de la cohérence de l'expression. Nous ne devons avoir
595: * ni '<<' ni '>>.
596: */
597:
598: l_element_courant = (*s_objet_argument_3).objet;
599:
600: while(l_element_courant != NULL)
601: {
602: if ((*(*l_element_courant).donnee).type == FCT)
603: {
604: if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
605: .donnee).objet)).nom_fonction, "<<") == 0) ||
606: (strcmp((*((struct_fonction *) (*(*l_element_courant)
607: .donnee).objet)).nom_fonction, ">>") == 0))
608: {
609: liberation(s_etat_processus, s_objet_argument_1);
610: liberation(s_etat_processus, s_objet_argument_2);
611: liberation(s_etat_processus, s_objet_argument_3);
612:
613: (*s_etat_processus).erreur_execution =
614: d_ex_argument_invalide;
615: return;
616: }
617: }
618:
619: l_element_courant = (*l_element_courant).suivant;
620: }
621: }
622: else
623: {
624: liberation(s_etat_processus, s_objet_argument_1);
625: liberation(s_etat_processus, s_objet_argument_2);
626: liberation(s_etat_processus, s_objet_argument_3);
627:
628: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
629: return;
630: }
631:
632: liberation(s_etat_processus, s_objet_argument_1);
633: liberation(s_etat_processus, s_objet_argument_2);
634:
635: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
636: s_objet_argument_3) == d_erreur)
637: {
638: return;
639: }
640:
641: return;
642: }
643:
1.50 bertrand 644:
645: /*
646: ================================================================================
647: Fonction 'eqv'
648: ================================================================================
649: Entrées : pointeur sur une structure struct_processus
650: --------------------------------------------------------------------------------
651: Sorties :
652: --------------------------------------------------------------------------------
653: Effets de bord : néant
654: ================================================================================
655: */
656:
657: void
658: instruction_eqv(struct_processus *s_etat_processus)
659: {
660: struct_liste_chainee *l_element_courant;
661: struct_liste_chainee *l_element_precedent;
662:
663: struct_objet *s_copie_argument_1;
664: struct_objet *s_copie_argument_2;
665: struct_objet *s_objet_argument_1;
666: struct_objet *s_objet_argument_2;
667: struct_objet *s_objet_resultat;
668:
669: integer8 nombre_elements;
670:
671: (*s_etat_processus).erreur_execution = d_ex;
672:
673: if ((*s_etat_processus).affichage_arguments == 'Y')
674: {
675: printf("\n EQV ");
676:
677: if ((*s_etat_processus).langue == 'F')
678: {
679: printf("(opérateur equivalence)\n\n");
680: }
681: else
682: {
683: printf("(equivalence operator)\n\n");
684: }
685:
686: printf(" 2: %s, %s\n", d_INT, d_REL);
687: printf(" 1: %s, %s\n", d_INT, d_REL);
688: printf("-> 1: %s\n\n", d_INT);
689:
690: printf(" 2: %s\n", d_BIN);
691: printf(" 1: %s\n", d_BIN);
692: printf("-> 1: %s\n\n", d_BIN);
693:
694: printf(" 2: %s\n", d_NOM);
695: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
696: printf("-> 1: %s\n\n", d_ALG);
697:
698: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
699: printf(" 1: %s\n", d_NOM);
700: printf("-> 1: %s\n\n", d_ALG);
701:
702: printf(" 2: %s\n", d_ALG);
703: printf(" 1: %s\n", d_ALG);
704: printf("-> 1: %s\n\n", d_ALG);
705:
706: printf(" 2: %s\n", d_RPN);
707: printf(" 1: %s\n", d_RPN);
708: printf("-> 1: %s\n", d_RPN);
709:
710: return;
711: }
712: else if ((*s_etat_processus).test_instruction == 'Y')
713: {
714: (*s_etat_processus).nombre_arguments = 0;
715: return;
716: }
717:
718: if (test_cfsf(s_etat_processus, 31) == d_vrai)
719: {
720: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
721: {
722: return;
723: }
724: }
725:
726: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
727: &s_objet_argument_1) == d_erreur)
728: {
729: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
730: return;
731: }
732:
733: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
734: &s_objet_argument_2) == d_erreur)
735: {
736: liberation(s_etat_processus, s_objet_argument_1);
737:
738: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
739: return;
740: }
741:
742: /*
743: --------------------------------------------------------------------------------
744: EQV logique
745: --------------------------------------------------------------------------------
746: */
747:
748: if ((((*s_objet_argument_1).type == INT) ||
749: ((*s_objet_argument_1).type == REL)) &&
750: (((*s_objet_argument_2).type == INT) ||
751: ((*s_objet_argument_2).type == REL)))
752: {
753: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
754: {
755: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
756: return;
757: }
758:
759: if ((*s_objet_argument_1).type == INT)
760: {
761: if ((*s_objet_argument_2).type == INT)
762: {
763: if ((((*((integer8 *) (*s_objet_argument_1).objet)) == 0) &&
764: ((*((integer8 *) (*s_objet_argument_2).objet)) == 0))
765: || (((*((integer8 *) (*s_objet_argument_1).objet))
766: != 0) && ((*((integer8 *) (*s_objet_argument_2).objet))
767: != 0)))
768: {
769: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
770: }
771: else
772: {
773: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
774: }
775: }
776: else
777: {
778: if ((((*((integer8 *) (*s_objet_argument_1).objet)) == 0) &&
779: ((*((real8 *) (*s_objet_argument_2).objet)) == 0))
780: || (((*((integer8 *) (*s_objet_argument_1).objet))
781: != 0) && ((*((real8 *) (*s_objet_argument_2).objet))
782: != 0)))
783: {
784: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
785: }
786: else
787: {
788: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
789: }
790: }
791: }
792: else
793: {
794: if ((*s_objet_argument_2).type == INT)
795: {
796: if ((((*((real8 *) (*s_objet_argument_1).objet)) == 0) &&
797: ((*((integer8 *) (*s_objet_argument_2).objet)) == 0))
798: || (((*((real8 *) (*s_objet_argument_1).objet))
799: != 0) && ((*((integer8 *) (*s_objet_argument_2).objet))
800: != 0)))
801: {
802: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
803: }
804: else
805: {
806: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
807: }
808: }
809: else
810: {
811: if ((((*((real8 *) (*s_objet_argument_1).objet)) == 0) &&
812: ((*((real8 *) (*s_objet_argument_2).objet)) == 0))
813: || (((*((real8 *) (*s_objet_argument_1).objet))
814: != 0) && ((*((real8 *) (*s_objet_argument_2).objet))
815: != 0)))
816: {
817: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
818: }
819: else
820: {
821: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
822: }
823: }
824: }
825: }
826:
827: /*
828: --------------------------------------------------------------------------------
829: EQV binaire
830: --------------------------------------------------------------------------------
831: */
832:
833: else if (((*s_objet_argument_1).type == BIN) &&
834: ((*s_objet_argument_2).type == BIN))
835: {
836: if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
837: {
838: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
839: return;
840: }
841:
842: (*((logical8 *) (*s_objet_resultat).objet)) =
843: ~((*((logical8 *) (*s_objet_argument_1).objet)) ^
844: (*((logical8 *) (*s_objet_argument_2).objet)));
845: }
846:
847: /*
848: --------------------------------------------------------------------------------
849: EQV entre des arguments complexes
850: --------------------------------------------------------------------------------
851: */
852:
853: /*
854: * Nom ou valeur numérique / Nom ou valeur numérique
855: */
856:
857: else if ((((*s_objet_argument_1).type == NOM) &&
858: (((*s_objet_argument_2).type == NOM) ||
859: ((*s_objet_argument_2).type == INT) ||
860: ((*s_objet_argument_2).type == REL))) ||
861: (((*s_objet_argument_2).type == NOM) &&
862: (((*s_objet_argument_1).type == INT) ||
863: ((*s_objet_argument_1).type == REL))))
864: {
865: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
866: {
867: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
868: return;
869: }
870:
871: if (((*s_objet_resultat).objet =
872: allocation_maillon(s_etat_processus)) == NULL)
873: {
874: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
875: return;
876: }
877:
878: l_element_courant = (*s_objet_resultat).objet;
879:
880: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
881: == NULL)
882: {
883: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
884: return;
885: }
886:
887: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
888: .nombre_arguments = 0;
889: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
890: .fonction = instruction_vers_niveau_superieur;
891:
892: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
893: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
894: {
895: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
896: return;
897: }
898:
899: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
900: .nom_fonction, "<<");
901:
902: if (((*l_element_courant).suivant =
903: allocation_maillon(s_etat_processus)) == NULL)
904: {
905: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
906: return;
907: }
908:
909: l_element_courant = (*l_element_courant).suivant;
910: (*l_element_courant).donnee = s_objet_argument_2;
911:
912: if (((*l_element_courant).suivant =
913: allocation_maillon(s_etat_processus)) == NULL)
914: {
915: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
916: return;
917: }
918:
919: l_element_courant = (*l_element_courant).suivant;
920: (*l_element_courant).donnee = s_objet_argument_1;
921:
922: if (((*l_element_courant).suivant =
923: allocation_maillon(s_etat_processus)) == NULL)
924: {
925: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
926: return;
927: }
928:
929: l_element_courant = (*l_element_courant).suivant;
930:
931: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
932: == NULL)
933: {
934: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
935: return;
936: }
937:
938: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
939: .nombre_arguments = 0;
940: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
941: .fonction = instruction_xor;
942:
943: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
944: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
945: {
946: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
947: return;
948: }
949:
950: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
951: .nom_fonction, "EQV");
952:
953: if (((*l_element_courant).suivant =
954: allocation_maillon(s_etat_processus)) == NULL)
955: {
956: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
957: return;
958: }
959:
960: l_element_courant = (*l_element_courant).suivant;
961:
962: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
963: == NULL)
964: {
965: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
966: return;
967: }
968:
969: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
970: .nombre_arguments = 0;
971: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
972: .fonction = instruction_vers_niveau_inferieur;
973:
974: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
975: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
976: {
977: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
978: return;
979: }
980:
981: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
982: .nom_fonction, ">>");
983:
984: (*l_element_courant).suivant = NULL;
985:
986: s_objet_argument_1 = NULL;
987: s_objet_argument_2 = NULL;
988: }
989:
990: /*
991: * Nom ou valeur numérique / Expression
992: */
993:
994: else if ((((*s_objet_argument_1).type == ALG) ||
995: ((*s_objet_argument_1).type == RPN)) &&
996: (((*s_objet_argument_2).type == NOM) ||
997: ((*s_objet_argument_2).type == INT) ||
998: ((*s_objet_argument_2).type == REL)))
999: {
1000: nombre_elements = 0;
1001: l_element_courant = (struct_liste_chainee *)
1002: (*s_objet_argument_1).objet;
1003:
1004: while(l_element_courant != NULL)
1005: {
1006: nombre_elements++;
1007: l_element_courant = (*l_element_courant).suivant;
1008: }
1009:
1010: if (nombre_elements == 2)
1011: {
1012: liberation(s_etat_processus, s_objet_argument_1);
1013: liberation(s_etat_processus, s_objet_argument_2);
1014:
1015: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1016: return;
1017: }
1018:
1019: if ((s_objet_resultat = copie_objet(s_etat_processus,
1020: s_objet_argument_1, 'N')) == NULL)
1021: {
1022: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1023: return;
1024: }
1025:
1026: l_element_courant = (struct_liste_chainee *)
1027: (*s_objet_resultat).objet;
1028: l_element_precedent = l_element_courant;
1029: l_element_courant = (*l_element_courant).suivant;
1030:
1031: if (((*l_element_precedent).suivant = (struct_liste_chainee *)
1032: allocation_maillon(s_etat_processus)) == NULL)
1033: {
1034: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1035: return;
1036: }
1037:
1038: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
1039: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1040:
1041: while((*l_element_courant).suivant != NULL)
1042: {
1043: l_element_precedent = l_element_courant;
1044: l_element_courant = (*l_element_courant).suivant;
1045: }
1046:
1047: if (((*l_element_precedent).suivant =
1048: allocation_maillon(s_etat_processus)) == NULL)
1049: {
1050: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1051: return;
1052: }
1053:
1054: if (((*(*l_element_precedent).suivant).donnee =
1055: allocation(s_etat_processus, FCT)) == NULL)
1056: {
1057: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1058: return;
1059: }
1060:
1061: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1062: .donnee).objet)).nombre_arguments = 0;
1063: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1064: .donnee).objet)).fonction = instruction_xor;
1065:
1066: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1067: .suivant).donnee).objet)).nom_fonction =
1068: malloc(4 * sizeof(unsigned char))) == NULL)
1069: {
1070: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1071: return;
1072: }
1073:
1074: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1075: .suivant).donnee).objet)).nom_fonction, "EQV");
1076:
1077: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1078:
1079: s_objet_argument_2 = NULL;
1080: }
1081:
1082: /*
1083: * Expression / Nom ou valeur numérique
1084: */
1085:
1086: else if ((((*s_objet_argument_1).type == NOM) ||
1087: ((*s_objet_argument_1).type == INT) ||
1088: ((*s_objet_argument_1).type == REL)) &&
1089: (((*s_objet_argument_2).type == ALG) ||
1090: ((*s_objet_argument_2).type == RPN)))
1091: {
1092: nombre_elements = 0;
1093: l_element_courant = (struct_liste_chainee *)
1094: (*s_objet_argument_2).objet;
1095:
1096: while(l_element_courant != NULL)
1097: {
1098: nombre_elements++;
1099: l_element_courant = (*l_element_courant).suivant;
1100: }
1101:
1102: if (nombre_elements == 2)
1103: {
1104: liberation(s_etat_processus, s_objet_argument_1);
1105: liberation(s_etat_processus, s_objet_argument_2);
1106:
1107: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1108: return;
1109: }
1110:
1111: if ((s_objet_resultat = copie_objet(s_etat_processus,
1112: s_objet_argument_2, 'N')) == NULL)
1113: {
1114: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1115: return;
1116: }
1117:
1118: l_element_courant = (struct_liste_chainee *)
1119: (*s_objet_resultat).objet;
1120: l_element_precedent = l_element_courant;
1121:
1122: while((*l_element_courant).suivant != NULL)
1123: {
1124: l_element_precedent = l_element_courant;
1125: l_element_courant = (*l_element_courant).suivant;
1126: }
1127:
1128: if (((*l_element_precedent).suivant =
1129: allocation_maillon(s_etat_processus)) == NULL)
1130: {
1131: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1132: return;
1133: }
1134:
1135: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
1136: l_element_precedent = (*l_element_precedent).suivant;
1137:
1138: if (((*l_element_precedent).suivant =
1139: allocation_maillon(s_etat_processus)) == NULL)
1140: {
1141: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1142: return;
1143: }
1144:
1145: if (((*(*l_element_precedent).suivant).donnee =
1146: allocation(s_etat_processus, FCT)) == NULL)
1147: {
1148: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1149: return;
1150: }
1151:
1152: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1153: .donnee).objet)).nombre_arguments = 0;
1154: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1155: .donnee).objet)).fonction = instruction_xor;
1156:
1157: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1158: .suivant).donnee).objet)).nom_fonction =
1159: malloc(4 * sizeof(unsigned char))) == NULL)
1160: {
1161: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1162: return;
1163: }
1164:
1165: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1166: .suivant).donnee).objet)).nom_fonction, "EQV");
1167:
1168: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1169:
1170: s_objet_argument_1 = NULL;
1171: }
1172:
1173: /*
1174: * Expression / Expression
1175: */
1176:
1177: else if ((((*s_objet_argument_1).type == ALG) &&
1178: ((*s_objet_argument_2).type == ALG)) ||
1179: (((*s_objet_argument_1).type == RPN) &&
1180: ((*s_objet_argument_2).type == RPN)))
1181: {
1182: nombre_elements = 0;
1183: l_element_courant = (struct_liste_chainee *)
1184: (*s_objet_argument_1).objet;
1185:
1186: while(l_element_courant != NULL)
1187: {
1188: nombre_elements++;
1189: l_element_courant = (*l_element_courant).suivant;
1190: }
1191:
1192: if (nombre_elements == 2)
1193: {
1194: liberation(s_etat_processus, s_objet_argument_1);
1195: liberation(s_etat_processus, s_objet_argument_2);
1196:
1197: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1198: return;
1199: }
1200:
1201: nombre_elements = 0;
1202: l_element_courant = (struct_liste_chainee *)
1203: (*s_objet_argument_2).objet;
1204:
1205: while(l_element_courant != NULL)
1206: {
1207: nombre_elements++;
1208: l_element_courant = (*l_element_courant).suivant;
1209: }
1210:
1211: if (nombre_elements == 2)
1212: {
1213: liberation(s_etat_processus, s_objet_argument_1);
1214: liberation(s_etat_processus, s_objet_argument_2);
1215:
1216: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1217: return;
1218: }
1219:
1220: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
1221: s_objet_argument_1, 'N')) == NULL)
1222: {
1223: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1224: return;
1225: }
1226:
1227: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
1228: s_objet_argument_2, 'N')) == NULL)
1229: {
1230: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1231: return;
1232: }
1233:
1234: l_element_courant = (struct_liste_chainee *)
1235: (*s_copie_argument_1).objet;
1236: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
1237: (*s_copie_argument_1).objet)).suivant;
1238:
1239: liberation(s_etat_processus, (*l_element_courant).donnee);
1240: free(l_element_courant);
1241:
1242: l_element_courant = (struct_liste_chainee *)
1243: (*s_copie_argument_2).objet;
1244: l_element_precedent = l_element_courant;
1245: s_objet_resultat = s_copie_argument_2;
1246:
1247: while((*l_element_courant).suivant != NULL)
1248: {
1249: l_element_precedent = l_element_courant;
1250: l_element_courant = (*l_element_courant).suivant;
1251: }
1252:
1253: liberation(s_etat_processus, (*l_element_courant).donnee);
1254: free(l_element_courant);
1255:
1256: (*l_element_precedent).suivant = (struct_liste_chainee *)
1257: (*s_copie_argument_1).objet;
1258: free(s_copie_argument_1);
1259:
1260: l_element_courant = (*l_element_precedent).suivant;
1261: while((*l_element_courant).suivant != NULL)
1262: {
1263: l_element_precedent = l_element_courant;
1264: l_element_courant = (*l_element_courant).suivant;
1265: }
1266:
1267: if (((*l_element_precedent).suivant =
1268: allocation_maillon(s_etat_processus)) == NULL)
1269: {
1270: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1271: return;
1272: }
1273:
1274: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1275: l_element_courant = (*l_element_precedent).suivant;
1276:
1277: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1278: == NULL)
1279: {
1280: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1281: return;
1282: }
1283:
1284: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1285: .nombre_arguments = 0;
1286: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1287: .fonction = instruction_xor;
1288:
1289: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1290: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
1291: {
1292: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1293: return;
1294: }
1295:
1296: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1297: .nom_fonction, "EQV");
1298: }
1299:
1300: /*
1301: --------------------------------------------------------------------------------
1302: EQV impossible
1303: --------------------------------------------------------------------------------
1304: */
1305:
1306: else
1307: {
1308: liberation(s_etat_processus, s_objet_argument_1);
1309: liberation(s_etat_processus, s_objet_argument_2);
1310:
1311: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1312: return;
1313: }
1314:
1315: liberation(s_etat_processus, s_objet_argument_1);
1316: liberation(s_etat_processus, s_objet_argument_2);
1317:
1318: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1319: s_objet_resultat) == d_erreur)
1320: {
1321: return;
1322: }
1323:
1324: return;
1325: }
1326:
1.1 bertrand 1327: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_e4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src