Annotation of rpl/src/instructions_l1.c, revision 1.65
1.1 bertrand 1: /*
2: ================================================================================
1.64 bertrand 3: RPL/2 (R) version 4.1.32
1.65 ! bertrand 4: Copyright (C) 1989-2020 Dr. BERTRAND Joël
1.1 bertrand 5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
1.11 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'list->'
29: ================================================================================
30: Entrées : structure processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_list_fleche(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_objet;
45: struct_objet *s_objet;
46:
1.54 bertrand 47: unsigned char *registre_instruction_courante;
48: unsigned char registre_instruction_valide;
49: unsigned char registre_test;
50:
1.1 bertrand 51: unsigned long nombre_elements;
52:
53: (*s_etat_processus).erreur_execution = d_ex;
54:
55: if ((*s_etat_processus).affichage_arguments == 'Y')
56: {
57: printf("\n LIST-> ");
58:
59: if ((*s_etat_processus).langue == 'F')
60: {
61: printf("(expansion d'une liste)\n\n");
62: }
63: else
64: {
65: printf("(expand list)\n\n");
66: }
67:
68: printf(" 1: %s\n", d_LST);
69: printf("-> n: %s, %s, %s, %s, %s, %s,\n"
70: " %s, %s, %s, %s, %s,\n"
71: " %s, %s, %s, %s, %s,\n"
72: " %s, %s\n",
73: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
74: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
75: printf(" ...\n");
76: printf(" 2: %s, %s, %s, %s, %s, %s,\n"
77: " %s, %s, %s, %s, %s,\n"
78: " %s, %s, %s, %s, %s,\n"
79: " %s, %s\n",
80: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
81: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
82: printf(" 1: %s\n", d_INT);
83:
84: return;
85: }
86: else if ((*s_etat_processus).test_instruction == 'Y')
87: {
88: (*s_etat_processus).nombre_arguments = -1;
89: return;
90: }
91:
92: if (test_cfsf(s_etat_processus, 31) == d_vrai)
93: {
94: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
95: {
96: return;
97: }
98: }
99:
100: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
101: &s_objet) == d_erreur)
102: {
103: return;
104: }
105:
106: if ((*s_objet).type != LST)
107: {
108: liberation(s_etat_processus, s_objet);
109:
110: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
111: return;
112: }
113:
114: if ((s_copie_objet = copie_objet(s_etat_processus, s_objet, 'N')) == NULL)
115: {
116: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
117: return;
118: }
119:
120: liberation(s_etat_processus, s_objet);
121: s_objet = s_copie_objet;
122:
123: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
124: nombre_elements = 0;
125:
126: while(l_element_courant != NULL)
127: {
1.54 bertrand 128: if ((*(*l_element_courant).donnee).type != FCT)
129: {
130: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
131: (*l_element_courant).donnee) == d_erreur)
132: {
133: return;
134: }
135: }
136: else
1.1 bertrand 137: {
1.54 bertrand 138: registre_test = (*s_etat_processus).test_instruction;
139: registre_instruction_courante = (*s_etat_processus)
140: .instruction_courante;
141: registre_instruction_valide = (*s_etat_processus)
142: .instruction_valide;
143:
144: (*s_etat_processus).test_instruction = 'Y';
145: (*s_etat_processus).instruction_courante =
146: (*((struct_fonction *) (*(*l_element_courant).donnee)
147: .objet)).nom_fonction;
148:
149: analyse(s_etat_processus, NULL);
150:
151: (*s_etat_processus).test_instruction = registre_test;
152: (*s_etat_processus).instruction_courante =
153: registre_instruction_courante;
154:
155: if (((*s_etat_processus).instruction_valide == 'Y') &&
156: (*s_etat_processus).constante_symbolique == 'Y')
157: {
158: if (evaluation(s_etat_processus, (*l_element_courant).donnee,
159: 'E') == d_erreur)
160: {
161: (*s_etat_processus).instruction_valide =
162: registre_instruction_valide;
163: return;
164: }
165: }
166: else
167: {
168: if (empilement(s_etat_processus, &((*s_etat_processus)
169: .l_base_pile), (*l_element_courant).donnee) == d_erreur)
170: {
171: (*s_etat_processus).instruction_valide =
172: registre_instruction_valide;
173: return;
174: }
175: }
176:
177: (*s_etat_processus).instruction_valide =
178: registre_instruction_valide;
1.1 bertrand 179: }
180:
181: l_element_precedent = l_element_courant;
182: l_element_courant = (*l_element_courant).suivant;
183:
184: free(l_element_precedent);
185:
186: nombre_elements++;
187: }
188:
189: free(s_objet);
190:
191: if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
192: {
193: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
194: return;
195: }
196:
197: (*((integer8 *) ((*s_objet).objet))) = (integer8) nombre_elements;
198:
199: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
200: s_objet) == d_erreur)
201: {
202: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
203: return;
204: }
205:
206: return;
207: }
208:
209:
210: /*
211: ================================================================================
212: Fonction '<='
213: ================================================================================
214: Entrées :
215: --------------------------------------------------------------------------------
216: Sorties :
217: --------------------------------------------------------------------------------
218: Effets de bord : néant
219: ================================================================================
220: */
221:
222: void
223: instruction_le(struct_processus *s_etat_processus)
224: {
225: struct_liste_chainee *l_element_courant;
226: struct_liste_chainee *l_element_precedent;
227:
228: struct_objet *s_copie_argument_1;
229: struct_objet *s_copie_argument_2;
230: struct_objet *s_objet_argument_1;
231: struct_objet *s_objet_argument_2;
232: struct_objet *s_objet_resultat;
233:
234: unsigned long nombre_elements;
235:
236: (*s_etat_processus).erreur_execution = d_ex;
237:
238: if ((*s_etat_processus).affichage_arguments == 'Y')
239: {
240: printf("\n <= ");
241:
242: if ((*s_etat_processus).langue == 'F')
243: {
244: printf("(opérateur inférieur ou égal)\n\n");
245: }
246: else
247: {
248: printf("(less or equal)\n\n");
249: }
250:
251: printf(" 2: %s, %s\n", d_INT, d_REL);
252: printf(" 1: %s, %s\n", d_INT, d_REL);
253: printf("-> 1: %s\n\n", d_INT);
254:
255: printf(" 2: %s\n", d_BIN);
256: printf(" 1: %s\n", d_BIN);
257: printf("-> 1: %s\n\n", d_INT);
258:
259: printf(" 2: %s\n", d_CHN);
260: printf(" 1: %s\n", d_CHN);
261: printf("-> 1: %s\n\n", d_INT);
262:
263: printf(" 2: %s\n", d_NOM);
264: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
265: printf("-> 1: %s\n\n", d_ALG);
266:
267: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
268: printf(" 1: %s\n", d_NOM);
269: printf("-> 1: %s\n\n", d_ALG);
270:
271: printf(" 2: %s\n", d_ALG);
272: printf(" 1: %s\n", d_ALG);
273: printf("-> 1: %s\n\n", d_ALG);
274:
275: printf(" 2: %s\n", d_RPN);
276: printf(" 1: %s\n", d_RPN);
277: printf("-> 1: %s\n", d_RPN);
278:
279: return;
280: }
281: else if ((*s_etat_processus).test_instruction == 'Y')
282: {
283: (*s_etat_processus).nombre_arguments = 0;
284: return;
285: }
286:
287: if (test_cfsf(s_etat_processus, 31) == d_vrai)
288: {
289: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
290: {
291: return;
292: }
293: }
294:
295: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
296: &s_objet_argument_1) == d_erreur)
297: {
298: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
299: return;
300: }
301:
302: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
303: &s_objet_argument_2) == d_erreur)
304: {
305: liberation(s_etat_processus, s_objet_argument_1);
306:
307: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
308: return;
309: }
310:
311: /*
312: --------------------------------------------------------------------------------
313: LE sur des valeurs numériques
314: --------------------------------------------------------------------------------
315: */
316:
317: if ((((*s_objet_argument_1).type == INT) ||
318: ((*s_objet_argument_1).type == REL)) &&
319: (((*s_objet_argument_2).type == INT) ||
320: ((*s_objet_argument_2).type == REL)))
321: {
322: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
323: {
324: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
325: return;
326: }
327:
328: if ((*s_objet_argument_1).type == INT)
329: {
330: if ((*s_objet_argument_2).type == INT)
331: {
332: (*((integer8 *) (*s_objet_resultat).objet)) =
333: ((*((integer8 *) (*s_objet_argument_1).objet)) >=
334: (*((integer8 *) (*s_objet_argument_2).objet)))
335: ? -1 : 0;
336: }
337: else
338: {
339: (*((integer8 *) (*s_objet_resultat).objet)) =
340: ((*((integer8 *) (*s_objet_argument_1).objet)) >=
341: (*((real8 *) (*s_objet_argument_2).objet)))
342: ? -1 : 0;
343: }
344: }
345: else
346: {
347: if ((*s_objet_argument_2).type == INT)
348: {
349: (*((integer8 *) (*s_objet_resultat).objet)) =
350: ((*((real8 *) (*s_objet_argument_1).objet)) >=
351: (*((integer8 *) (*s_objet_argument_2).objet)))
352: ? -1 : 0;
353: }
354: else
355: {
356: (*((integer8 *) (*s_objet_resultat).objet)) =
357: ((*((real8 *) (*s_objet_argument_1).objet)) >=
358: (*((real8 *) (*s_objet_argument_2).objet)))
359: ? -1 : 0;
360: }
361: }
362: }
363:
364: /*
365: --------------------------------------------------------------------------------
366: LE binaire
367: --------------------------------------------------------------------------------
368: */
369:
370: else if (((*s_objet_argument_1).type == BIN) &&
371: ((*s_objet_argument_2).type == BIN))
372: {
373: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
374: {
375: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
376: return;
377: }
378:
379: (*((integer8 *) (*s_objet_resultat).objet)) =
380: ((*((logical8 *) (*s_objet_argument_1).objet)) >=
381: (*((logical8 *) (*s_objet_argument_2).objet)))
382: ? -1 : 0;
383: }
384:
385: /*
386: --------------------------------------------------------------------------------
387: LE portant sur des chaînes de caractères
388: --------------------------------------------------------------------------------
389: */
390:
391: else if (((*s_objet_argument_1).type == CHN) &&
392: ((*s_objet_argument_2).type == CHN))
393: {
394: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
395: {
396: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
397: return;
398: }
399:
400: (*((integer8 *) (*s_objet_resultat).objet)) =
401: (strcmp((unsigned char *) (*s_objet_argument_1).objet,
402: (unsigned char *) (*s_objet_argument_2).objet) >= 0) ? -1 : 0;
403: }
404:
405: /*
406: --------------------------------------------------------------------------------
407: LE entre des arguments complexes
408: --------------------------------------------------------------------------------
409: */
410:
411: /*
412: * Nom ou valeur numérique / Nom ou valeur numérique
413: */
414:
415: else if ((((*s_objet_argument_1).type == NOM) &&
416: (((*s_objet_argument_2).type == NOM) ||
417: ((*s_objet_argument_2).type == INT) ||
418: ((*s_objet_argument_2).type == REL))) ||
419: (((*s_objet_argument_2).type == NOM) &&
420: (((*s_objet_argument_1).type == INT) ||
421: ((*s_objet_argument_1).type == REL))))
422: {
423: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
424: {
425: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
426: return;
427: }
428:
429: if (((*s_objet_resultat).objet =
430: allocation_maillon(s_etat_processus)) == NULL)
431: {
432: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
433: return;
434: }
435:
436: l_element_courant = (*s_objet_resultat).objet;
437:
438: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
439: == NULL)
440: {
441: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
442: return;
443: }
444:
445: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
446: .nombre_arguments = 0;
447: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
448: .fonction = instruction_vers_niveau_superieur;
449:
450: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
451: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
452: {
453: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
454: return;
455: }
456:
457: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
458: .nom_fonction, "<<");
459:
460: if (((*l_element_courant).suivant =
461: allocation_maillon(s_etat_processus)) == NULL)
462: {
463: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
464: return;
465: }
466:
467: l_element_courant = (*l_element_courant).suivant;
468: (*l_element_courant).donnee = s_objet_argument_2;
469:
470: if (((*l_element_courant).suivant =
471: allocation_maillon(s_etat_processus)) == NULL)
472: {
473: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
474: return;
475: }
476:
477: l_element_courant = (*l_element_courant).suivant;
478: (*l_element_courant).donnee = s_objet_argument_1;
479:
480: if (((*l_element_courant).suivant =
481: allocation_maillon(s_etat_processus)) == NULL)
482: {
483: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
484: return;
485: }
486:
487: l_element_courant = (*l_element_courant).suivant;
488:
489: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
490: == NULL)
491: {
492: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
493: return;
494: }
495:
496: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
497: .nombre_arguments = 0;
498: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
499: .fonction = instruction_le;
500:
501: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
502: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
503: {
504: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
505: return;
506: }
507:
508: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
509: .nom_fonction, "<=");
510:
511: if (((*l_element_courant).suivant =
512: allocation_maillon(s_etat_processus)) == NULL)
513: {
514: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
515: return;
516: }
517:
518: l_element_courant = (*l_element_courant).suivant;
519:
520: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
521: == NULL)
522: {
523: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
524: return;
525: }
526:
527: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
528: .nombre_arguments = 0;
529: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
530: .fonction = instruction_vers_niveau_inferieur;
531:
532: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
533: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
534: {
535: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
536: return;
537: }
538:
539: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
540: .nom_fonction, ">>");
541:
542: (*l_element_courant).suivant = NULL;
543:
544: s_objet_argument_1 = NULL;
545: s_objet_argument_2 = NULL;
546: }
547:
548: /*
549: * Nom ou valeur numérique / Expression
550: */
551:
552: else if (((((*s_objet_argument_1).type == ALG) ||
553: ((*s_objet_argument_1).type == RPN))) &&
554: (((*s_objet_argument_2).type == NOM) ||
555: ((*s_objet_argument_2).type == INT) ||
556: ((*s_objet_argument_2).type == REL)))
557: {
558: nombre_elements = 0;
559: l_element_courant = (struct_liste_chainee *)
560: (*s_objet_argument_1).objet;
561:
562: while(l_element_courant != NULL)
563: {
564: nombre_elements++;
565: l_element_courant = (*l_element_courant).suivant;
566: }
567:
568: if (nombre_elements == 2)
569: {
570: liberation(s_etat_processus, s_objet_argument_1);
571: liberation(s_etat_processus, s_objet_argument_2);
572:
573: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
574: return;
575: }
576:
577: if ((s_objet_resultat = copie_objet(s_etat_processus,
578: s_objet_argument_1, 'N')) == NULL)
579: {
580: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
581: return;
582: }
583:
584: l_element_courant = (struct_liste_chainee *)
585: (*s_objet_resultat).objet;
586: l_element_precedent = l_element_courant;
587: l_element_courant = (*l_element_courant).suivant;
588:
589: if (((*l_element_precedent).suivant =
590: allocation_maillon(s_etat_processus)) == NULL)
591: {
592: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
593: return;
594: }
595:
596: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
597: (*(*l_element_precedent).suivant).suivant = l_element_courant;
598:
599: while((*l_element_courant).suivant != NULL)
600: {
601: l_element_precedent = l_element_courant;
602: l_element_courant = (*l_element_courant).suivant;
603: }
604:
605: if (((*l_element_precedent).suivant =
606: allocation_maillon(s_etat_processus)) == NULL)
607: {
608: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
609: return;
610: }
611:
612: if (((*(*l_element_precedent).suivant).donnee =
613: allocation(s_etat_processus, FCT)) == NULL)
614: {
615: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
616: return;
617: }
618:
619: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
620: .donnee).objet)).nombre_arguments = 0;
621: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
622: .donnee).objet)).fonction = instruction_le;
623:
624: if (((*((struct_fonction *) (*(*(*l_element_precedent)
625: .suivant).donnee).objet)).nom_fonction =
626: malloc(3 * sizeof(unsigned char))) == NULL)
627: {
628: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
629: return;
630: }
631:
632: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
633: .suivant).donnee).objet)).nom_fonction, "<=");
634:
635: (*(*l_element_precedent).suivant).suivant = l_element_courant;
636:
637: s_objet_argument_2 = NULL;
638: }
639:
640: /*
641: * Expression / Nom ou valeur numérique
642: */
643:
644: else if ((((*s_objet_argument_1).type == NOM) ||
645: ((*s_objet_argument_1).type == INT) ||
646: ((*s_objet_argument_1).type == REL)) &&
647: ((((*s_objet_argument_2).type == ALG) ||
648: ((*s_objet_argument_2).type == RPN))))
649: {
650: nombre_elements = 0;
651: l_element_courant = (struct_liste_chainee *)
652: (*s_objet_argument_2).objet;
653:
654: while(l_element_courant != NULL)
655: {
656: nombre_elements++;
657: l_element_courant = (*l_element_courant).suivant;
658: }
659:
660: if (nombre_elements == 2)
661: {
662: liberation(s_etat_processus, s_objet_argument_1);
663: liberation(s_etat_processus, s_objet_argument_2);
664:
665: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
666: return;
667: }
668:
669: if ((s_objet_resultat = copie_objet(s_etat_processus,
670: s_objet_argument_2, 'N')) == NULL)
671: {
672: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
673: return;
674: }
675:
676: l_element_courant = (struct_liste_chainee *)
677: (*s_objet_resultat).objet;
678: l_element_precedent = l_element_courant;
679:
680: while((*l_element_courant).suivant != NULL)
681: {
682: l_element_precedent = l_element_courant;
683: l_element_courant = (*l_element_courant).suivant;
684: }
685:
686: if (((*l_element_precedent).suivant =
687: allocation_maillon(s_etat_processus)) == NULL)
688: {
689: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
690: return;
691: }
692:
693: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
694: l_element_precedent = (*l_element_precedent).suivant;
695:
696: if (((*l_element_precedent).suivant =
697: allocation_maillon(s_etat_processus)) == NULL)
698: {
699: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
700: return;
701: }
702:
703: if (((*(*l_element_precedent).suivant).donnee =
704: allocation(s_etat_processus, FCT)) == NULL)
705: {
706: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
707: return;
708: }
709:
710: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
711: .donnee).objet)).nombre_arguments = 0;
712: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
713: .donnee).objet)).fonction = instruction_le;
714:
715: if (((*((struct_fonction *) (*(*(*l_element_precedent)
716: .suivant).donnee).objet)).nom_fonction =
717: malloc(3 * sizeof(unsigned char))) == NULL)
718: {
719: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
720: return;
721: }
722:
723: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
724: .suivant).donnee).objet)).nom_fonction, "<=");
725:
726: (*(*l_element_precedent).suivant).suivant = l_element_courant;
727:
728: s_objet_argument_1 = NULL;
729: }
730:
731: /*
732: * Expression / Expression
733: */
734:
735: else if ((((*s_objet_argument_1).type == ALG) &&
736: ((*s_objet_argument_2).type == ALG)) ||
737: (((*s_objet_argument_1).type == RPN) &&
738: ((*s_objet_argument_2).type == RPN)))
739: {
740: nombre_elements = 0;
741: l_element_courant = (struct_liste_chainee *)
742: (*s_objet_argument_1).objet;
743:
744: while(l_element_courant != NULL)
745: {
746: nombre_elements++;
747: l_element_courant = (*l_element_courant).suivant;
748: }
749:
750: if (nombre_elements == 2)
751: {
752: liberation(s_etat_processus, s_objet_argument_1);
753: liberation(s_etat_processus, s_objet_argument_2);
754:
755: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
756: return;
757: }
758:
759: nombre_elements = 0;
760: l_element_courant = (struct_liste_chainee *)
761: (*s_objet_argument_2).objet;
762:
763: while(l_element_courant != NULL)
764: {
765: nombre_elements++;
766: l_element_courant = (*l_element_courant).suivant;
767: }
768:
769: if (nombre_elements == 2)
770: {
771: liberation(s_etat_processus, s_objet_argument_1);
772: liberation(s_etat_processus, s_objet_argument_2);
773:
774: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
775: return;
776: }
777:
778: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
779: s_objet_argument_1, 'N')) == NULL)
780: {
781: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
782: return;
783: }
784:
785: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
786: s_objet_argument_2, 'N')) == NULL)
787: {
788: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
789: return;
790: }
791:
792: l_element_courant = (struct_liste_chainee *)
793: (*s_copie_argument_1).objet;
794: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
795: (*s_copie_argument_1).objet)).suivant;
796:
797: liberation(s_etat_processus, (*l_element_courant).donnee);
798: free(l_element_courant);
799:
800: l_element_courant = (struct_liste_chainee *)
801: (*s_copie_argument_2).objet;
802: l_element_precedent = l_element_courant;
803: s_objet_resultat = s_copie_argument_2;
804:
805: while((*l_element_courant).suivant != NULL)
806: {
807: l_element_precedent = l_element_courant;
808: l_element_courant = (*l_element_courant).suivant;
809: }
810:
811: liberation(s_etat_processus, (*l_element_courant).donnee);
812: free(l_element_courant);
813:
814: (*l_element_precedent).suivant = (struct_liste_chainee *)
815: (*s_copie_argument_1).objet;
816: free(s_copie_argument_1);
817:
818: l_element_courant = (*l_element_precedent).suivant;
819: while((*l_element_courant).suivant != NULL)
820: {
821: l_element_precedent = l_element_courant;
822: l_element_courant = (*l_element_courant).suivant;
823: }
824:
825: if (((*l_element_precedent).suivant =
826: allocation_maillon(s_etat_processus)) == NULL)
827: {
828: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
829: return;
830: }
831:
832: (*(*l_element_precedent).suivant).suivant = l_element_courant;
833: l_element_courant = (*l_element_precedent).suivant;
834:
835: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
836: == NULL)
837: {
838: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
839: return;
840: }
841:
842: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
843: .nombre_arguments = 0;
844: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
845: .fonction = instruction_le;
846:
847: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
848: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
849: {
850: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
851: return;
852: }
853:
854: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
855: .nom_fonction, "<=");
856: }
857:
858: /*
859: --------------------------------------------------------------------------------
860: LE impossible
861: --------------------------------------------------------------------------------
862: */
863:
864: else
865: {
866: liberation(s_etat_processus, s_objet_argument_1);
867: liberation(s_etat_processus, s_objet_argument_2);
868:
869: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
870: return;
871: }
872:
873: liberation(s_etat_processus, s_objet_argument_1);
874: liberation(s_etat_processus, s_objet_argument_2);
875:
876: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
877: s_objet_resultat) == d_erreur)
878: {
879: return;
880: }
881:
882: return;
883: }
884:
885:
886: /*
887: ================================================================================
888: Fonction '<'
889: ================================================================================
890: Entrées :
891: --------------------------------------------------------------------------------
892: Sorties :
893: --------------------------------------------------------------------------------
894: Effets de bord : néant
895: ================================================================================
896: */
897:
898: void
899: instruction_lt(struct_processus *s_etat_processus)
900: {
901: struct_liste_chainee *l_element_courant;
902: struct_liste_chainee *l_element_precedent;
903:
904: struct_objet *s_copie_argument_1;
905: struct_objet *s_copie_argument_2;
906: struct_objet *s_objet_argument_1;
907: struct_objet *s_objet_argument_2;
908: struct_objet *s_objet_resultat;
909:
910: unsigned long nombre_elements;
911:
912: (*s_etat_processus).erreur_execution = d_ex;
913:
914: if ((*s_etat_processus).affichage_arguments == 'Y')
915: {
916: printf("\n < ");
917:
918: if ((*s_etat_processus).langue == 'F')
919: {
920: printf("(opérateur inférieur strictement)\n\n");
921: }
922: else
923: {
924: printf("(less than)\n\n");
925: }
926:
927: printf(" 2: %s, %s\n", d_INT, d_REL);
928: printf(" 1: %s, %s\n", d_INT, d_REL);
929: printf("-> 1: %s\n\n", d_INT);
930:
931: printf(" 2: %s\n", d_BIN);
932: printf(" 1: %s\n", d_BIN);
933: printf("-> 1: %s\n\n", d_INT);
934:
935: printf(" 2: %s\n", d_CHN);
936: printf(" 1: %s\n", d_CHN);
937: printf("-> 1: %s\n\n", d_INT);
938:
939: printf(" 2: %s\n", d_NOM);
940: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
941: printf("-> 1: %s\n\n", d_ALG);
942:
943: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
944: printf(" 1: %s\n", d_NOM);
945: printf("-> 1: %s\n\n", d_ALG);
946:
947: printf(" 2: %s\n", d_ALG);
948: printf(" 1: %s\n", d_ALG);
949: printf("-> 1: %s\n\n", d_ALG);
950:
951: printf(" 2: %s\n", d_RPN);
952: printf(" 1: %s\n", d_RPN);
953: printf("-> 1: %s\n", d_RPN);
954:
955: return;
956: }
957: else if ((*s_etat_processus).test_instruction == 'Y')
958: {
959: (*s_etat_processus).nombre_arguments = 0;
960: return;
961: }
962:
963: if (test_cfsf(s_etat_processus, 31) == d_vrai)
964: {
965: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
966: {
967: return;
968: }
969: }
970:
971: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
972: &s_objet_argument_1) == d_erreur)
973: {
974: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
975: return;
976: }
977:
978: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
979: &s_objet_argument_2) == d_erreur)
980: {
981: liberation(s_etat_processus, s_objet_argument_1);
982:
983: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
984: return;
985: }
986:
987: /*
988: --------------------------------------------------------------------------------
989: LT sur des valeurs numériques
990: --------------------------------------------------------------------------------
991: */
992:
993: if ((((*s_objet_argument_1).type == INT) ||
994: ((*s_objet_argument_1).type == REL)) &&
995: (((*s_objet_argument_2).type == INT) ||
996: ((*s_objet_argument_2).type == REL)))
997: {
998: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
999: {
1000: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1001: return;
1002: }
1003:
1004: if ((*s_objet_argument_1).type == INT)
1005: {
1006: if ((*s_objet_argument_2).type == INT)
1007: {
1008: (*((integer8 *) (*s_objet_resultat).objet)) =
1009: ((*((integer8 *) (*s_objet_argument_1).objet)) >
1010: (*((integer8 *) (*s_objet_argument_2).objet)))
1011: ? -1 : 0;
1012: }
1013: else
1014: {
1015: (*((integer8 *) (*s_objet_resultat).objet)) =
1016: ((*((integer8 *) (*s_objet_argument_1).objet)) >
1017: (*((real8 *) (*s_objet_argument_2).objet)))
1018: ? -1 : 0;
1019: }
1020: }
1021: else
1022: {
1023: if ((*s_objet_argument_2).type == INT)
1024: {
1025: (*((integer8 *) (*s_objet_resultat).objet)) =
1026: ((*((real8 *) (*s_objet_argument_1).objet)) >
1027: (*((integer8 *) (*s_objet_argument_2).objet)))
1028: ? -1 : 0;
1029: }
1030: else
1031: {
1032: (*((integer8 *) (*s_objet_resultat).objet)) =
1033: ((*((real8 *) (*s_objet_argument_1).objet)) >
1034: (*((real8 *) (*s_objet_argument_2).objet)))
1035: ? -1 : 0;
1036: }
1037: }
1038: }
1039:
1040: /*
1041: --------------------------------------------------------------------------------
1042: LT binaire
1043: --------------------------------------------------------------------------------
1044: */
1045:
1046: else if (((*s_objet_argument_1).type == BIN) &&
1047: ((*s_objet_argument_2).type == BIN))
1048: {
1049: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
1050: {
1051: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1052: return;
1053: }
1054:
1055: (*((integer8 *) (*s_objet_resultat).objet)) =
1056: ((*((logical8 *) (*s_objet_argument_1).objet)) >
1057: (*((logical8 *) (*s_objet_argument_2).objet)))
1058: ? -1 : 0;
1059: }
1060:
1061: /*
1062: --------------------------------------------------------------------------------
1063: LT portant sur des chaînes de caractères
1064: --------------------------------------------------------------------------------
1065: */
1066:
1067: else if (((*s_objet_argument_1).type == CHN) &&
1068: ((*s_objet_argument_2).type == CHN))
1069: {
1070: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
1071: {
1072: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1073: return;
1074: }
1075:
1076: (*((integer8 *) (*s_objet_resultat).objet)) =
1077: (strcmp((unsigned char *) (*s_objet_argument_1).objet,
1078: (unsigned char *) (*s_objet_argument_2).objet) > 0) ? -1 : 0;
1079: }
1080:
1081: /*
1082: --------------------------------------------------------------------------------
1083: LT entre des arguments complexes
1084: --------------------------------------------------------------------------------
1085: */
1086:
1087: /*
1088: * Nom ou valeur numérique / Nom ou valeur numérique
1089: */
1090:
1091: else if ((((*s_objet_argument_1).type == NOM) &&
1092: (((*s_objet_argument_2).type == NOM) ||
1093: ((*s_objet_argument_2).type == INT) ||
1094: ((*s_objet_argument_2).type == REL))) ||
1095: (((*s_objet_argument_2).type == NOM) &&
1096: (((*s_objet_argument_1).type == INT) ||
1097: ((*s_objet_argument_1).type == REL))))
1098: {
1099: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
1100: {
1101: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1102: return;
1103: }
1104:
1105: if (((*s_objet_resultat).objet =
1106: allocation_maillon(s_etat_processus)) == NULL)
1107: {
1108: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1109: return;
1110: }
1111:
1112: l_element_courant = (*s_objet_resultat).objet;
1113:
1114: if (((*l_element_courant).donnee =
1115: allocation(s_etat_processus, FCT)) == NULL)
1116: {
1117: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1118: return;
1119: }
1120:
1121: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1122: .nombre_arguments = 0;
1123: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1124: .fonction = instruction_vers_niveau_superieur;
1125:
1126: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1127: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1128: {
1129: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1130: return;
1131: }
1132:
1133: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1134: .nom_fonction, "<<");
1135:
1136: if (((*l_element_courant).suivant =
1137: allocation_maillon(s_etat_processus)) == NULL)
1138: {
1139: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1140: return;
1141: }
1142:
1143: l_element_courant = (*l_element_courant).suivant;
1144: (*l_element_courant).donnee = s_objet_argument_2;
1145:
1146: if (((*l_element_courant).suivant =
1147: allocation_maillon(s_etat_processus)) == NULL)
1148: {
1149: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1150: return;
1151: }
1152:
1153: l_element_courant = (*l_element_courant).suivant;
1154: (*l_element_courant).donnee = s_objet_argument_1;
1155:
1156: if (((*l_element_courant).suivant =
1157: allocation_maillon(s_etat_processus)) == NULL)
1158: {
1159: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1160: return;
1161: }
1162:
1163: l_element_courant = (*l_element_courant).suivant;
1164:
1165: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1166: == NULL)
1167: {
1168: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1169: return;
1170: }
1171:
1172: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1173: .nombre_arguments = 0;
1174: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1175: .fonction = instruction_lt;
1176:
1177: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1178: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL)
1179: {
1180: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1181: return;
1182: }
1183:
1184: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1185: .nom_fonction, "<");
1186:
1187: if (((*l_element_courant).suivant =
1188: allocation_maillon(s_etat_processus)) == NULL)
1189: {
1190: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1191: return;
1192: }
1193:
1194: l_element_courant = (*l_element_courant).suivant;
1195:
1196: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1197: == NULL)
1198: {
1199: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1200: return;
1201: }
1202:
1203: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1204: .nombre_arguments = 0;
1205: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1206: .fonction = instruction_vers_niveau_inferieur;
1207:
1208: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1209: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1210: {
1211: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1212: return;
1213: }
1214:
1215: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1216: .nom_fonction, ">>");
1217:
1218: (*l_element_courant).suivant = NULL;
1219:
1220: s_objet_argument_1 = NULL;
1221: s_objet_argument_2 = NULL;
1222: }
1223:
1224: /*
1225: * Nom ou valeur numérique / Expression
1226: */
1227:
1228: else if (((((*s_objet_argument_1).type == ALG) ||
1229: ((*s_objet_argument_1).type == RPN))) &&
1230: (((*s_objet_argument_2).type == NOM) ||
1231: ((*s_objet_argument_2).type == INT) ||
1232: ((*s_objet_argument_2).type == REL)))
1233: {
1234: nombre_elements = 0;
1235: l_element_courant = (struct_liste_chainee *)
1236: (*s_objet_argument_1).objet;
1237:
1238: while(l_element_courant != NULL)
1239: {
1240: nombre_elements++;
1241: l_element_courant = (*l_element_courant).suivant;
1242: }
1243:
1244: if (nombre_elements == 2)
1245: {
1246: liberation(s_etat_processus, s_objet_argument_1);
1247: liberation(s_etat_processus, s_objet_argument_2);
1248:
1249: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1250: return;
1251: }
1252:
1253: if ((s_objet_resultat = copie_objet(s_etat_processus,
1254: s_objet_argument_1, 'N')) == NULL)
1255: {
1256: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1257: return;
1258: }
1259:
1260: l_element_courant = (struct_liste_chainee *)
1261: (*s_objet_resultat).objet;
1262: l_element_precedent = l_element_courant;
1263: l_element_courant = (*l_element_courant).suivant;
1264:
1265: if (((*l_element_precedent).suivant =
1266: allocation_maillon(s_etat_processus)) == NULL)
1267: {
1268: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1269: return;
1270: }
1271:
1272: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
1273: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1274:
1275: while((*l_element_courant).suivant != NULL)
1276: {
1277: l_element_precedent = l_element_courant;
1278: l_element_courant = (*l_element_courant).suivant;
1279: }
1280:
1281: if (((*l_element_precedent).suivant =
1282: allocation_maillon(s_etat_processus)) == NULL)
1283: {
1284: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1285: return;
1286: }
1287:
1288: if (((*(*l_element_precedent).suivant).donnee =
1289: allocation(s_etat_processus, FCT)) == NULL)
1290: {
1291: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1292: return;
1293: }
1294:
1295: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1296: .donnee).objet)).nombre_arguments = 0;
1297: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1298: .donnee).objet)).fonction = instruction_lt;
1299:
1300: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1301: .suivant).donnee).objet)).nom_fonction =
1302: malloc(2 * sizeof(unsigned char))) == NULL)
1303: {
1304: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1305: return;
1306: }
1307:
1308: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1309: .suivant).donnee).objet)).nom_fonction, "<");
1310:
1311: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1312:
1313: s_objet_argument_2 = NULL;
1314: }
1315:
1316: /*
1317: * Expression / Nom ou valeur numérique
1318: */
1319:
1320: else if ((((*s_objet_argument_1).type == NOM) ||
1321: ((*s_objet_argument_1).type == INT) ||
1322: ((*s_objet_argument_1).type == REL)) &&
1323: ((((*s_objet_argument_2).type == ALG) ||
1324: ((*s_objet_argument_2).type == RPN))))
1325: {
1326: nombre_elements = 0;
1327: l_element_courant = (struct_liste_chainee *)
1328: (*s_objet_argument_2).objet;
1329:
1330: while(l_element_courant != NULL)
1331: {
1332: nombre_elements++;
1333: l_element_courant = (*l_element_courant).suivant;
1334: }
1335:
1336: if (nombre_elements == 2)
1337: {
1338: liberation(s_etat_processus, s_objet_argument_1);
1339: liberation(s_etat_processus, s_objet_argument_2);
1340:
1341: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1342: return;
1343: }
1344:
1345: if ((s_objet_resultat = copie_objet(s_etat_processus,
1346: s_objet_argument_2, 'N')) == NULL)
1347: {
1348: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1349: return;
1350: }
1351:
1352: l_element_courant = (struct_liste_chainee *)
1353: (*s_objet_resultat).objet;
1354: l_element_precedent = l_element_courant;
1355:
1356: while((*l_element_courant).suivant != NULL)
1357: {
1358: l_element_precedent = l_element_courant;
1359: l_element_courant = (*l_element_courant).suivant;
1360: }
1361:
1362: if (((*l_element_precedent).suivant =
1363: allocation_maillon(s_etat_processus)) == NULL)
1364: {
1365: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1366: return;
1367: }
1368:
1369: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
1370: l_element_precedent = (*l_element_precedent).suivant;
1371:
1372: if (((*l_element_precedent).suivant =
1373: allocation_maillon(s_etat_processus)) == NULL)
1374: {
1375: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1376: return;
1377: }
1378:
1379: if (((*(*l_element_precedent).suivant).donnee =
1380: allocation(s_etat_processus, FCT)) == NULL)
1381: {
1382: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1383: return;
1384: }
1385:
1386: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1387: .donnee).objet)).nombre_arguments = 0;
1388: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1389: .donnee).objet)).fonction = instruction_lt;
1390:
1391: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1392: .suivant).donnee).objet)).nom_fonction =
1393: malloc(2 * sizeof(unsigned char))) == NULL)
1394: {
1395: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1396: return;
1397: }
1398:
1399: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1400: .suivant).donnee).objet)).nom_fonction, "<");
1401:
1402: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1403:
1404: s_objet_argument_1 = NULL;
1405: }
1406:
1407: /*
1408: * Expression / Expression
1409: */
1410:
1411: else if ((((*s_objet_argument_1).type == ALG) &&
1412: ((*s_objet_argument_2).type == ALG)) ||
1413: (((*s_objet_argument_1).type == RPN) &&
1414: ((*s_objet_argument_2).type == RPN)))
1415: {
1416: nombre_elements = 0;
1417: l_element_courant = (struct_liste_chainee *)
1418: (*s_objet_argument_1).objet;
1419:
1420: while(l_element_courant != NULL)
1421: {
1422: nombre_elements++;
1423: l_element_courant = (*l_element_courant).suivant;
1424: }
1425:
1426: if (nombre_elements == 2)
1427: {
1428: liberation(s_etat_processus, s_objet_argument_1);
1429: liberation(s_etat_processus, s_objet_argument_2);
1430:
1431: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1432: return;
1433: }
1434:
1435: nombre_elements = 0;
1436: l_element_courant = (struct_liste_chainee *)
1437: (*s_objet_argument_2).objet;
1438:
1439: while(l_element_courant != NULL)
1440: {
1441: nombre_elements++;
1442: l_element_courant = (*l_element_courant).suivant;
1443: }
1444:
1445: if (nombre_elements == 2)
1446: {
1447: liberation(s_etat_processus, s_objet_argument_1);
1448: liberation(s_etat_processus, s_objet_argument_2);
1449:
1450: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1451: return;
1452: }
1453:
1454: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
1455: s_objet_argument_1, 'N')) == NULL)
1456: {
1457: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1458: return;
1459: }
1460:
1461: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
1462: s_objet_argument_2, 'N')) == NULL)
1463: {
1464: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1465: return;
1466: }
1467:
1468: l_element_courant = (struct_liste_chainee *)
1469: (*s_copie_argument_1).objet;
1470: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
1471: (*s_copie_argument_1).objet)).suivant;
1472:
1473: liberation(s_etat_processus, (*l_element_courant).donnee);
1474: free(l_element_courant);
1475:
1476: l_element_courant = (struct_liste_chainee *)
1477: (*s_copie_argument_2).objet;
1478: l_element_precedent = l_element_courant;
1479: s_objet_resultat = s_copie_argument_2;
1480:
1481: while((*l_element_courant).suivant != NULL)
1482: {
1483: l_element_precedent = l_element_courant;
1484: l_element_courant = (*l_element_courant).suivant;
1485: }
1486:
1487: liberation(s_etat_processus, (*l_element_courant).donnee);
1488: free(l_element_courant);
1489:
1490: (*l_element_precedent).suivant = (struct_liste_chainee *)
1491: (*s_copie_argument_1).objet;
1492: free(s_copie_argument_1);
1493:
1494: l_element_courant = (*l_element_precedent).suivant;
1495: while((*l_element_courant).suivant != NULL)
1496: {
1497: l_element_precedent = l_element_courant;
1498: l_element_courant = (*l_element_courant).suivant;
1499: }
1500:
1501: if (((*l_element_precedent).suivant =
1502: allocation_maillon(s_etat_processus)) == NULL)
1503: {
1504: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1505: return;
1506: }
1507:
1508: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1509: l_element_courant = (*l_element_precedent).suivant;
1510:
1511: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1512: == NULL)
1513: {
1514: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1515: return;
1516: }
1517:
1518: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1519: .nombre_arguments = 0;
1520: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1521: .fonction = instruction_lt;
1522:
1523: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1524: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL)
1525: {
1526: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1527: return;
1528: }
1529:
1530: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1531: .nom_fonction, "<");
1532: }
1533:
1534: /*
1535: --------------------------------------------------------------------------------
1536: LT impossible
1537: --------------------------------------------------------------------------------
1538: */
1539:
1540: else
1541: {
1542: liberation(s_etat_processus, s_objet_argument_1);
1543: liberation(s_etat_processus, s_objet_argument_2);
1544:
1545: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1546: return;
1547: }
1548:
1549: liberation(s_etat_processus, s_objet_argument_1);
1550: liberation(s_etat_processus, s_objet_argument_2);
1551:
1552: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1553: s_objet_resultat) == d_erreur)
1554: {
1555: return;
1556: }
1557:
1558: return;
1559: }
1560:
1561:
1562: /*
1563: ================================================================================
1564: Fonction 'last'
1565: ================================================================================
1566: Entrées : structure processus
1567: --------------------------------------------------------------------------------
1568: Sorties :
1569: --------------------------------------------------------------------------------
1570: Effets de bord : néant
1571: ================================================================================
1572: */
1573:
1574: void
1575: instruction_last(struct_processus *s_etat_processus)
1576: {
1577: struct_liste_chainee *l_element_courant;
1578:
1579: struct_objet *s_objet;
1580:
1581: (*s_etat_processus).erreur_execution = d_ex;
1582:
1583: if ((*s_etat_processus).affichage_arguments == 'Y')
1584: {
1585: printf("\n LAST ");
1586:
1587: if ((*s_etat_processus).langue == 'F')
1588: {
1589: printf("(renvoie les arguments de la dernière fonction "
1590: "intrinsèque)\n\n");
1591: printf(" Aucun argument\n");
1592: }
1593: else
1594: {
1595: printf("(return arguments of the last intrinsic function)\n\n");
1596: printf(" No argument\n");
1597: }
1598:
1599: return;
1600: }
1601: else if ((*s_etat_processus).test_instruction == 'Y')
1602: {
1603: (*s_etat_processus).nombre_arguments = -1;
1604: return;
1605: }
1606:
1607: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1608: {
1609: l_element_courant = (*s_etat_processus).l_base_pile_last;
1610:
1611: while(l_element_courant != NULL)
1612: {
1613: if ((s_objet = copie_objet(s_etat_processus,
1614: (*l_element_courant).donnee, 'P')) == NULL)
1615: {
1616: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1617: return;
1618: }
1619:
1620: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1621: s_objet) == d_erreur)
1622: {
1623: return;
1624: }
1625:
1626: l_element_courant = (*l_element_courant).suivant;
1627: }
1628: }
1629:
1630: return;
1631: }
1632:
1633: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_l1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src