![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to calcul_differentiel.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to calcul_differentiel.c CVS log | Up to [local] / rpl / src |
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 'derivation'
29: ================================================================================
30: Entrées : pointeur sur une structure struct_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: derivation(struct_processus *s_etat_processus, struct_objet **s_expression)
40: {
41: /*
42: * Faire le calcul directement sur l'expression RPN. Mettre les
43: * pointeurs dans une pile pour pouvoir circuler dans l'autre sens.
44: * << 2 X * >> -> << 2 X * X DER >>
45: * -> << 2 X DER X * 2 X X DER * + >> -> << 0 X * 2 1 * + >>
46: * -> << 2 >>
47: *
48: * << X 2 * 3 + COS >> -> << X 2 * 3 + COS X DER >>
49: * -> << X 2 * 3 + SIN NEG X 2 * 3 + X DER * >>
50: *
51: * Prévoir la simplification des expressions faite par une évaluation
52: * symbolique ('E').
53: */
54:
55: integer8 derivee;
56:
57: logical1 derivee_fonction_disponible;
58: logical1 drapeau;
59: logical1 fin_boucle;
60:
61: static unsigned char *fonctions[] =
62: {
63: "ABS", "1", NULL,
64: "FCT", "SIGN", "1",
65: NULL,
66:
67: "ARG", "1", NULL,
68: "FCT", "INV", "1",
69: "FCT", "DUP", "1",
70: "FCT", "CONJ", "1",
71: "FCT", "-", "0",
72: "INT", "2", "0",
73: "NOM", "i", "0",
74: "FCT", "*", "0",
75: "FCT", "/", "0",
76: NULL,
77:
78: "ACOS", "1", NULL,
79: "INT", "1", "0",
80: "FCT", "SWAP", "2",
81: "FCT", "SQ", "1",
82: "FCT", "-", "0",
83: "FCT", "SQRT", "1",
84: "FCT", "INV", "1",
85: "FCT", "NEG", "1",
86: NULL,
87:
88: "ACOSH", "1", NULL,
89: "FCT", "DUP", "1",
90: "INT", "1", "0",
91: "FCT", "-", "0",
92: "FCT", "SQRT", "1",
93: "FCT", "SWAP", "1",
94: "INT", "1", "0",
95: "FCT", "+", "0",
96: "FCT", "SQRT", "1",
97: "FCT", "*", "0",
98: "FCT", "INV", "1",
99: NULL,
100:
101: "ALOG", "1", NULL,
102: "FCT", "ALOG", "1",
103: "INT", "10", "0",
104: "FCT", "LN", "1",
105: "FCT", "*", "0",
106: NULL,
107:
108: "ASIN", "1", NULL,
109: "INT", "1", "0",
110: "FCT", "SWAP", "2",
111: "FCT", "SQ", "1",
112: "FCT", "-", "0",
113: "FCT", "SQRT", "1",
114: "FCT", "INV", "1",
115: NULL,
116:
117: "ASINH", "1", NULL,
118: "FCT", "SQ", "1",
119: "INT", "1", "0",
120: "FCT", "SWAP", "2",
121: "FCT", "+", "0",
122: "FCT", "SQRT", "1",
123: "FCT", "INV", "1",
124: NULL,
125:
126: "ATAN", "1", NULL,
127: "INT", "1", "0",
128: "FCT", "SWAP", "2",
129: "FCT", "SQ", "1",
130: "FCT", "+", "0",
131: "FCT", "INV", "1",
132: NULL,
133:
134: "ATANH", "1", NULL,
135: "FCT", "SQ", "1",
136: "INT", "1", "0",
137: "FCT", "SWAP", "2",
138: "FCT", "-", "0",
139: "FCT", "INV", "1",
140: NULL,
141:
142: "CONJ", "1", NULL,
143: "FCT", "SWAP", "2",
144: "FCT", "DROP", "1",
145: "DER", "0", "0",
146: "FCT", "CONJ", "1",
147: "INT", "1", "0",
148: NULL,
149:
150: "COS", "1", NULL,
151: "FCT", "SIN", "1",
152: "FCT", "NEG", "1",
153: NULL,
154:
155: "COSH", "1", NULL,
156: "FCT", "SINH", "1",
157: NULL,
158:
159: "EXP", "1", NULL,
160: "FCT", "EXP", "1",
161: NULL,
162:
163: "EXPM", "1", NULL,
164: "FCT", "EXP", "1",
165: NULL,
166:
167: "IM", "1", NULL,
168: "FCT", "SWAP", "2",
169: "FCT", "DROP", "1",
170: "DER", "0", "0",
171: "FCT", "IM", "1",
172: "INT", "1", "0",
173: NULL,
174:
175: "INV", "1", NULL,
176: "FCT", "SQ", "1",
177: "FCT", "INV", "1",
178: "FCT", "NEG", "1",
179: NULL,
180:
181: "LN", "1", NULL,
182: "FCT", "INV", "1",
183: NULL,
184:
185: "LNP1", "1", NULL,
186: "INT", "1", "0",
187: "FCT", "+", "0",
188: "FCT", "INV", "1",
189: NULL,
190:
191: "LOG", "1", NULL,
192: "INT", "10", "0",
193: "FCT", "LN", "1",
194: "FCT", "*", "0",
195: "FCT", "INV", "1",
196: NULL,
197:
198: "NEG", "1", NULL,
199: "FCT", "SWAP", "2",
200: "FCT", "DROP", "1",
201: "DER", "0", "0",
202: "FCT", "NEG", "1",
203: "INT", "1", "0",
204: NULL,
205:
206: "RE", "1", NULL,
207: "FCT", "SWAP", "2",
208: "FCT", "DROP", "1",
209: "DER", "0", "0",
210: "FCT", "RE", "1",
211: "INT", "1", "0",
212: NULL,
213:
214: "RELAX", "1", NULL,
215: "FCT", "DROP", "1",
216: "INT", "1", "0",
217: NULL,
218:
219: "SIN", "1", NULL,
220: "FCT", "COS", "1",
221: NULL,
222:
223: "SINH", "1", NULL,
224: "FCT", "COSH", "1",
225: NULL,
226:
227: "SQ", "1", NULL,
228: "INT", "2", "0",
229: "FCT", "*", "0",
230: NULL,
231:
232: "SQRT", "1", NULL,
233: "FCT", "SQRT", "1",
234: "INT", "2", "0",
235: "FCT", "*", "0",
236: "FCT", "INV", "1",
237: NULL,
238:
239: "TAN", "1", NULL,
240: "INT", "1", "0",
241: "FCT", "SWAP", "2",
242: "FCT", "TAN", "1",
243: "FCT", "SQ", "1",
244: "FCT", "+", "0",
245: NULL,
246:
247: "TANH", "1", NULL,
248: "FCT", "COSH", "1",
249: "FCT", "SQ", "1",
250: "FCT", "INV", "1",
251: NULL,
252:
253: "XROOT", "2", NULL,
254: "FCT", "INV", "1",
255: "FCT", "**", "0",
256: "DER", "0", "0",
257: NULL,
258:
259: "=" , "0", NULL,
260: "FCT", "SWAP", "2",
261: "FCT", "DROP", "1",
262: "FCT", "SWAP", "2",
263: "DER", "0", "0",
264: "FCT", "SWAP", "2",
265: "DER", "0", "0",
266: "FCT", "=", "0",
267: "INT", "1", "0",
268: NULL,
269:
270: NULL
271: };
272:
273: struct_liste_chainee *l_element_courant;
274: struct_liste_chainee *l_element_suivant;
275:
276: struct_objet *s_copie;
277: struct_objet *s_expression_courante;
278:
279: unsigned char *tampon;
280: unsigned char *variable;
281:
282: unsigned long i;
283: unsigned long position_courante;
284: unsigned long type_operation;
285:
286: if ((s_copie = copie_objet(s_etat_processus, *s_expression, 'O')) == NULL)
287: {
288: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
289: return;
290: }
291:
292: liberation(s_etat_processus, *s_expression);
293: *s_expression = s_copie;
294: s_expression_courante = *s_expression;
295:
296: do
297: {
298: /*
299: * Recherche de la première occurrence de la fonction DER
300: */
301:
302: l_element_courant = (struct_liste_chainee *)
303: (*s_expression_courante).objet;
304: position_courante = 0;
305: drapeau = d_faux;
306:
307: while((l_element_courant != NULL) && (drapeau == d_faux))
308: {
309: if ((*(*l_element_courant).donnee).type == FCT)
310: {
311: if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee)
312: .objet)).nom_fonction, "DER") == 0)
313: {
314: drapeau = d_vrai;
315: }
316: }
317:
318: l_element_courant = (*l_element_courant).suivant;
319:
320: if (drapeau == d_faux)
321: {
322: position_courante++;
323: }
324: }
325:
326: l_element_courant = (struct_liste_chainee *)
327: (*s_expression_courante).objet;
328:
329: for(i = 0; i < (position_courante - 2);
330: i++, l_element_courant = (*l_element_courant).suivant);
331:
332: variable = (*((struct_nom *) (*(*(*l_element_courant).suivant)
333: .donnee).objet)).nom;
334:
335: /*
336: * Recherche du type d'objet à dériver
337: */
338:
339: if (((*(*l_element_courant).donnee).type == INT) ||
340: ((*(*l_element_courant).donnee).type == REL) ||
341: ((*(*l_element_courant).donnee).type == CPL))
342: {
343: l_element_suivant = (*(*(*l_element_courant).suivant)
344: .suivant).suivant;
345:
346: liberation(s_etat_processus, (*l_element_courant).donnee);
347: liberation(s_etat_processus,
348: (*(*l_element_courant).suivant).donnee);
349: liberation(s_etat_processus,
350: (*(*(*l_element_courant).suivant).suivant).donnee);
351:
352: free((*(*l_element_courant).suivant).suivant);
353: free((*l_element_courant).suivant);
354:
355: (*l_element_courant).suivant = l_element_suivant;
356:
357: if (((*l_element_courant).donnee = allocation(s_etat_processus,
358: INT)) == NULL)
359: {
360: (*s_expression) = s_expression_courante;
361: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
362: return;
363: }
364:
365: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = 0;
366: }
367: else if ((*(*l_element_courant).donnee).type == NOM)
368: {
369: l_element_suivant = (*(*(*l_element_courant).suivant)
370: .suivant).suivant;
371:
372: if (strcmp((*((struct_nom *) (*(*l_element_courant).donnee).objet))
373: .nom, variable) == 0)
374: {
375: derivee = 1;
376: }
377: else
378: {
379: derivee = 0;
380: }
381:
382: liberation(s_etat_processus, (*l_element_courant).donnee);
383: liberation(s_etat_processus,
384: (*(*l_element_courant).suivant).donnee);
385: liberation(s_etat_processus,
386: (*(*(*l_element_courant).suivant).suivant).donnee);
387:
388: free((*(*l_element_courant).suivant).suivant);
389: free((*l_element_courant).suivant);
390:
391: (*l_element_courant).suivant = l_element_suivant;
392:
393: if (((*l_element_courant).donnee = allocation(s_etat_processus,
394: INT)) == NULL)
395: {
396: (*s_expression) = s_expression_courante;
397: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
398: return;
399: }
400:
401: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = derivee;
402: }
403: else if ((*(*l_element_courant).donnee).type == FCT)
404: {
405: if ((strcmp((*((struct_fonction *) (*(*l_element_courant).donnee)
406: .objet)).nom_fonction, "+") == 0) ||
407: (strcmp((*((struct_fonction *) (*(*l_element_courant)
408: .donnee).objet)).nom_fonction, "-") == 0))
409: {
410: if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee)
411: .objet)).nom_fonction, "+") == 0)
412: {
413: // Opération à dériver : '+'
414: type_operation = 0;
415: }
416: else
417: {
418: // Opération à dériver : '-'
419: type_operation = 1;
420: }
421:
422: /*
423: * Transormer << + X DER >> en << SWAP X DER SWAP X DER + >>
424: * ou << - X DER >> en << SWAP X DER SWAP X DER - >>
425: */
426:
427: // Transformation du '+' en SWAP
428:
429: l_element_suivant = (*l_element_courant).suivant;
430:
431: free((*((struct_fonction *) (*(*l_element_courant).donnee)
432: .objet)).nom_fonction);
433:
434: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
435: .objet)).nom_fonction = malloc(5 *
436: sizeof(unsigned char))) == NULL)
437: {
438: (*s_expression) = s_expression_courante;
439: (*s_etat_processus).erreur_systeme =
440: d_es_allocation_memoire;
441: return;
442: }
443:
444: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
445: .objet)).nom_fonction, "SWAP");
446: (*((struct_fonction *) (*(*l_element_courant).donnee)
447: .objet)).nombre_arguments = -1;
448: (*((struct_fonction *) (*(*l_element_courant).donnee)
449: .objet)).fonction = instruction_swap;
450:
451: // Ajout de la variable de dérivation
452:
453: if (((*l_element_courant).suivant = malloc(
454: sizeof(struct_liste_chainee))) == NULL)
455: {
456: (*s_expression) = s_expression_courante;
457: (*s_etat_processus).erreur_systeme =
458: d_es_allocation_memoire;
459: return;
460: }
461:
462: l_element_courant = (*l_element_courant).suivant;
463:
464: if (((*l_element_courant).donnee = allocation(s_etat_processus,
465: NOM)) == NULL)
466: {
467: (*s_expression) = s_expression_courante;
468: (*s_etat_processus).erreur_systeme =
469: d_es_allocation_memoire;
470: return;
471: }
472:
473: if (((*((struct_nom *) (*(*l_element_courant).donnee)
474: .objet)).nom = malloc((strlen(variable) + 1)
475: * sizeof(unsigned char))) == NULL)
476: {
477: (*s_expression) = s_expression_courante;
478: (*s_etat_processus).erreur_systeme =
479: d_es_allocation_memoire;
480: return;
481: }
482:
483: strcpy((*((struct_nom *) (*(*l_element_courant).donnee)
484: .objet)).nom, variable);
485: (*((struct_nom *) (*(*l_element_courant).donnee).objet))
486: .symbole = d_vrai;
487:
488: // Ajout de la fonction DER
489:
490: if (((*l_element_courant).suivant = malloc(
491: sizeof(struct_liste_chainee))) == NULL)
492: {
493: (*s_expression) = s_expression_courante;
494: (*s_etat_processus).erreur_systeme =
495: d_es_allocation_memoire;
496: return;
497: }
498:
499: l_element_courant = (*l_element_courant).suivant;
500:
501: if (((*l_element_courant).donnee = allocation(s_etat_processus,
502: FCT)) == NULL)
503: {
504: (*s_expression) = s_expression_courante;
505: (*s_etat_processus).erreur_systeme =
506: d_es_allocation_memoire;
507: return;
508: }
509:
510: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
511: .objet)).nom_fonction = malloc(4 *
512: sizeof(unsigned char))) == NULL)
513: {
514: (*s_expression) = s_expression_courante;
515: (*s_etat_processus).erreur_systeme =
516: d_es_allocation_memoire;
517: return;
518: }
519:
520: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
521: .objet)).nom_fonction, "DER");
522: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
523: .nombre_arguments = 2;
524: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
525: .fonction = instruction_der;
526:
527: // Ajout de la fonction SWAP
528:
529: if (((*l_element_courant).suivant = malloc(
530: sizeof(struct_liste_chainee))) == NULL)
531: {
532: (*s_expression) = s_expression_courante;
533: (*s_etat_processus).erreur_systeme =
534: d_es_allocation_memoire;
535: return;
536: }
537:
538: l_element_courant = (*l_element_courant).suivant;
539:
540: if (((*l_element_courant).donnee = allocation(s_etat_processus,
541: FCT)) == NULL)
542: {
543: (*s_expression) = s_expression_courante;
544: (*s_etat_processus).erreur_systeme =
545: d_es_allocation_memoire;
546: return;
547: }
548:
549: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
550: .objet)).nom_fonction = malloc(5 *
551: sizeof(unsigned char))) == NULL)
552: {
553: (*s_expression) = s_expression_courante;
554: (*s_etat_processus).erreur_systeme =
555: d_es_allocation_memoire;
556: return;
557: }
558:
559: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
560: .objet)).nom_fonction, "SWAP");
561: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
562: .nombre_arguments = -1;
563: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
564: .fonction = instruction_swap;
565:
566: // Ajout de la variable de dérivation
567:
568: if (((*l_element_courant).suivant = malloc(
569: sizeof(struct_liste_chainee))) == NULL)
570: {
571: (*s_expression) = s_expression_courante;
572: (*s_etat_processus).erreur_systeme =
573: d_es_allocation_memoire;
574: return;
575: }
576:
577: l_element_courant = (*l_element_courant).suivant;
578:
579: if (((*l_element_courant).donnee = allocation(s_etat_processus,
580: NOM)) == NULL)
581: {
582: (*s_expression) = s_expression_courante;
583: (*s_etat_processus).erreur_systeme =
584: d_es_allocation_memoire;
585: return;
586: }
587:
588: if (((*((struct_nom *) (*(*l_element_courant).donnee)
589: .objet)).nom = malloc((strlen(variable) + 1)
590: * sizeof(unsigned char))) == NULL)
591: {
592: (*s_expression) = s_expression_courante;
593: (*s_etat_processus).erreur_systeme =
594: d_es_allocation_memoire;
595: return;
596: }
597:
598: strcpy((*((struct_nom *) (*(*l_element_courant).donnee)
599: .objet)).nom, variable);
600: (*((struct_nom *) (*(*l_element_courant).donnee).objet))
601: .symbole = d_vrai;
602:
603: // Ajout de la fonction DER
604:
605: if (((*l_element_courant).suivant = malloc(
606: sizeof(struct_liste_chainee))) == NULL)
607: {
608: (*s_expression) = s_expression_courante;
609: (*s_etat_processus).erreur_systeme =
610: d_es_allocation_memoire;
611: return;
612: }
613:
614: l_element_courant = (*l_element_courant).suivant;
615:
616: if (((*l_element_courant).donnee = allocation(s_etat_processus,
617: FCT)) == NULL)
618: {
619: (*s_expression) = s_expression_courante;
620: (*s_etat_processus).erreur_systeme =
621: d_es_allocation_memoire;
622: return;
623: }
624:
625: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
626: .objet)).nom_fonction = malloc(4 *
627: sizeof(unsigned char))) == NULL)
628: {
629: (*s_expression) = s_expression_courante;
630: (*s_etat_processus).erreur_systeme =
631: d_es_allocation_memoire;
632: return;
633: }
634:
635: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
636: .objet)).nom_fonction, "DER");
637: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
638: .nombre_arguments = 2;
639: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
640: .fonction = instruction_der;
641:
642: (*l_element_courant).suivant = (*l_element_suivant).suivant;
643:
644: liberation(s_etat_processus, (*l_element_suivant).donnee);
645: free(l_element_suivant);
646:
647: // Ajout de l'opérateur
648:
649: l_element_courant = (*l_element_courant).suivant;
650:
651: free((*((struct_fonction *) (*(*l_element_courant).donnee)
652: .objet)).nom_fonction);
653:
654: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
655: .objet)).nom_fonction = malloc(2 *
656: sizeof(unsigned char))) == NULL)
657: {
658: (*s_expression) = s_expression_courante;
659: (*s_etat_processus).erreur_systeme =
660: d_es_allocation_memoire;
661: return;
662: }
663:
664: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
665: .objet)).nom_fonction,
666: (type_operation == 0) ? "+" : "-");
667: (*((struct_fonction *) (*(*l_element_courant).donnee)
668: .objet)).nombre_arguments = 0;
669: (*((struct_fonction *) (*(*l_element_courant).donnee)
670: .objet)).fonction = (type_operation == 0)
671: ? instruction_plus : instruction_moins;
672: }
673: else if (strcmp((*((struct_fonction *)
674: (*(*l_element_courant).donnee)
675: .objet)).nom_fonction, "*") == 0)
676: {
677: /*
678: * Transormer << * X DER >> en
679: * << DUP2 X DER * ROT X DER ROT * + >>
680: */
681:
682: // Transformation du '*' en DUP2
683:
684: l_element_suivant = (*l_element_courant).suivant;
685:
686: free((*((struct_fonction *) (*(*l_element_courant).donnee)
687: .objet)).nom_fonction);
688:
689: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
690: .objet)).nom_fonction = malloc(5 *
691: sizeof(unsigned char))) == NULL)
692: {
693: (*s_expression) = s_expression_courante;
694: (*s_etat_processus).erreur_systeme =
695: d_es_allocation_memoire;
696: return;
697: }
698:
699: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
700: .objet)).nom_fonction, "DUP2");
701: (*((struct_fonction *) (*(*l_element_courant).donnee)
702: .objet)).nombre_arguments = -1;
703: (*((struct_fonction *) (*(*l_element_courant).donnee)
704: .objet)).fonction = instruction_dup2;
705:
706: // Ajout de la variable de dérivation
707:
708: if (((*l_element_courant).suivant = malloc(
709: sizeof(struct_liste_chainee))) == NULL)
710: {
711: (*s_expression) = s_expression_courante;
712: (*s_etat_processus).erreur_systeme =
713: d_es_allocation_memoire;
714: return;
715: }
716:
717: l_element_courant = (*l_element_courant).suivant;
718:
719: if (((*l_element_courant).donnee = allocation(s_etat_processus,
720: NOM)) == NULL)
721: {
722: (*s_expression) = s_expression_courante;
723: (*s_etat_processus).erreur_systeme =
724: d_es_allocation_memoire;
725: return;
726: }
727:
728: if (((*((struct_nom *) (*(*l_element_courant).donnee)
729: .objet)).nom = malloc((strlen(variable) + 1)
730: * sizeof(unsigned char))) == NULL)
731: {
732: (*s_expression) = s_expression_courante;
733: (*s_etat_processus).erreur_systeme =
734: d_es_allocation_memoire;
735: return;
736: }
737:
738: strcpy((*((struct_nom *) (*(*l_element_courant).donnee)
739: .objet)).nom, variable);
740: (*((struct_nom *) (*(*l_element_courant).donnee).objet))
741: .symbole = d_vrai;
742:
743: // Ajout de la fonction DER
744:
745: if (((*l_element_courant).suivant = malloc(
746: sizeof(struct_liste_chainee))) == NULL)
747: {
748: (*s_expression) = s_expression_courante;
749: (*s_etat_processus).erreur_systeme =
750: d_es_allocation_memoire;
751: return;
752: }
753:
754: l_element_courant = (*l_element_courant).suivant;
755:
756: if (((*l_element_courant).donnee = allocation(s_etat_processus,
757: FCT)) == NULL)
758: {
759: (*s_expression) = s_expression_courante;
760: (*s_etat_processus).erreur_systeme =
761: d_es_allocation_memoire;
762: return;
763: }
764:
765: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
766: .objet)).nom_fonction = malloc(4 *
767: sizeof(unsigned char))) == NULL)
768: {
769: (*s_expression) = s_expression_courante;
770: (*s_etat_processus).erreur_systeme =
771: d_es_allocation_memoire;
772: return;
773: }
774:
775: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
776: .objet)).nom_fonction, "DER");
777: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
778: .nombre_arguments = 2;
779: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
780: .fonction = instruction_der;
781:
782: // Ajout de la fonction '*'
783:
784: if (((*l_element_courant).suivant = malloc(
785: sizeof(struct_liste_chainee))) == NULL)
786: {
787: (*s_expression) = s_expression_courante;
788: (*s_etat_processus).erreur_systeme =
789: d_es_allocation_memoire;
790: return;
791: }
792:
793: l_element_courant = (*l_element_courant).suivant;
794:
795: if (((*l_element_courant).donnee = allocation(s_etat_processus,
796: FCT)) == NULL)
797: {
798: (*s_expression) = s_expression_courante;
799: (*s_etat_processus).erreur_systeme =
800: d_es_allocation_memoire;
801: return;
802: }
803:
804: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
805: .objet)).nom_fonction = malloc(2 *
806: sizeof(unsigned char))) == NULL)
807: {
808: (*s_expression) = s_expression_courante;
809: (*s_etat_processus).erreur_systeme =
810: d_es_allocation_memoire;
811: return;
812: }
813:
814: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
815: .objet)).nom_fonction, "*");
816: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
817: .nombre_arguments = 0;
818: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
819: .fonction = instruction_multiplication;
820:
821: // Ajout de la fonction ROT
822:
823: if (((*l_element_courant).suivant = malloc(
824: sizeof(struct_liste_chainee))) == NULL)
825: {
826: (*s_expression) = s_expression_courante;
827: (*s_etat_processus).erreur_systeme =
828: d_es_allocation_memoire;
829: return;
830: }
831:
832: l_element_courant = (*l_element_courant).suivant;
833:
834: if (((*l_element_courant).donnee = allocation(s_etat_processus,
835: FCT)) == NULL)
836: {
837: (*s_expression) = s_expression_courante;
838: (*s_etat_processus).erreur_systeme =
839: d_es_allocation_memoire;
840: return;
841: }
842:
843: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
844: .objet)).nom_fonction = malloc(4 *
845: sizeof(unsigned char))) == NULL)
846: {
847: (*s_expression) = s_expression_courante;
848: (*s_etat_processus).erreur_systeme =
849: d_es_allocation_memoire;
850: return;
851: }
852:
853: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
854: .objet)).nom_fonction, "ROT");
855: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
856: .nombre_arguments = -1;
857: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
858: .fonction = instruction_rot;
859:
860: // Ajout de la variable de dérivation
861:
862: if (((*l_element_courant).suivant = malloc(
863: sizeof(struct_liste_chainee))) == NULL)
864: {
865: (*s_expression) = s_expression_courante;
866: (*s_etat_processus).erreur_systeme =
867: d_es_allocation_memoire;
868: return;
869: }
870:
871: l_element_courant = (*l_element_courant).suivant;
872:
873: if (((*l_element_courant).donnee = allocation(s_etat_processus,
874: NOM)) == NULL)
875: {
876: (*s_expression) = s_expression_courante;
877: (*s_etat_processus).erreur_systeme =
878: d_es_allocation_memoire;
879: return;
880: }
881:
882: if (((*((struct_nom *) (*(*l_element_courant).donnee)
883: .objet)).nom = malloc((strlen(variable) + 1)
884: * sizeof(unsigned char))) == NULL)
885: {
886: (*s_expression) = s_expression_courante;
887: (*s_etat_processus).erreur_systeme =
888: d_es_allocation_memoire;
889: return;
890: }
891:
892: strcpy((*((struct_nom *) (*(*l_element_courant).donnee)
893: .objet)).nom, variable);
894: (*((struct_nom *) (*(*l_element_courant).donnee).objet))
895: .symbole = d_vrai;
896:
897: // Ajout de la fonction DER
898:
899: if (((*l_element_courant).suivant = malloc(
900: sizeof(struct_liste_chainee))) == NULL)
901: {
902: (*s_expression) = s_expression_courante;
903: (*s_etat_processus).erreur_systeme =
904: d_es_allocation_memoire;
905: return;
906: }
907:
908: l_element_courant = (*l_element_courant).suivant;
909:
910: if (((*l_element_courant).donnee = allocation(s_etat_processus,
911: FCT)) == NULL)
912: {
913: (*s_expression) = s_expression_courante;
914: (*s_etat_processus).erreur_systeme =
915: d_es_allocation_memoire;
916: return;
917: }
918:
919: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
920: .objet)).nom_fonction = malloc(4 *
921: sizeof(unsigned char))) == NULL)
922: {
923: (*s_expression) = s_expression_courante;
924: (*s_etat_processus).erreur_systeme =
925: d_es_allocation_memoire;
926: return;
927: }
928:
929: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
930: .objet)).nom_fonction, "DER");
931: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
932: .nombre_arguments = 2;
933: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
934: .fonction = instruction_der;
935:
936: // Ajout de la fonction ROT
937:
938: if (((*l_element_courant).suivant = malloc(
939: sizeof(struct_liste_chainee))) == NULL)
940: {
941: (*s_expression) = s_expression_courante;
942: (*s_etat_processus).erreur_systeme =
943: d_es_allocation_memoire;
944: return;
945: }
946:
947: l_element_courant = (*l_element_courant).suivant;
948:
949: if (((*l_element_courant).donnee = allocation(s_etat_processus,
950: FCT)) == NULL)
951: {
952: (*s_expression) = s_expression_courante;
953: (*s_etat_processus).erreur_systeme =
954: d_es_allocation_memoire;
955: return;
956: }
957:
958: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
959: .objet)).nom_fonction = malloc(4 *
960: sizeof(unsigned char))) == NULL)
961: {
962: (*s_expression) = s_expression_courante;
963: (*s_etat_processus).erreur_systeme =
964: d_es_allocation_memoire;
965: return;
966: }
967:
968: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
969: .objet)).nom_fonction, "ROT");
970: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
971: .nombre_arguments = -1;
972: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
973: .fonction = instruction_rot;
974:
975: // Ajout de la fonction '*'
976:
977: if (((*l_element_courant).suivant = malloc(
978: sizeof(struct_liste_chainee))) == NULL)
979: {
980: (*s_expression) = s_expression_courante;
981: (*s_etat_processus).erreur_systeme =
982: d_es_allocation_memoire;
983: return;
984: }
985:
986: l_element_courant = (*l_element_courant).suivant;
987:
988: if (((*l_element_courant).donnee = allocation(s_etat_processus,
989: FCT)) == NULL)
990: {
991: (*s_expression) = s_expression_courante;
992: (*s_etat_processus).erreur_systeme =
993: d_es_allocation_memoire;
994: return;
995: }
996:
997: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
998: .objet)).nom_fonction = malloc(2 *
999: sizeof(unsigned char))) == NULL)
1000: {
1001: (*s_expression) = s_expression_courante;
1002: (*s_etat_processus).erreur_systeme =
1003: d_es_allocation_memoire;
1004: return;
1005: }
1006:
1007: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1008: .objet)).nom_fonction, "*");
1009: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1010: .nombre_arguments = 0;
1011: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1012: .fonction = instruction_multiplication;
1013:
1014: // Ajout de la fonction '+'
1015:
1016: (*l_element_courant).suivant = (*l_element_suivant).suivant;
1017:
1018: liberation(s_etat_processus, (*l_element_suivant).donnee);
1019: free(l_element_suivant);
1020:
1021: l_element_courant = (*l_element_courant).suivant;
1022:
1023: free((*((struct_fonction *) (*(*l_element_courant).donnee)
1024: .objet)).nom_fonction);
1025:
1026: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1027: .objet)).nom_fonction = malloc(2 *
1028: sizeof(unsigned char))) == NULL)
1029: {
1030: (*s_expression) = s_expression_courante;
1031: (*s_etat_processus).erreur_systeme =
1032: d_es_allocation_memoire;
1033: return;
1034: }
1035:
1036: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1037: .objet)).nom_fonction, "+");
1038: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1039: .nombre_arguments = 0;
1040: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1041: .fonction = instruction_plus;
1042: }
1043: else if (strcmp((*((struct_fonction *)
1044: (*(*l_element_courant).donnee)
1045: .objet)).nom_fonction, "/") == 0)
1046: {
1047: /*
1048: * Transormer << / X DER >> en
1049: * << DUP2 DUP SQ ROT ROT X DER * SWAP / ROT X DER ROT /
1050: * SWAP - >>
1051: */
1052:
1053: // Transformation du '/' en DUP2
1054:
1055: l_element_suivant = (*l_element_courant).suivant;
1056:
1057: free((*((struct_fonction *) (*(*l_element_courant).donnee)
1058: .objet)).nom_fonction);
1059:
1060: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1061: .objet)).nom_fonction = malloc(5 *
1062: sizeof(unsigned char))) == NULL)
1063: {
1064: (*s_expression) = s_expression_courante;
1065: (*s_etat_processus).erreur_systeme =
1066: d_es_allocation_memoire;
1067: return;
1068: }
1069:
1070: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1071: .objet)).nom_fonction, "DUP2");
1072: (*((struct_fonction *) (*(*l_element_courant).donnee)
1073: .objet)).nombre_arguments = -1;
1074: (*((struct_fonction *) (*(*l_element_courant).donnee)
1075: .objet)).fonction = instruction_dup2;
1076:
1077: // Ajout de la fonction DUP
1078:
1079: if (((*l_element_courant).suivant = malloc(
1080: sizeof(struct_liste_chainee))) == NULL)
1081: {
1082: (*s_expression) = s_expression_courante;
1083: (*s_etat_processus).erreur_systeme =
1084: d_es_allocation_memoire;
1085: return;
1086: }
1087:
1088: l_element_courant = (*l_element_courant).suivant;
1089:
1090: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1091: FCT)) == NULL)
1092: {
1093: (*s_expression) = s_expression_courante;
1094: (*s_etat_processus).erreur_systeme =
1095: d_es_allocation_memoire;
1096: return;
1097: }
1098:
1099: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1100: .objet)).nom_fonction = malloc(4 *
1101: sizeof(unsigned char))) == NULL)
1102: {
1103: (*s_expression) = s_expression_courante;
1104: (*s_etat_processus).erreur_systeme =
1105: d_es_allocation_memoire;
1106: return;
1107: }
1108:
1109: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1110: .objet)).nom_fonction, "DUP");
1111: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1112: .nombre_arguments = -1;
1113: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1114: .fonction = instruction_dup;
1115:
1116: // Ajout de la fonction SQ
1117:
1118: if (((*l_element_courant).suivant = malloc(
1119: sizeof(struct_liste_chainee))) == NULL)
1120: {
1121: (*s_expression) = s_expression_courante;
1122: (*s_etat_processus).erreur_systeme =
1123: d_es_allocation_memoire;
1124: return;
1125: }
1126:
1127: l_element_courant = (*l_element_courant).suivant;
1128:
1129: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1130: FCT)) == NULL)
1131: {
1132: (*s_expression) = s_expression_courante;
1133: (*s_etat_processus).erreur_systeme =
1134: d_es_allocation_memoire;
1135: return;
1136: }
1137:
1138: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1139: .objet)).nom_fonction = malloc(3 *
1140: sizeof(unsigned char))) == NULL)
1141: {
1142: (*s_expression) = s_expression_courante;
1143: (*s_etat_processus).erreur_systeme =
1144: d_es_allocation_memoire;
1145: return;
1146: }
1147:
1148: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1149: .objet)).nom_fonction, "SQ");
1150: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1151: .nombre_arguments = 1;
1152: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1153: .fonction = instruction_sq;
1154:
1155: // Ajout de la fonction ROT
1156:
1157: if (((*l_element_courant).suivant = malloc(
1158: sizeof(struct_liste_chainee))) == NULL)
1159: {
1160: (*s_expression) = s_expression_courante;
1161: (*s_etat_processus).erreur_systeme =
1162: d_es_allocation_memoire;
1163: return;
1164: }
1165:
1166: l_element_courant = (*l_element_courant).suivant;
1167:
1168: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1169: FCT)) == NULL)
1170: {
1171: (*s_expression) = s_expression_courante;
1172: (*s_etat_processus).erreur_systeme =
1173: d_es_allocation_memoire;
1174: return;
1175: }
1176:
1177: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1178: .objet)).nom_fonction = malloc(4 *
1179: sizeof(unsigned char))) == NULL)
1180: {
1181: (*s_expression) = s_expression_courante;
1182: (*s_etat_processus).erreur_systeme =
1183: d_es_allocation_memoire;
1184: return;
1185: }
1186:
1187: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1188: .objet)).nom_fonction, "ROT");
1189: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1190: .nombre_arguments = -1;
1191: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1192: .fonction = instruction_rot;
1193:
1194: // Ajout de la fonction ROT
1195:
1196: if (((*l_element_courant).suivant = malloc(
1197: sizeof(struct_liste_chainee))) == NULL)
1198: {
1199: (*s_expression) = s_expression_courante;
1200: (*s_etat_processus).erreur_systeme =
1201: d_es_allocation_memoire;
1202: return;
1203: }
1204:
1205: l_element_courant = (*l_element_courant).suivant;
1206:
1207: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1208: FCT)) == NULL)
1209: {
1210: (*s_expression) = s_expression_courante;
1211: (*s_etat_processus).erreur_systeme =
1212: d_es_allocation_memoire;
1213: return;
1214: }
1215:
1216: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1217: .objet)).nom_fonction = malloc(4 *
1218: sizeof(unsigned char))) == NULL)
1219: {
1220: (*s_expression) = s_expression_courante;
1221: (*s_etat_processus).erreur_systeme =
1222: d_es_allocation_memoire;
1223: return;
1224: }
1225:
1226: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1227: .objet)).nom_fonction, "ROT");
1228: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1229: .nombre_arguments = -1;
1230: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1231: .fonction = instruction_rot;
1232:
1233: // Ajout de la variable de dérivation
1234:
1235: if (((*l_element_courant).suivant = malloc(
1236: sizeof(struct_liste_chainee))) == NULL)
1237: {
1238: (*s_expression) = s_expression_courante;
1239: (*s_etat_processus).erreur_systeme =
1240: d_es_allocation_memoire;
1241: return;
1242: }
1243:
1244: l_element_courant = (*l_element_courant).suivant;
1245:
1246: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1247: NOM)) == NULL)
1248: {
1249: (*s_expression) = s_expression_courante;
1250: (*s_etat_processus).erreur_systeme =
1251: d_es_allocation_memoire;
1252: return;
1253: }
1254:
1255: if (((*((struct_nom *) (*(*l_element_courant).donnee)
1256: .objet)).nom = malloc((strlen(variable) + 1)
1257: * sizeof(unsigned char))) == NULL)
1258: {
1259: (*s_expression) = s_expression_courante;
1260: (*s_etat_processus).erreur_systeme =
1261: d_es_allocation_memoire;
1262: return;
1263: }
1264:
1265: strcpy((*((struct_nom *) (*(*l_element_courant).donnee)
1266: .objet)).nom, variable);
1267: (*((struct_nom *) (*(*l_element_courant).donnee).objet))
1268: .symbole = d_vrai;
1269:
1270: // Ajout de la fonction DER
1271:
1272: if (((*l_element_courant).suivant = malloc(
1273: sizeof(struct_liste_chainee))) == NULL)
1274: {
1275: (*s_expression) = s_expression_courante;
1276: (*s_etat_processus).erreur_systeme =
1277: d_es_allocation_memoire;
1278: return;
1279: }
1280:
1281: l_element_courant = (*l_element_courant).suivant;
1282:
1283: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1284: FCT)) == NULL)
1285: {
1286: (*s_expression) = s_expression_courante;
1287: (*s_etat_processus).erreur_systeme =
1288: d_es_allocation_memoire;
1289: return;
1290: }
1291:
1292: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1293: .objet)).nom_fonction = malloc(4 *
1294: sizeof(unsigned char))) == NULL)
1295: {
1296: (*s_expression) = s_expression_courante;
1297: (*s_etat_processus).erreur_systeme =
1298: d_es_allocation_memoire;
1299: return;
1300: }
1301:
1302: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1303: .objet)).nom_fonction, "DER");
1304: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1305: .nombre_arguments = 2;
1306: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1307: .fonction = instruction_der;
1308:
1309: // Ajout de la fonction '*'
1310:
1311: if (((*l_element_courant).suivant = malloc(
1312: sizeof(struct_liste_chainee))) == NULL)
1313: {
1314: (*s_expression) = s_expression_courante;
1315: (*s_etat_processus).erreur_systeme =
1316: d_es_allocation_memoire;
1317: return;
1318: }
1319:
1320: l_element_courant = (*l_element_courant).suivant;
1321:
1322: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1323: FCT)) == NULL)
1324: {
1325: (*s_expression) = s_expression_courante;
1326: (*s_etat_processus).erreur_systeme =
1327: d_es_allocation_memoire;
1328: return;
1329: }
1330:
1331: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1332: .objet)).nom_fonction = malloc(2 *
1333: sizeof(unsigned char))) == NULL)
1334: {
1335: (*s_expression) = s_expression_courante;
1336: (*s_etat_processus).erreur_systeme =
1337: d_es_allocation_memoire;
1338: return;
1339: }
1340:
1341: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1342: .objet)).nom_fonction, "*");
1343: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1344: .nombre_arguments = 0;
1345: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1346: .fonction = instruction_multiplication;
1347:
1348: // Ajout de la fonction SWAP
1349:
1350: if (((*l_element_courant).suivant = malloc(
1351: sizeof(struct_liste_chainee))) == NULL)
1352: {
1353: (*s_expression) = s_expression_courante;
1354: (*s_etat_processus).erreur_systeme =
1355: d_es_allocation_memoire;
1356: return;
1357: }
1358:
1359: l_element_courant = (*l_element_courant).suivant;
1360:
1361: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1362: FCT)) == NULL)
1363: {
1364: (*s_expression) = s_expression_courante;
1365: (*s_etat_processus).erreur_systeme =
1366: d_es_allocation_memoire;
1367: return;
1368: }
1369:
1370: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1371: .objet)).nom_fonction = malloc(5 *
1372: sizeof(unsigned char))) == NULL)
1373: {
1374: (*s_expression) = s_expression_courante;
1375: (*s_etat_processus).erreur_systeme =
1376: d_es_allocation_memoire;
1377: return;
1378: }
1379:
1380: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1381: .objet)).nom_fonction, "SWAP");
1382: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1383: .nombre_arguments = -1;
1384: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1385: .fonction = instruction_swap;
1386:
1387: // Ajout de la fonction '/'
1388:
1389: if (((*l_element_courant).suivant = malloc(
1390: sizeof(struct_liste_chainee))) == NULL)
1391: {
1392: (*s_expression) = s_expression_courante;
1393: (*s_etat_processus).erreur_systeme =
1394: d_es_allocation_memoire;
1395: return;
1396: }
1397:
1398: l_element_courant = (*l_element_courant).suivant;
1399:
1400: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1401: FCT)) == NULL)
1402: {
1403: (*s_expression) = s_expression_courante;
1404: (*s_etat_processus).erreur_systeme =
1405: d_es_allocation_memoire;
1406: return;
1407: }
1408:
1409: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1410: .objet)).nom_fonction = malloc(2 *
1411: sizeof(unsigned char))) == NULL)
1412: {
1413: (*s_expression) = s_expression_courante;
1414: (*s_etat_processus).erreur_systeme =
1415: d_es_allocation_memoire;
1416: return;
1417: }
1418:
1419: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1420: .objet)).nom_fonction, "/");
1421: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1422: .nombre_arguments = 0;
1423: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1424: .fonction = instruction_division;
1425:
1426: // Ajout de la fonction ROT
1427:
1428: if (((*l_element_courant).suivant = malloc(
1429: sizeof(struct_liste_chainee))) == NULL)
1430: {
1431: (*s_expression) = s_expression_courante;
1432: (*s_etat_processus).erreur_systeme =
1433: d_es_allocation_memoire;
1434: return;
1435: }
1436:
1437: l_element_courant = (*l_element_courant).suivant;
1438:
1439: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1440: FCT)) == NULL)
1441: {
1442: (*s_expression) = s_expression_courante;
1443: (*s_etat_processus).erreur_systeme =
1444: d_es_allocation_memoire;
1445: return;
1446: }
1447:
1448: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1449: .objet)).nom_fonction = malloc(4 *
1450: sizeof(unsigned char))) == NULL)
1451: {
1452: (*s_expression) = s_expression_courante;
1453: (*s_etat_processus).erreur_systeme =
1454: d_es_allocation_memoire;
1455: return;
1456: }
1457:
1458: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1459: .objet)).nom_fonction, "ROT");
1460: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1461: .nombre_arguments = -1;
1462: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1463: .fonction = instruction_rot;
1464:
1465: // Ajout de la variable de dérivation
1466:
1467: if (((*l_element_courant).suivant = malloc(
1468: sizeof(struct_liste_chainee))) == NULL)
1469: {
1470: (*s_expression) = s_expression_courante;
1471: (*s_etat_processus).erreur_systeme =
1472: d_es_allocation_memoire;
1473: return;
1474: }
1475:
1476: l_element_courant = (*l_element_courant).suivant;
1477:
1478: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1479: NOM)) == NULL)
1480: {
1481: (*s_expression) = s_expression_courante;
1482: (*s_etat_processus).erreur_systeme =
1483: d_es_allocation_memoire;
1484: return;
1485: }
1486:
1487: if (((*((struct_nom *) (*(*l_element_courant).donnee)
1488: .objet)).nom = malloc((strlen(variable) + 1)
1489: * sizeof(unsigned char))) == NULL)
1490: {
1491: (*s_expression) = s_expression_courante;
1492: (*s_etat_processus).erreur_systeme =
1493: d_es_allocation_memoire;
1494: return;
1495: }
1496:
1497: strcpy((*((struct_nom *) (*(*l_element_courant).donnee)
1498: .objet)).nom, variable);
1499: (*((struct_nom *) (*(*l_element_courant).donnee).objet))
1500: .symbole = d_vrai;
1501:
1502: // Ajout de la fonction DER
1503:
1504: if (((*l_element_courant).suivant = malloc(
1505: sizeof(struct_liste_chainee))) == NULL)
1506: {
1507: (*s_expression) = s_expression_courante;
1508: (*s_etat_processus).erreur_systeme =
1509: d_es_allocation_memoire;
1510: return;
1511: }
1512:
1513: l_element_courant = (*l_element_courant).suivant;
1514:
1515: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1516: FCT)) == NULL)
1517: {
1518: (*s_expression) = s_expression_courante;
1519: (*s_etat_processus).erreur_systeme =
1520: d_es_allocation_memoire;
1521: return;
1522: }
1523:
1524: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1525: .objet)).nom_fonction = malloc(4 *
1526: sizeof(unsigned char))) == NULL)
1527: {
1528: (*s_expression) = s_expression_courante;
1529: (*s_etat_processus).erreur_systeme =
1530: d_es_allocation_memoire;
1531: return;
1532: }
1533:
1534: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1535: .objet)).nom_fonction, "DER");
1536: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1537: .nombre_arguments = 2;
1538: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1539: .fonction = instruction_der;
1540:
1541: // Ajout de la fonction ROT
1542:
1543: if (((*l_element_courant).suivant = malloc(
1544: sizeof(struct_liste_chainee))) == NULL)
1545: {
1546: (*s_expression) = s_expression_courante;
1547: (*s_etat_processus).erreur_systeme =
1548: d_es_allocation_memoire;
1549: return;
1550: }
1551:
1552: l_element_courant = (*l_element_courant).suivant;
1553:
1554: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1555: FCT)) == NULL)
1556: {
1557: (*s_expression) = s_expression_courante;
1558: (*s_etat_processus).erreur_systeme =
1559: d_es_allocation_memoire;
1560: return;
1561: }
1562:
1563: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1564: .objet)).nom_fonction = malloc(4 *
1565: sizeof(unsigned char))) == NULL)
1566: {
1567: (*s_expression) = s_expression_courante;
1568: (*s_etat_processus).erreur_systeme =
1569: d_es_allocation_memoire;
1570: return;
1571: }
1572:
1573: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1574: .objet)).nom_fonction, "ROT");
1575: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1576: .nombre_arguments = -1;
1577: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1578: .fonction = instruction_rot;
1579:
1580: // Ajout de la fonction '/'
1581:
1582: if (((*l_element_courant).suivant = malloc(
1583: sizeof(struct_liste_chainee))) == NULL)
1584: {
1585: (*s_expression) = s_expression_courante;
1586: (*s_etat_processus).erreur_systeme =
1587: d_es_allocation_memoire;
1588: return;
1589: }
1590:
1591: l_element_courant = (*l_element_courant).suivant;
1592:
1593: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1594: FCT)) == NULL)
1595: {
1596: (*s_expression) = s_expression_courante;
1597: (*s_etat_processus).erreur_systeme =
1598: d_es_allocation_memoire;
1599: return;
1600: }
1601:
1602: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1603: .objet)).nom_fonction = malloc(2 *
1604: sizeof(unsigned char))) == NULL)
1605: {
1606: (*s_expression) = s_expression_courante;
1607: (*s_etat_processus).erreur_systeme =
1608: d_es_allocation_memoire;
1609: return;
1610: }
1611:
1612: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1613: .objet)).nom_fonction, "/");
1614: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1615: .nombre_arguments = 0;
1616: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1617: .fonction = instruction_division;
1618:
1619: // Ajout de la fonction SWAP
1620:
1621: if (((*l_element_courant).suivant = malloc(
1622: sizeof(struct_liste_chainee))) == NULL)
1623: {
1624: (*s_expression) = s_expression_courante;
1625: (*s_etat_processus).erreur_systeme =
1626: d_es_allocation_memoire;
1627: return;
1628: }
1629:
1630: l_element_courant = (*l_element_courant).suivant;
1631:
1632: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1633: FCT)) == NULL)
1634: {
1635: (*s_expression) = s_expression_courante;
1636: (*s_etat_processus).erreur_systeme =
1637: d_es_allocation_memoire;
1638: return;
1639: }
1640:
1641: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1642: .objet)).nom_fonction = malloc(5 *
1643: sizeof(unsigned char))) == NULL)
1644: {
1645: (*s_expression) = s_expression_courante;
1646: (*s_etat_processus).erreur_systeme =
1647: d_es_allocation_memoire;
1648: return;
1649: }
1650:
1651: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1652: .objet)).nom_fonction, "SWAP");
1653: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1654: .nombre_arguments = -1;
1655: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1656: .fonction = instruction_swap;
1657:
1658: // Ajout de la fonction '-'
1659:
1660: (*l_element_courant).suivant = (*l_element_suivant).suivant;
1661:
1662: liberation(s_etat_processus, (*l_element_suivant).donnee);
1663: free(l_element_suivant);
1664:
1665: l_element_courant = (*l_element_courant).suivant;
1666:
1667: free((*((struct_fonction *) (*(*l_element_courant).donnee)
1668: .objet)).nom_fonction);
1669:
1670: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1671: .objet)).nom_fonction = malloc(2 *
1672: sizeof(unsigned char))) == NULL)
1673: {
1674: (*s_expression) = s_expression_courante;
1675: (*s_etat_processus).erreur_systeme =
1676: d_es_allocation_memoire;
1677: return;
1678: }
1679:
1680: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1681: .objet)).nom_fonction, "-");
1682: (*((struct_fonction *) (*(*l_element_courant).donnee)
1683: .objet)).nombre_arguments = 0;
1684: (*((struct_fonction *) (*(*l_element_courant).donnee)
1685: .objet)).fonction = instruction_moins;
1686: }
1687: else if ((strcmp((*((struct_fonction *)
1688: (*(*l_element_courant).donnee)
1689: .objet)).nom_fonction, "^") == 0) ||
1690: (strcmp((*((struct_fonction *) (*(*l_element_courant)
1691: .donnee).objet)).nom_fonction , "**") == 0))
1692: {
1693: /*
1694: * Transormer << ** X DER >> en
1695: * << OVER X DER ROT ROT DUP 1 - ROT SWAP ** * * >>
1696: */
1697:
1698: // Transformation du '**' en OVER
1699:
1700: l_element_suivant = (*l_element_courant).suivant;
1701:
1702: free((*((struct_fonction *) (*(*l_element_courant).donnee)
1703: .objet)).nom_fonction);
1704:
1705: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1706: .objet)).nom_fonction = malloc(5 *
1707: sizeof(unsigned char))) == NULL)
1708: {
1709: (*s_expression) = s_expression_courante;
1710: (*s_etat_processus).erreur_systeme =
1711: d_es_allocation_memoire;
1712: return;
1713: }
1714:
1715: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1716: .objet)).nom_fonction, "OVER");
1717: (*((struct_fonction *) (*(*l_element_courant).donnee)
1718: .objet)).nombre_arguments = -1;
1719: (*((struct_fonction *) (*(*l_element_courant).donnee)
1720: .objet)).fonction = instruction_over;
1721:
1722: // Ajout de la variable de dérivation
1723:
1724: if (((*l_element_courant).suivant = malloc(
1725: sizeof(struct_liste_chainee))) == NULL)
1726: {
1727: (*s_expression) = s_expression_courante;
1728: (*s_etat_processus).erreur_systeme =
1729: d_es_allocation_memoire;
1730: return;
1731: }
1732:
1733: l_element_courant = (*l_element_courant).suivant;
1734:
1735: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1736: NOM)) == NULL)
1737: {
1738: (*s_expression) = s_expression_courante;
1739: (*s_etat_processus).erreur_systeme =
1740: d_es_allocation_memoire;
1741: return;
1742: }
1743:
1744: if (((*((struct_nom *) (*(*l_element_courant).donnee)
1745: .objet)).nom = malloc((strlen(variable) + 1)
1746: * sizeof(unsigned char))) == NULL)
1747: {
1748: (*s_expression) = s_expression_courante;
1749: (*s_etat_processus).erreur_systeme =
1750: d_es_allocation_memoire;
1751: return;
1752: }
1753:
1754: strcpy((*((struct_nom *) (*(*l_element_courant).donnee)
1755: .objet)).nom, variable);
1756: (*((struct_nom *) (*(*l_element_courant).donnee).objet))
1757: .symbole = d_vrai;
1758:
1759: // Ajout de la fonction DER
1760:
1761: if (((*l_element_courant).suivant = malloc(
1762: sizeof(struct_liste_chainee))) == NULL)
1763: {
1764: (*s_expression) = s_expression_courante;
1765: (*s_etat_processus).erreur_systeme =
1766: d_es_allocation_memoire;
1767: return;
1768: }
1769:
1770: l_element_courant = (*l_element_courant).suivant;
1771:
1772: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1773: FCT)) == NULL)
1774: {
1775: (*s_expression) = s_expression_courante;
1776: (*s_etat_processus).erreur_systeme =
1777: d_es_allocation_memoire;
1778: return;
1779: }
1780:
1781: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1782: .objet)).nom_fonction = malloc(4 *
1783: sizeof(unsigned char))) == NULL)
1784: {
1785: (*s_expression) = s_expression_courante;
1786: (*s_etat_processus).erreur_systeme =
1787: d_es_allocation_memoire;
1788: return;
1789: }
1790:
1791: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1792: .objet)).nom_fonction, "DER");
1793: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1794: .nombre_arguments = 2;
1795: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1796: .fonction = instruction_der;
1797:
1798: // Ajout de la fonction ROT
1799:
1800: if (((*l_element_courant).suivant = malloc(
1801: sizeof(struct_liste_chainee))) == NULL)
1802: {
1803: (*s_expression) = s_expression_courante;
1804: (*s_etat_processus).erreur_systeme =
1805: d_es_allocation_memoire;
1806: return;
1807: }
1808:
1809: l_element_courant = (*l_element_courant).suivant;
1810:
1811: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1812: FCT)) == NULL)
1813: {
1814: (*s_expression) = s_expression_courante;
1815: (*s_etat_processus).erreur_systeme =
1816: d_es_allocation_memoire;
1817: return;
1818: }
1819:
1820: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1821: .objet)).nom_fonction = malloc(4 *
1822: sizeof(unsigned char))) == NULL)
1823: {
1824: (*s_expression) = s_expression_courante;
1825: (*s_etat_processus).erreur_systeme =
1826: d_es_allocation_memoire;
1827: return;
1828: }
1829:
1830: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1831: .objet)).nom_fonction, "ROT");
1832: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1833: .nombre_arguments = -1;
1834: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1835: .fonction = instruction_rot;
1836:
1837: // Ajout de la fonction ROT
1838:
1839: if (((*l_element_courant).suivant = malloc(
1840: sizeof(struct_liste_chainee))) == NULL)
1841: {
1842: (*s_expression) = s_expression_courante;
1843: (*s_etat_processus).erreur_systeme =
1844: d_es_allocation_memoire;
1845: return;
1846: }
1847:
1848: l_element_courant = (*l_element_courant).suivant;
1849:
1850: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1851: FCT)) == NULL)
1852: {
1853: (*s_expression) = s_expression_courante;
1854: (*s_etat_processus).erreur_systeme =
1855: d_es_allocation_memoire;
1856: return;
1857: }
1858:
1859: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1860: .objet)).nom_fonction = malloc(4 *
1861: sizeof(unsigned char))) == NULL)
1862: {
1863: (*s_expression) = s_expression_courante;
1864: (*s_etat_processus).erreur_systeme =
1865: d_es_allocation_memoire;
1866: return;
1867: }
1868:
1869: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1870: .objet)).nom_fonction, "ROT");
1871: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1872: .nombre_arguments = -1;
1873: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1874: .fonction = instruction_rot;
1875:
1876: // Ajout de la fonction DUP
1877:
1878: if (((*l_element_courant).suivant = malloc(
1879: sizeof(struct_liste_chainee))) == NULL)
1880: {
1881: (*s_expression) = s_expression_courante;
1882: (*s_etat_processus).erreur_systeme =
1883: d_es_allocation_memoire;
1884: return;
1885: }
1886:
1887: l_element_courant = (*l_element_courant).suivant;
1888:
1889: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1890: FCT)) == NULL)
1891: {
1892: (*s_expression) = s_expression_courante;
1893: (*s_etat_processus).erreur_systeme =
1894: d_es_allocation_memoire;
1895: return;
1896: }
1897:
1898: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1899: .objet)).nom_fonction = malloc(4 *
1900: sizeof(unsigned char))) == NULL)
1901: {
1902: (*s_expression) = s_expression_courante;
1903: (*s_etat_processus).erreur_systeme =
1904: d_es_allocation_memoire;
1905: return;
1906: }
1907:
1908: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1909: .objet)).nom_fonction, "DUP");
1910: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1911: .nombre_arguments = -1;
1912: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1913: .fonction = instruction_dup;
1914:
1915: // Ajout de 1 sur la pile
1916:
1917: if (((*l_element_courant).suivant = malloc(
1918: sizeof(struct_liste_chainee))) == NULL)
1919: {
1920: (*s_expression) = s_expression_courante;
1921: (*s_etat_processus).erreur_systeme =
1922: d_es_allocation_memoire;
1923: return;
1924: }
1925:
1926: l_element_courant = (*l_element_courant).suivant;
1927:
1928: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1929: INT)) == NULL)
1930: {
1931: (*s_expression) = s_expression_courante;
1932: (*s_etat_processus).erreur_systeme =
1933: d_es_allocation_memoire;
1934: return;
1935: }
1936:
1937: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = 1;
1938:
1939: // Ajout de la fonction '-'
1940:
1941: if (((*l_element_courant).suivant = malloc(
1942: sizeof(struct_liste_chainee))) == NULL)
1943: {
1944: (*s_expression) = s_expression_courante;
1945: (*s_etat_processus).erreur_systeme =
1946: d_es_allocation_memoire;
1947: return;
1948: }
1949:
1950: l_element_courant = (*l_element_courant).suivant;
1951:
1952: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1953: FCT)) == NULL)
1954: {
1955: (*s_expression) = s_expression_courante;
1956: (*s_etat_processus).erreur_systeme =
1957: d_es_allocation_memoire;
1958: return;
1959: }
1960:
1961: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1962: .objet)).nom_fonction = malloc(2 *
1963: sizeof(unsigned char))) == NULL)
1964: {
1965: (*s_expression) = s_expression_courante;
1966: (*s_etat_processus).erreur_systeme =
1967: d_es_allocation_memoire;
1968: return;
1969: }
1970:
1971: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1972: .objet)).nom_fonction, "-");
1973: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1974: .nombre_arguments = 0;
1975: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1976: .fonction = instruction_moins;
1977:
1978: // Ajout de la fonction ROT
1979:
1980: if (((*l_element_courant).suivant = malloc(
1981: sizeof(struct_liste_chainee))) == NULL)
1982: {
1983: (*s_expression) = s_expression_courante;
1984: (*s_etat_processus).erreur_systeme =
1985: d_es_allocation_memoire;
1986: return;
1987: }
1988:
1989: l_element_courant = (*l_element_courant).suivant;
1990:
1991: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1992: FCT)) == NULL)
1993: {
1994: (*s_expression) = s_expression_courante;
1995: (*s_etat_processus).erreur_systeme =
1996: d_es_allocation_memoire;
1997: return;
1998: }
1999:
2000: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
2001: .objet)).nom_fonction = malloc(4 *
2002: sizeof(unsigned char))) == NULL)
2003: {
2004: (*s_expression) = s_expression_courante;
2005: (*s_etat_processus).erreur_systeme =
2006: d_es_allocation_memoire;
2007: return;
2008: }
2009:
2010: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
2011: .objet)).nom_fonction, "ROT");
2012: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2013: .nombre_arguments = -1;
2014: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2015: .fonction = instruction_rot;
2016:
2017: // Ajout de la fonction SWAP
2018:
2019: if (((*l_element_courant).suivant = malloc(
2020: sizeof(struct_liste_chainee))) == NULL)
2021: {
2022: (*s_expression) = s_expression_courante;
2023: (*s_etat_processus).erreur_systeme =
2024: d_es_allocation_memoire;
2025: return;
2026: }
2027:
2028: l_element_courant = (*l_element_courant).suivant;
2029:
2030: if (((*l_element_courant).donnee = allocation(s_etat_processus,
2031: FCT)) == NULL)
2032: {
2033: (*s_expression) = s_expression_courante;
2034: (*s_etat_processus).erreur_systeme =
2035: d_es_allocation_memoire;
2036: return;
2037: }
2038:
2039: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
2040: .objet)).nom_fonction = malloc(5 *
2041: sizeof(unsigned char))) == NULL)
2042: {
2043: (*s_expression) = s_expression_courante;
2044: (*s_etat_processus).erreur_systeme =
2045: d_es_allocation_memoire;
2046: return;
2047: }
2048:
2049: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
2050: .objet)).nom_fonction, "SWAP");
2051: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2052: .nombre_arguments = -1;
2053: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2054: .fonction = instruction_swap;
2055:
2056: // Ajout de la fonction '**'
2057:
2058: if (((*l_element_courant).suivant = malloc(
2059: sizeof(struct_liste_chainee))) == NULL)
2060: {
2061: (*s_expression) = s_expression_courante;
2062: (*s_etat_processus).erreur_systeme =
2063: d_es_allocation_memoire;
2064: return;
2065: }
2066:
2067: l_element_courant = (*l_element_courant).suivant;
2068:
2069: if (((*l_element_courant).donnee = allocation(s_etat_processus,
2070: FCT)) == NULL)
2071: {
2072: (*s_expression) = s_expression_courante;
2073: (*s_etat_processus).erreur_systeme =
2074: d_es_allocation_memoire;
2075: return;
2076: }
2077:
2078: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
2079: .objet)).nom_fonction = malloc(3 *
2080: sizeof(unsigned char))) == NULL)
2081: {
2082: (*s_expression) = s_expression_courante;
2083: (*s_etat_processus).erreur_systeme =
2084: d_es_allocation_memoire;
2085: return;
2086: }
2087:
2088: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
2089: .objet)).nom_fonction, "**");
2090: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2091: .nombre_arguments = 0;
2092: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2093: .fonction = instruction_puissance;
2094:
2095: // Ajout de la fonction '*'
2096:
2097: if (((*l_element_courant).suivant = malloc(
2098: sizeof(struct_liste_chainee))) == NULL)
2099: {
2100: (*s_expression) = s_expression_courante;
2101: (*s_etat_processus).erreur_systeme =
2102: d_es_allocation_memoire;
2103: return;
2104: }
2105:
2106: l_element_courant = (*l_element_courant).suivant;
2107:
2108: if (((*l_element_courant).donnee = allocation(s_etat_processus,
2109: FCT)) == NULL)
2110: {
2111: (*s_expression) = s_expression_courante;
2112: (*s_etat_processus).erreur_systeme =
2113: d_es_allocation_memoire;
2114: return;
2115: }
2116:
2117: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
2118: .objet)).nom_fonction = malloc(2 *
2119: sizeof(unsigned char))) == NULL)
2120: {
2121: (*s_expression) = s_expression_courante;
2122: (*s_etat_processus).erreur_systeme =
2123: d_es_allocation_memoire;
2124: return;
2125: }
2126:
2127: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
2128: .objet)).nom_fonction, "*");
2129: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2130: .nombre_arguments = 0;
2131: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2132: .fonction = instruction_multiplication;
2133:
2134: // Ajout de la fonction '*'
2135:
2136: (*l_element_courant).suivant = (*l_element_suivant).suivant;
2137:
2138: liberation(s_etat_processus, (*l_element_suivant).donnee);
2139: free(l_element_suivant);
2140:
2141: l_element_courant = (*l_element_courant).suivant;
2142:
2143: free((*((struct_fonction *) (*(*l_element_courant).donnee)
2144: .objet)).nom_fonction);
2145:
2146: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
2147: .objet)).nom_fonction = malloc(2 *
2148: sizeof(unsigned char))) == NULL)
2149: {
2150: (*s_expression) = s_expression_courante;
2151: (*s_etat_processus).erreur_systeme =
2152: d_es_allocation_memoire;
2153: return;
2154: }
2155:
2156: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
2157: .objet)).nom_fonction, "*");
2158: (*((struct_fonction *) (*(*l_element_courant).donnee)
2159: .objet)).nombre_arguments = 0;
2160: (*((struct_fonction *) (*(*l_element_courant).donnee)
2161: .objet)).fonction = instruction_multiplication;
2162: }
2163:
2164: /*
2165: * Traitement des fonctions
2166: */
2167:
2168: else
2169: {
2170: derivee_fonction_disponible = d_faux;
2171:
2172: tampon = (*((struct_fonction *) (*(*l_element_courant)
2173: .donnee).objet)).nom_fonction;
2174:
2175: derivee_fonction_disponible = d_faux;
2176: fin_boucle = d_faux;
2177:
2178: i = 0;
2179:
2180: do
2181: {
2182: if (fonctions[i] == NULL)
2183: {
2184: /*
2185: * On saute les expressions dérivées, donc
2186: * on cherche le prochain NULL.
2187: */
2188:
2189: while(fonctions[++i] != NULL);
2190:
2191: if (fonctions[++i] == NULL)
2192: {
2193: fin_boucle = d_vrai;
2194: }
2195: }
2196: else if (strcmp(fonctions[i], tampon) == 0)
2197: {
2198: /*
2199: * Vérification du nombre d'arguments de la fonction
2200: */
2201:
2202: if ((*((struct_fonction *) (*(*l_element_courant)
2203: .donnee).objet)).nombre_arguments ==
1.41 bertrand 2204: atol(fonctions[i + 1]))
1.1 bertrand 2205: {
2206: i += 2;
2207: derivee_fonction_disponible = d_vrai;
2208: fin_boucle = d_vrai;
2209:
2210: while(fonctions[i] != NULL)
2211: {
2212: i++;
2213: }
2214: }
2215: }
2216: else
2217: {
2218: /*
2219: * Saut de la fonction et du nombre d'arguments
2220: */
2221:
2222: i += 2;
2223: }
2224: } while(fin_boucle == d_faux);
2225:
2226: if (derivee_fonction_disponible == d_faux)
2227: {
2228: /*
2229: * Remplacement de 'fct' X DER par
2230: * 'Derfct(arg, X)'
2231: */
2232:
2233: tampon = (*((struct_fonction *) (*(*l_element_courant)
2234: .donnee).objet)).nom_fonction;
2235:
2236: // Transformation du nom de la fonction
2237: // en variable de dérivation
2238:
2239: l_element_suivant = (*l_element_courant).suivant;
2240:
2241: free((*(*l_element_courant).donnee).objet);
2242:
2243: (*(*l_element_courant).donnee).type = NOM;
2244:
2245: if (((*(*l_element_courant).donnee).objet = malloc(
2246: sizeof(struct_nom))) == NULL)
2247: {
2248: (*s_expression) = s_expression_courante;
2249: (*s_etat_processus).erreur_systeme =
2250: d_es_allocation_memoire;
2251: return;
2252: }
2253:
2254: if (((*((struct_nom *) (*(*l_element_courant).donnee)
2255: .objet)).nom = malloc((strlen(variable) + 1)
2256: * sizeof(unsigned char))) == NULL)
2257: {
2258: (*s_expression) = s_expression_courante;
2259: (*s_etat_processus).erreur_systeme =
2260: d_es_allocation_memoire;
2261: return;
2262: }
2263:
2264: strcpy((*((struct_nom *) (*(*l_element_courant).donnee)
2265: .objet)).nom, variable);
2266: (*((struct_nom *) (*(*l_element_courant).donnee).objet))
2267: .symbole = d_vrai;
2268:
2269: (*l_element_courant).suivant =
2270: (*l_element_suivant).suivant;
2271:
2272: liberation(s_etat_processus, (*l_element_suivant).donnee);
2273: free(l_element_suivant);
2274:
2275: l_element_courant = (*l_element_courant).suivant;
2276:
2277: free((*((struct_fonction *) (*(*l_element_courant).donnee)
2278: .objet)).nom_fonction);
2279:
2280: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
2281: .objet)).nom_fonction = malloc((strlen(tampon) + 4)
2282: * sizeof(unsigned char))) == NULL)
2283: {
2284: (*s_expression) = s_expression_courante;
2285: (*s_etat_processus).erreur_systeme =
2286: d_es_allocation_memoire;
2287: return;
2288: }
2289:
2290: strcat(strcpy((*((struct_fonction *) (*(*l_element_courant)
2291: .donnee).objet)).nom_fonction, "Der"), tampon);
2292:
2293: if ((*((struct_fonction *) (*(*l_element_courant).donnee)
2294: .objet)).nombre_arguments == 0)
2295: {
2296: (*((struct_fonction *) (*(*l_element_courant).donnee)
2297: .objet)).nombre_arguments = 3;
2298: }
2299: else
2300: {
2301: (*((struct_fonction *) (*(*l_element_courant).donnee)
2302: .objet)).nombre_arguments += 1;
2303: }
2304:
2305: free(tampon);
2306: }
2307: else
2308: {
2309: /*
2310: * Transormer << FCT X DER >> en
2311: * << DUP X DER SWAP DerFCT * >>
2312: */
2313:
2314: // Transformation de la fonction à dériver en DUP
2315:
2316: l_element_suivant = (*l_element_courant).suivant;
2317:
2318: free((*((struct_fonction *) (*(*l_element_courant).donnee)
2319: .objet)).nom_fonction);
2320:
2321: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
2322: .objet)).nom_fonction = malloc(4 *
2323: sizeof(unsigned char))) == NULL)
2324: {
2325: (*s_expression) = s_expression_courante;
2326: (*s_etat_processus).erreur_systeme =
2327: d_es_allocation_memoire;
2328: return;
2329: }
2330:
2331: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
2332: .objet)).nom_fonction, "DUP");
2333: (*((struct_fonction *) (*(*l_element_courant).donnee)
2334: .objet)).nombre_arguments = -1;
2335: (*((struct_fonction *) (*(*l_element_courant).donnee)
2336: .objet)).fonction = instruction_dup;
2337:
2338: // Ajout de la variable de dérivation
2339:
2340: if (((*l_element_courant).suivant = malloc(
2341: sizeof(struct_liste_chainee))) == NULL)
2342: {
2343: (*s_expression) = s_expression_courante;
2344: (*s_etat_processus).erreur_systeme =
2345: d_es_allocation_memoire;
2346: return;
2347: }
2348:
2349: l_element_courant = (*l_element_courant).suivant;
2350:
2351: if (((*l_element_courant).donnee =
2352: allocation(s_etat_processus, NOM)) == NULL)
2353: {
2354: (*s_expression) = s_expression_courante;
2355: (*s_etat_processus).erreur_systeme =
2356: d_es_allocation_memoire;
2357: return;
2358: }
2359:
2360: if (((*((struct_nom *) (*(*l_element_courant).donnee)
2361: .objet)).nom = malloc((strlen(variable) + 1)
2362: * sizeof(unsigned char))) == NULL)
2363: {
2364: (*s_expression) = s_expression_courante;
2365: (*s_etat_processus).erreur_systeme =
2366: d_es_allocation_memoire;
2367: return;
2368: }
2369:
2370: strcpy((*((struct_nom *) (*(*l_element_courant).donnee)
2371: .objet)).nom, variable);
2372: (*((struct_nom *) (*(*l_element_courant).donnee).objet))
2373: .symbole = d_vrai;
2374:
2375: // Ajout de la fonction DER
2376:
2377: if (((*l_element_courant).suivant = malloc(
2378: sizeof(struct_liste_chainee))) == NULL)
2379: {
2380: (*s_expression) = s_expression_courante;
2381: (*s_etat_processus).erreur_systeme =
2382: d_es_allocation_memoire;
2383: return;
2384: }
2385:
2386: l_element_courant = (*l_element_courant).suivant;
2387:
2388: if (((*l_element_courant).donnee =
2389: allocation(s_etat_processus, FCT)) == NULL)
2390: {
2391: (*s_expression) = s_expression_courante;
2392: (*s_etat_processus).erreur_systeme =
2393: d_es_allocation_memoire;
2394: return;
2395: }
2396:
2397: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
2398: .objet)).nom_fonction = malloc(4 *
2399: sizeof(unsigned char))) == NULL)
2400: {
2401: (*s_expression) = s_expression_courante;
2402: (*s_etat_processus).erreur_systeme =
2403: d_es_allocation_memoire;
2404: return;
2405: }
2406:
2407: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
2408: .objet)).nom_fonction, "DER");
2409: (*((struct_fonction *) (*(*l_element_courant).donnee)
2410: .objet)).nombre_arguments = 2;
2411: (*((struct_fonction *) (*(*l_element_courant).donnee)
2412: .objet)).fonction = instruction_der;
2413:
2414: // Ajout de la fonction SWAP
2415:
2416: if (((*l_element_courant).suivant = malloc(
2417: sizeof(struct_liste_chainee))) == NULL)
2418: {
2419: (*s_expression) = s_expression_courante;
2420: (*s_etat_processus).erreur_systeme =
2421: d_es_allocation_memoire;
2422: return;
2423: }
2424:
2425: l_element_courant = (*l_element_courant).suivant;
2426:
2427: if (((*l_element_courant).donnee =
2428: allocation(s_etat_processus, FCT)) == NULL)
2429: {
2430: (*s_expression) = s_expression_courante;
2431: (*s_etat_processus).erreur_systeme =
2432: d_es_allocation_memoire;
2433: return;
2434: }
2435:
2436: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
2437: .objet)).nom_fonction = malloc(5 *
2438: sizeof(unsigned char))) == NULL)
2439: {
2440: (*s_expression) = s_expression_courante;
2441: (*s_etat_processus).erreur_systeme =
2442: d_es_allocation_memoire;
2443: return;
2444: }
2445:
2446: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
2447: .objet)).nom_fonction, "SWAP");
2448: (*((struct_fonction *) (*(*l_element_courant).donnee)
2449: .objet)).nombre_arguments = -1;
2450: (*((struct_fonction *) (*(*l_element_courant).donnee)
2451: .objet)).fonction = instruction_swap;
2452:
2453: // Ajout de la fonction dérivée
2454:
2455: i++;
2456:
2457: do
2458: {
2459: if (((*l_element_courant).suivant = malloc(
2460: sizeof(struct_liste_chainee))) == NULL)
2461: {
2462: (*s_expression) = s_expression_courante;
2463: (*s_etat_processus).erreur_systeme =
2464: d_es_allocation_memoire;
2465: return;
2466: }
2467:
2468: l_element_courant = (*l_element_courant).suivant;
2469:
2470: if (strcmp(fonctions[i], "FCT") == 0)
2471: {
2472: if (((*l_element_courant).donnee = allocation(
2473: s_etat_processus, FCT)) == NULL)
2474: {
2475: (*s_expression) = s_expression_courante;
2476: (*s_etat_processus).erreur_systeme =
2477: d_es_allocation_memoire;
2478: return;
2479: }
2480:
2481: if (((*((struct_fonction *) (*(*l_element_courant)
2482: .donnee).objet)).nom_fonction = malloc(
2483: (strlen(fonctions[i + 1]) + 1) *
2484: sizeof(unsigned char))) == NULL)
2485: {
2486: (*s_expression) = s_expression_courante;
2487: (*s_etat_processus).erreur_systeme =
2488: d_es_allocation_memoire;
2489: return;
2490: }
2491:
2492: strcpy((*((struct_fonction *) (*(*l_element_courant)
2493: .donnee).objet)).nom_fonction,
2494: fonctions[i + 1]);
2495: (*((struct_fonction *) (*(*l_element_courant)
2496: .donnee).objet)).nombre_arguments =
2497: atoi(fonctions[i + 2]);
2498: (*((struct_fonction *) (*(*l_element_courant)
2499: .donnee).objet)).fonction =
2500: analyse_instruction(s_etat_processus,
2501: fonctions[i + 1]);
2502: }
2503: else if (strcmp(fonctions[i], "INT") == 0)
2504: {
2505: if (((*l_element_courant).donnee = allocation(
2506: s_etat_processus, INT)) == NULL)
2507: {
2508: (*s_expression) = s_expression_courante;
2509: (*s_etat_processus).erreur_systeme =
2510: d_es_allocation_memoire;
2511: return;
2512: }
2513:
2514: (*((integer8 *) (*(*l_element_courant)
2515: .donnee).objet)) = atoi(fonctions[i + 1]);
2516: }
2517: else if (strcmp(fonctions[i], "NOM") == 0)
2518: {
2519: if (((*l_element_courant).donnee = allocation(
2520: s_etat_processus, NOM)) == NULL)
2521: {
2522: (*s_expression) = s_expression_courante;
2523: (*s_etat_processus).erreur_systeme =
2524: d_es_allocation_memoire;
2525: return;
2526: }
2527:
2528: if (((*((struct_nom *) (*(*l_element_courant)
2529: .donnee).objet)).nom = malloc(
2530: strlen((fonctions[i + 1]) + 1) *
2531: sizeof(unsigned char))) == NULL)
2532: {
2533: (*s_expression) = s_expression_courante;
2534: (*s_etat_processus).erreur_systeme =
2535: d_es_allocation_memoire;
2536: return;
2537: }
2538:
2539: strcpy((*((struct_nom *) (*(*l_element_courant)
2540: .donnee).objet)).nom, fonctions[i + 1]);
2541: (*((struct_nom *) (*(*l_element_courant)
2542: .donnee).objet)).symbole = d_vrai;
2543: }
2544: else if (strcmp(fonctions[i], "DER") == 0)
2545: {
2546: // Ajout de la variable de dérivation
2547:
2548: if (((*l_element_courant).donnee = allocation(
2549: s_etat_processus, NOM)) == NULL)
2550: {
2551: (*s_expression) = s_expression_courante;
2552: (*s_etat_processus).erreur_systeme =
2553: d_es_allocation_memoire;
2554: return;
2555: }
2556:
2557: if (((*((struct_nom *) (*(*l_element_courant)
2558: .donnee).objet)).nom =
2559: malloc((strlen(variable) + 1)
2560: * sizeof(unsigned char))) == NULL)
2561: {
2562: (*s_expression) = s_expression_courante;
2563: (*s_etat_processus).erreur_systeme =
2564: d_es_allocation_memoire;
2565: return;
2566: }
2567:
2568: strcpy((*((struct_nom *) (*(*l_element_courant)
2569: .donnee).objet)).nom, variable);
2570: (*((struct_nom *) (*(*l_element_courant).donnee)
2571: .objet)).symbole = d_vrai;
2572:
2573: // Ajout de la fonction DER
2574:
2575: if (((*l_element_courant).suivant = malloc(
2576: sizeof(struct_liste_chainee))) == NULL)
2577: {
2578: (*s_expression) = s_expression_courante;
2579: (*s_etat_processus).erreur_systeme =
2580: d_es_allocation_memoire;
2581: return;
2582: }
2583:
2584: l_element_courant = (*l_element_courant).suivant;
2585:
2586: if (((*l_element_courant).donnee =
2587: allocation(s_etat_processus, FCT))
2588: == NULL)
2589: {
2590: (*s_expression) = s_expression_courante;
2591: (*s_etat_processus).erreur_systeme =
2592: d_es_allocation_memoire;
2593: return;
2594: }
2595:
2596: if (((*((struct_fonction *) (*(*l_element_courant)
2597: .donnee).objet)).nom_fonction = malloc(4 *
2598: sizeof(unsigned char))) == NULL)
2599: {
2600: (*s_expression) = s_expression_courante;
2601: (*s_etat_processus).erreur_systeme =
2602: d_es_allocation_memoire;
2603: return;
2604: }
2605:
2606: strcpy((*((struct_fonction *)
2607: (*(*l_element_courant).donnee)
2608: .objet)).nom_fonction, "DER");
2609: (*((struct_fonction *) (*(*l_element_courant)
2610: .donnee).objet)).nombre_arguments = 2;
2611: (*((struct_fonction *) (*(*l_element_courant)
2612: .donnee).objet)).fonction =
2613: instruction_der;
2614: }
2615:
2616: i += 3;
2617: } while(fonctions[i] != NULL);
2618:
2619: // Ajout de la fonction '*'
2620:
2621: (*l_element_courant).suivant = (*l_element_suivant).suivant;
2622:
2623: liberation(s_etat_processus, (*l_element_suivant).donnee);
2624: free(l_element_suivant);
2625:
2626: l_element_courant = (*l_element_courant).suivant;
2627:
2628: free((*((struct_fonction *) (*(*l_element_courant).donnee)
2629: .objet)).nom_fonction);
2630:
2631: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
2632: .objet)).nom_fonction = malloc(2 *
2633: sizeof(unsigned char))) == NULL)
2634: {
2635: (*s_expression) = s_expression_courante;
2636: (*s_etat_processus).erreur_systeme =
2637: d_es_allocation_memoire;
2638: return;
2639: }
2640:
2641: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
2642: .objet)).nom_fonction, "*");
2643: (*((struct_fonction *) (*(*l_element_courant).donnee)
2644: .objet)).nombre_arguments = 0;
2645: (*((struct_fonction *) (*(*l_element_courant).donnee)
2646: .objet)).fonction = instruction_multiplication;
2647: }
2648: }
2649: }
2650:
2651: (*s_etat_processus).traitement_symbolique = 'Y';
2652:
2653: if (evaluation(s_etat_processus, s_expression_courante, 'E')
2654: == d_erreur)
2655: {
2656: (*s_expression) = s_expression_courante;
2657: (*s_etat_processus).traitement_symbolique = 'N';
2658: return;
2659: }
2660:
2661: (*s_etat_processus).traitement_symbolique = 'N';
2662: liberation(s_etat_processus, s_expression_courante);
2663:
2664: if ((*s_etat_processus).var_volatile_requete_arret == 0)
2665: {
2666: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2667: &s_expression_courante) == d_erreur)
2668: {
2669: (*s_expression) = NULL;
2670: (*s_etat_processus).erreur_systeme =
2671: d_es_pile_operationnelle_vide;
2672: return;
2673: }
2674:
2675: /*
2676: * Arrêt lorsqu'il n'y a plus de fonction 'DER' dans l'expression
2677: * courante.
2678: */
2679:
2680: if (((*s_expression_courante).type == ALG) ||
2681: ((*s_expression_courante).type == RPN))
2682: {
2683: l_element_courant = (struct_liste_chainee *)
2684: (*s_expression_courante).objet;
2685: drapeau = d_faux;
2686:
2687: while((l_element_courant != NULL) && (drapeau == d_faux))
2688: {
2689: if ((*(*l_element_courant).donnee).type == FCT)
2690: {
2691: if (strcmp((*((struct_fonction *)
2692: (*(*l_element_courant).donnee)
2693: .objet)).nom_fonction, "DER") == 0)
2694: {
2695: drapeau = d_vrai;
2696: }
2697: }
2698:
2699: l_element_courant = (*l_element_courant).suivant;
2700: }
2701: }
2702: else
2703: {
2704: drapeau = d_faux;
2705: }
2706: }
2707: else
2708: {
2709: s_expression_courante = NULL;
2710: }
2711: } while((drapeau == d_vrai) && ((*s_etat_processus)
2712: .var_volatile_requete_arret == 0));
2713:
2714: (*s_expression) = s_expression_courante;
2715:
2716: return;
2717: }
2718:
2719: // vim: ts=4