Annotation of rpl/src/instructions_e4.c, revision 1.50
1.1 bertrand 1: /*
2: ================================================================================
1.49 bertrand 3: RPL/2 (R) version 4.1.19
1.47 bertrand 4: Copyright (C) 1989-2014 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