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