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