1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.15
4: Copyright (C) 1989-2010 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 'eval'
29: ================================================================================
30: Entrées : structure processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_eval(struct_processus *s_etat_processus)
40: {
41: logical1 last_valide;
42:
43: struct_objet *s_objet;
44: struct_objet *s_objet_simplifie;
45:
46: unsigned char registre_type_evaluation;
47:
48: (*s_etat_processus).erreur_execution = d_ex;
49:
50: if ((*s_etat_processus).affichage_arguments == 'Y')
51: {
52: printf("\n EVAL ");
53:
54: if ((*s_etat_processus).langue == 'F')
55: {
56: printf("(évaluation d'un objet)\n\n");
57: }
58: else
59: {
60: printf("(object evaluation)\n\n");
61: }
62:
63: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
64: " %s, %s, %s, %s, %s,\n"
65: " %s, %s, %s, %s, %s,\n"
66: " %s\n",
67: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
68: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
69: printf("-> n: %s, %s, %s, %s, %s, %s,\n"
70: " %s, %s, %s, %s, %s,\n"
71: " %s, %s, %s, %s, %s,\n"
72: " %s\n",
73: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
74: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
75: printf(" ...\n");
76: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
77: " %s, %s, %s, %s, %s,\n"
78: " %s, %s, %s, %s, %s,\n"
79: " %s\n",
80: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
81: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
82:
83: return;
84: }
85: else if ((*s_etat_processus).test_instruction == 'Y')
86: {
87: (*s_etat_processus).nombre_arguments = -1;
88: return;
89: }
90:
91: if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
92: {
93: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
94: {
95: return;
96: }
97:
98: cf(s_etat_processus, 31);
99: }
100:
101: registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
102: ? 'E' : 'N';
103: sf(s_etat_processus, 35);
104:
105: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
106: &s_objet) == d_erreur)
107: {
108: if (last_valide == d_vrai)
109: {
110: sf(s_etat_processus, 31);
111: }
112:
113: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
114: return;
115: }
116:
117: if ((s_objet_simplifie = simplification(s_etat_processus, s_objet)) == NULL)
118: {
119: if (last_valide == d_vrai)
120: {
121: sf(s_etat_processus, 31);
122: }
123:
124: return;
125: }
126:
127: liberation(s_etat_processus, s_objet);
128: s_objet = s_objet_simplifie;
129:
130: if ((*s_etat_processus).l_base_pile_systeme == NULL)
131: {
132: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
133: return;
134: }
135:
136: (*(*s_etat_processus).l_base_pile_systeme).evaluation_expression = d_vrai;
137:
138: if (evaluation(s_etat_processus, s_objet, 'E') == d_erreur)
139: {
140: (*(*s_etat_processus).l_base_pile_systeme)
141: .evaluation_expression = d_faux;
142:
143: if (last_valide == d_vrai)
144: {
145: sf(s_etat_processus, 31);
146: }
147:
148: liberation(s_etat_processus, s_objet);
149: return;
150: }
151:
152: (*(*s_etat_processus).l_base_pile_systeme).evaluation_expression = d_faux;
153: liberation(s_etat_processus, s_objet);
154:
155: if (registre_type_evaluation == 'E')
156: {
157: sf(s_etat_processus, 35);
158: }
159: else
160: {
161: cf(s_etat_processus, 35);
162: }
163:
164: if (last_valide == d_vrai)
165: {
166: sf(s_etat_processus, 31);
167: }
168:
169: return;
170: }
171:
172:
173: /*
174: ================================================================================
175: Fonction 'end'
176: ================================================================================
177: Entrées : structure processus
178: --------------------------------------------------------------------------------
179: Sorties :
180: --------------------------------------------------------------------------------
181: Effets de bord : néant
182: ================================================================================
183: */
184:
185: void
186: instruction_end(struct_processus *s_etat_processus)
187: {
188: struct_objet *s_objet;
189:
190: logical1 condition;
191:
192: (*s_etat_processus).erreur_execution = d_ex;
193:
194: if ((*s_etat_processus).affichage_arguments == 'Y')
195: {
196: printf("\n END ");
197:
198: if ((*s_etat_processus).langue == 'F')
199: {
200: printf("(structure de contrôle)\n\n");
201: printf(" Utilisation :\n\n");
202: }
203: else
204: {
205: printf("(control statement)\n\n");
206: printf(" Usage:\n\n");
207: }
208:
209: printf(" IF\n");
210: printf(" (expression test 1)\n");
211: printf(" THEN\n");
212: printf(" (expression 1)\n");
213: printf(" [ELSEIF\n");
214: printf(" (expression test 2)\n");
215: printf(" THEN\n");
216: printf(" (expression 2)]\n");
217: printf(" ...\n");
218: printf(" [ELSE\n");
219: printf(" (expression n)]\n");
220: printf(" END\n\n");
221:
222: printf(" IFERR\n");
223: printf(" (expression test)\n");
224: printf(" THEN\n");
225: printf(" (expression 1)\n");
226: printf(" [ELSE\n");
227: printf(" (expression 2)]\n");
228: printf(" END\n\n");
229:
230: printf(" DO\n");
231: printf(" (expression)\n");
232: printf(" UNTIL\n");
233: printf(" (expression test)\n");
234: printf(" END\n\n");
235:
236: printf(" WHILE\n");
237: printf(" (expression test)\n");
238: printf(" REPEAT\n");
239: printf(" (expression)\n");
240: printf(" END\n\n");
241:
242: printf(" SELECT (expression test)\n");
243: printf(" CASE (clause 1) THEN (expression 1) END\n");
244: printf(" CASE (clause 2) THEN (expression 2) END\n");
245: printf(" ...\n");
246: printf(" CASE (clause n) THEN (expression n) END\n");
247: printf(" DEFAULT\n");
248: printf(" (expression)\n");
249: printf(" END\n\n");
250:
251: printf(" SELECT (expression test)\n");
252: printf(" CASE (clause 1) THEN (expression 1) END\n");
253: printf(" (expression)\n");
254: printf(" CASE (clause 2) THEN (expression 2) END\n");
255: printf(" END\n");
256:
257: return;
258: }
259: else if ((*s_etat_processus).test_instruction == 'Y')
260: {
261: (*s_etat_processus).nombre_arguments = -1;
262: return;
263: }
264:
265: if (((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'I')
266: || ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'J'))
267: {
268: depilement_pile_systeme(s_etat_processus);
269:
270: if ((*s_etat_processus).erreur_systeme != d_es)
271: {
272: return;
273: }
274: }
275: else if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'D')
276: {
277: if ((*(*s_etat_processus).l_base_pile_systeme).clause != 'U')
278: {
279: (*s_etat_processus).erreur_execution =
280: d_ex_erreur_traitement_boucle;
281: return;
282: }
283:
284: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
285: &s_objet) == d_erreur)
286: {
287: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
288: return;
289: }
290:
291: if (((*s_objet).type == INT) ||
292: ((*s_objet).type == REL))
293: {
294: if ((*s_objet).type == INT)
295: {
296: condition = ((*((integer8 *) (*s_objet).objet)) == 0)
297: ? d_faux : d_vrai;
298: }
299: else
300: {
301: condition = ((*((real8 *) (*s_objet).objet)) == 0)
302: ? d_faux : d_vrai;
303: }
304:
305: if (condition == d_faux)
306: {
307: if ((*s_etat_processus).mode_execution_programme == 'Y')
308: {
309: (*s_etat_processus).position_courante =
310: (*(*s_etat_processus).l_base_pile_systeme)
311: .adresse_retour;
312: }
313: else
314: {
315: (*s_etat_processus).expression_courante =
316: (*(*s_etat_processus).l_base_pile_systeme)
317: .pointeur_objet_retour;
318: }
319: }
320: else
321: {
322: depilement_pile_systeme(s_etat_processus);
323:
324: if ((*s_etat_processus).erreur_systeme != d_es)
325: {
326: return;
327: }
328: }
329: }
330: else
331: {
332: liberation(s_etat_processus, s_objet);
333:
334: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
335: return;
336: }
337:
338: liberation(s_etat_processus, s_objet);
339: }
340: else if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'W')
341: {
342: if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'W')
343: {
344: if ((*s_etat_processus).mode_execution_programme == 'Y')
345: {
346: (*s_etat_processus).position_courante =
347: (*(*s_etat_processus).l_base_pile_systeme)
348: .adresse_retour;
349: }
350: else
351: {
352: (*s_etat_processus).expression_courante =
353: (*(*s_etat_processus).l_base_pile_systeme)
354: .pointeur_objet_retour;
355: }
356: }
357: else
358: {
359: depilement_pile_systeme(s_etat_processus);
360:
361: if ((*s_etat_processus).erreur_systeme != d_es)
362: {
363: return;
364: }
365: }
366: }
367: else if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'C')
368: {
369: if ((*(*s_etat_processus).l_base_pile_systeme).clause != 'Q')
370: {
371: depilement_pile_systeme(s_etat_processus);
372:
373: if ((*s_etat_processus).erreur_systeme != d_es)
374: {
375: return;
376: }
377: }
378: else
379: {
380: (*(*s_etat_processus).l_base_pile_systeme).clause = 'C';
381: }
382: }
383: else
384: {
385: (*s_etat_processus).erreur_systeme = d_es_end_incoherent;
386: }
387:
388: return;
389: }
390:
391:
392: /*
393: ================================================================================
394: Fonction 'else'
395: ================================================================================
396: Entrées : structure processus
397: --------------------------------------------------------------------------------
398: Sorties :
399: --------------------------------------------------------------------------------
400: Effets de bord : néant
401: ================================================================================
402: */
403:
404: void
405: instruction_else(struct_processus *s_etat_processus)
406: {
407: logical1 drapeau_fin;
408: logical1 execution;
409:
410: struct_liste_chainee *s_registre;
411:
412: unsigned char *instruction_majuscule;
413: unsigned char *tampon;
414:
415: unsigned long niveau;
416:
417: void (*fonction)();
418:
419: (*s_etat_processus).erreur_execution = d_ex;
420:
421: if ((*s_etat_processus).affichage_arguments == 'Y')
422: {
423: printf("\n ELSE ");
424:
425: if ((*s_etat_processus).langue == 'F')
426: {
427: printf("(structure de contrôle)\n\n");
428: printf(" Utilisation :\n\n");
429: }
430: else
431: {
432: printf("(control statement)\n\n");
433: printf(" Usage:\n\n");
434: }
435:
436: printf(" IF\n");
437: printf(" (expression test 1)\n");
438: printf(" THEN\n");
439: printf(" (expression 1)\n");
440: printf(" [ELSEIF\n");
441: printf(" (expression test 2)\n");
442: printf(" THEN\n");
443: printf(" (expression 2)]\n");
444: printf(" ...\n");
445: printf(" ELSE\n");
446: printf(" (expression n)\n");
447: printf(" END\n");
448:
449: return;
450: }
451: else if ((*s_etat_processus).test_instruction == 'Y')
452: {
453: (*s_etat_processus).nombre_arguments = -1;
454: return;
455: }
456:
457: if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'T')
458: {
459: niveau = 0;
460: drapeau_fin = d_faux;
461:
462: if ((*s_etat_processus).mode_execution_programme == 'Y')
463: {
464: tampon = (*s_etat_processus).instruction_courante;
465:
466: do
467: {
468: if (recherche_instruction_suivante(s_etat_processus)
469: == d_erreur)
470: {
471: if ((*s_etat_processus).instruction_courante != NULL)
472: {
473: free((*s_etat_processus).instruction_courante);
474: }
475:
476: (*s_etat_processus).instruction_courante = tampon;
477: (*s_etat_processus).erreur_execution =
478: d_ex_erreur_traitement_condition;
479: return;
480: }
481:
482: if ((instruction_majuscule = conversion_majuscule(
483: (*s_etat_processus).instruction_courante)) == NULL)
484: {
485: free((*s_etat_processus).instruction_courante);
486: (*s_etat_processus).instruction_courante = tampon;
487: (*s_etat_processus).erreur_systeme =
488: d_es_allocation_memoire;
489: return;
490: }
491:
492: if (niveau == 0)
493: {
494: if (strcmp(instruction_majuscule, "END") == 0)
495: {
496: (*s_etat_processus).position_courante -= (strlen(
497: instruction_majuscule) + 1);
498: drapeau_fin = d_vrai;
499: }
500: else
501: {
502: drapeau_fin = d_faux;
503: }
504: }
505: else
506: {
507: drapeau_fin = d_faux;
508: }
509:
510: if ((strcmp(instruction_majuscule, "CASE") == 0) ||
511: (strcmp(instruction_majuscule, "DO") == 0) ||
512: (strcmp(instruction_majuscule, "IF") == 0) ||
513: (strcmp(instruction_majuscule, "IFERR") == 0) ||
514: (strcmp(instruction_majuscule, "SELECT") == 0) ||
515: (strcmp(instruction_majuscule, "WHILE") == 0))
516: {
517: niveau++;
518: }
519: else if (strcmp(instruction_majuscule, "END") == 0)
520: {
521: niveau--;
522: }
523:
524: free(instruction_majuscule);
525: free((*s_etat_processus).instruction_courante);
526: } while(drapeau_fin == d_faux);
527:
528: (*s_etat_processus).instruction_courante = tampon;
529: }
530: else
531: {
532: /*
533: * Vérification du pointeur de prédiction de saut.
534: */
535:
536: if (pthread_mutex_lock(&((*(*(*s_etat_processus)
537: .expression_courante).donnee).mutex)) != 0)
538: {
539: (*s_etat_processus).erreur_systeme = d_es_processus;
540: return;
541: }
542:
543: if ((*((struct_fonction *) (*(*(*s_etat_processus)
544: .expression_courante).donnee).objet)).prediction_saut
545: != NULL)
546: {
547: s_registre = (*s_etat_processus).expression_courante;
548:
549: (*s_etat_processus).expression_courante =
550: (struct_liste_chainee *)
551: (*((struct_fonction *) (*(*(*s_etat_processus)
552: .expression_courante).donnee).objet))
553: .prediction_saut;
554: fonction = (*((struct_fonction *)
555: (*(*(*s_etat_processus).expression_courante)
556: .donnee).objet)).fonction;
557: execution = (*((struct_fonction *)
558: (*(*s_registre).donnee).objet)).prediction_execution;
559:
560: if (pthread_mutex_unlock(&((*(*s_registre).donnee).mutex)) != 0)
561: {
562: (*s_etat_processus).erreur_systeme = d_es_processus;
563: return;
564: }
565:
566: if (execution == d_vrai)
567: {
568: fonction(s_etat_processus);
569: }
570: }
571: else
572: {
573: if (pthread_mutex_unlock(&((*(*(*s_etat_processus)
574: .expression_courante).donnee).mutex)) != 0)
575: {
576: (*s_etat_processus).erreur_systeme = d_es_processus;
577: return;
578: }
579:
580: s_registre = (*s_etat_processus).expression_courante;
581: execution = d_faux;
582:
583: do
584: {
585: if (((*s_etat_processus).expression_courante =
586: (*(*s_etat_processus).expression_courante).suivant)
587: == NULL)
588: {
589: (*s_etat_processus).erreur_execution =
590: d_ex_erreur_traitement_condition;
591: return;
592: }
593:
594: if ((*(*(*s_etat_processus).expression_courante)
595: .donnee).type == FCT)
596: {
597: fonction = (*((struct_fonction *)
598: (*(*(*s_etat_processus).expression_courante)
599: .donnee).objet)).fonction;
600:
601: if (niveau == 0)
602: {
603: if (fonction == instruction_end)
604: {
605: fonction(s_etat_processus);
606: execution = d_vrai;
607: drapeau_fin = d_vrai;
608: }
609: else
610: {
611: drapeau_fin = d_faux;
612: }
613: }
614: else
615: {
616: drapeau_fin = d_faux;
617: }
618:
619: if ((fonction == instruction_case) ||
620: (fonction == instruction_do) ||
621: (fonction == instruction_if) ||
622: (fonction == instruction_iferr) ||
623: (fonction == instruction_select) ||
624: (fonction == instruction_while))
625: {
626: niveau++;
627: }
628: else if (fonction == instruction_end)
629: {
630: niveau--;
631: }
632: }
633: } while(drapeau_fin == d_faux);
634:
635: if (pthread_mutex_lock(&((*(*(*s_etat_processus)
636: .expression_courante).donnee).mutex)) != 0)
637: {
638: (*s_etat_processus).erreur_systeme = d_es_processus;
639: return;
640: }
641:
642: (*((struct_fonction *) (*(*s_registre).donnee).objet))
643: .prediction_saut = (*s_etat_processus)
644: .expression_courante;
645: (*((struct_fonction *) (*(*s_registre).donnee).objet))
646: .prediction_execution = execution;
647:
648: if (pthread_mutex_unlock(&((*(*(*s_etat_processus)
649: .expression_courante).donnee).mutex)) != 0)
650: {
651: (*s_etat_processus).erreur_systeme = d_es_processus;
652: return;
653: }
654: }
655: }
656: }
657: else if ((*(*s_etat_processus).l_base_pile_systeme).clause != 'E')
658: {
659: (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_condition;
660: return;
661: }
662: else
663: {
664: (*(*s_etat_processus).l_base_pile_systeme).clause = 'Z';
665: }
666:
667: return;
668: }
669:
670:
671: /*
672: ================================================================================
673: Fonction 'elseif'
674: ================================================================================
675: Entrées : structure processus
676: --------------------------------------------------------------------------------
677: Sorties :
678: --------------------------------------------------------------------------------
679: Effets de bord : néant
680: ================================================================================
681: */
682:
683: void
684: instruction_elseif(struct_processus *s_etat_processus)
685: {
686: logical1 drapeau_fin;
687: logical1 execution;
688:
689: struct_liste_chainee *s_registre;
690:
691: unsigned char *instruction_majuscule;
692: unsigned char *tampon;
693:
694: unsigned long niveau;
695:
696: void (*fonction)();
697:
698: (*s_etat_processus).erreur_execution = d_ex;
699:
700: if ((*s_etat_processus).affichage_arguments == 'Y')
701: {
702: printf("\n ELSEIF ");
703:
704: if ((*s_etat_processus).langue == 'F')
705: {
706: printf("(structure de contrôle)\n\n");
707: printf(" Utilisation :\n\n");
708: }
709: else
710: {
711: printf("(control statement)\n\n");
712: printf(" Usage:\n\n");
713: }
714:
715: printf(" IF\n");
716: printf(" (expression test 1)\n");
717: printf(" THEN\n");
718: printf(" (expression 1)\n");
719: printf(" ELSEIF\n");
720: printf(" (expression test 2)\n");
721: printf(" THEN\n");
722: printf(" (expression 2)\n");
723: printf(" ...\n");
724: printf(" [ELSE\n");
725: printf(" (expression n)]\n");
726: printf(" END\n\n");
727:
728: return;
729: }
730: else if ((*s_etat_processus).test_instruction == 'Y')
731: {
732: (*s_etat_processus).nombre_arguments = -1;
733: return;
734: }
735:
736: if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture != 'I')
737: {
738: (*s_etat_processus).erreur_execution =
739: d_ex_erreur_traitement_condition;
740: return;
741: }
742:
743: if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'T')
744: {
745: /*
746: * On saute au END car le test précédent était vrai.
747: */
748:
749: niveau = 0;
750: drapeau_fin = d_faux;
751:
752: if ((*s_etat_processus).mode_execution_programme == 'Y')
753: {
754: tampon = (*s_etat_processus).instruction_courante;
755:
756: do
757: {
758: if (recherche_instruction_suivante(s_etat_processus)
759: == d_erreur)
760: {
761: if ((*s_etat_processus).instruction_courante != NULL)
762: {
763: free((*s_etat_processus).instruction_courante);
764: }
765:
766: (*s_etat_processus).instruction_courante = tampon;
767: (*s_etat_processus).erreur_execution =
768: d_ex_erreur_traitement_condition;
769: return;
770: }
771:
772: if ((instruction_majuscule = conversion_majuscule(
773: (*s_etat_processus).instruction_courante)) == NULL)
774: {
775: free((*s_etat_processus).instruction_courante);
776: (*s_etat_processus).instruction_courante = tampon;
777: (*s_etat_processus).erreur_systeme =
778: d_es_allocation_memoire;
779: return;
780: }
781:
782: if (niveau == 0)
783: {
784: if (strcmp(instruction_majuscule, "END") == 0)
785: {
786: (*s_etat_processus).position_courante -= (strlen(
787: instruction_majuscule) + 1);
788: drapeau_fin = d_vrai;
789: }
790: else
791: {
792: drapeau_fin = d_faux;
793: }
794: }
795: else
796: {
797: drapeau_fin = d_faux;
798: }
799:
800: if ((strcmp(instruction_majuscule, "CASE") == 0) ||
801: (strcmp(instruction_majuscule, "DO") == 0) ||
802: (strcmp(instruction_majuscule, "IF") == 0) ||
803: (strcmp(instruction_majuscule, "IFERR") == 0) ||
804: (strcmp(instruction_majuscule, "SELECT") == 0) ||
805: (strcmp(instruction_majuscule, "WHILE") == 0))
806: {
807: niveau++;
808: }
809: else if (strcmp(instruction_majuscule, "END") == 0)
810: {
811: niveau--;
812: }
813:
814: free(instruction_majuscule);
815: free((*s_etat_processus).instruction_courante);
816: } while(drapeau_fin == d_faux);
817:
818: (*s_etat_processus).instruction_courante = tampon;
819: }
820: else
821: {
822: /*
823: * Vérification du pointeur de prédiction de saut
824: */
825:
826: if (pthread_mutex_lock(&((*(*(*s_etat_processus)
827: .expression_courante).donnee).mutex)) != 0)
828: {
829: (*s_etat_processus).erreur_systeme = d_es_processus;
830: return;
831: }
832:
833: if ((*((struct_fonction *) (*(*(*s_etat_processus)
834: .expression_courante).donnee).objet)).prediction_saut
835: != NULL)
836: {
837: s_registre = (*s_etat_processus).expression_courante;
838:
839: (*s_etat_processus).expression_courante =
840: (struct_liste_chainee *)
841: (*((struct_fonction *) (*(*(*s_etat_processus)
842: .expression_courante).donnee).objet))
843: .prediction_saut;
844: fonction = (*((struct_fonction *)
845: (*(*(*s_etat_processus).expression_courante)
846: .donnee).objet)).fonction;
847: execution = (*((struct_fonction *)
848: (*(*s_registre).donnee).objet)).prediction_execution;
849:
850: if (pthread_mutex_unlock(&((*(*s_registre).donnee).mutex)) != 0)
851: {
852: (*s_etat_processus).erreur_systeme = d_es_processus;
853: return;
854: }
855:
856: if (execution == d_vrai)
857: {
858: fonction(s_etat_processus);
859: }
860: }
861: else
862: {
863: if (pthread_mutex_unlock(&((*(*(*s_etat_processus)
864: .expression_courante).donnee).mutex)) != 0)
865: {
866: (*s_etat_processus).erreur_systeme = d_es_processus;
867: return;
868: }
869:
870: s_registre = (*s_etat_processus).expression_courante;
871: execution = d_faux;
872:
873: do
874: {
875: if (((*s_etat_processus).expression_courante =
876: (*(*s_etat_processus).expression_courante).suivant)
877: == NULL)
878: {
879: (*s_etat_processus).erreur_execution =
880: d_ex_erreur_traitement_condition;
881: return;
882: }
883:
884: if ((*(*(*s_etat_processus).expression_courante)
885: .donnee).type == FCT)
886: {
887: fonction = (*((struct_fonction *)
888: (*(*(*s_etat_processus).expression_courante)
889: .donnee).objet)).fonction;
890:
891: if (niveau == 0)
892: {
893: if (fonction == instruction_end)
894: {
895: instruction_end(s_etat_processus);
896: execution = d_vrai;
897: drapeau_fin = d_vrai;
898: }
899: else
900: {
901: drapeau_fin = d_faux;
902: }
903: }
904: else
905: {
906: drapeau_fin = d_faux;
907: }
908:
909: if ((fonction == instruction_case) ||
910: (fonction == instruction_do) ||
911: (fonction == instruction_if) ||
912: (fonction == instruction_iferr) ||
913: (fonction == instruction_select) ||
914: (fonction == instruction_while))
915: {
916: niveau++;
917: }
918: else if (fonction == instruction_end)
919: {
920: niveau--;
921: }
922: }
923: } while(drapeau_fin == d_faux);
924:
925: if (pthread_mutex_lock(&((*(*(*s_etat_processus)
926: .expression_courante).donnee).mutex)) != 0)
927: {
928: (*s_etat_processus).erreur_systeme = d_es_processus;
929: return;
930: }
931:
932: (*((struct_fonction *) (*(*s_registre).donnee).objet))
933: .prediction_saut = (*s_etat_processus)
934: .expression_courante;
935: (*((struct_fonction *) (*(*s_registre).donnee).objet))
936: .prediction_execution = execution;
937:
938: if (pthread_mutex_unlock(&((*(*(*s_etat_processus)
939: .expression_courante).donnee).mutex)) != 0)
940: {
941: (*s_etat_processus).erreur_systeme = d_es_processus;
942: return;
943: }
944: }
945: }
946: }
947: else
948: {
949: /*
950: * On teste à nouveau...
951: */
952:
953: (*(*s_etat_processus).l_base_pile_systeme).clause = 'I';
954: }
955:
956: return;
957: }
958:
959:
960: /*
961: ================================================================================
962: Fonction 'e'
963: ================================================================================
964: Entrées : structure processus
965: --------------------------------------------------------------------------------
966: Sorties :
967: --------------------------------------------------------------------------------
968: Effets de bord : néant
969: ================================================================================
970: */
971:
972: void
973: instruction_sensible_e(struct_processus *s_etat_processus)
974: {
975: if (strcmp((*s_etat_processus).instruction_courante, "e") == 0)
976: {
977: instruction_e(s_etat_processus);
978: }
979: else
980: {
981: (*s_etat_processus).instruction_valide = 'N';
982: }
983:
984: return;
985: }
986:
987: void
988: instruction_e(struct_processus *s_etat_processus)
989: {
990: struct_objet *s_objet;
991:
992: (*s_etat_processus).erreur_execution = d_ex;
993:
994: if ((*s_etat_processus).affichage_arguments == 'Y')
995: {
996: printf("\n e ");
997:
998: if ((*s_etat_processus).langue == 'F')
999: {
1000: printf("(base de logarithmes népériens)\n\n");
1001: }
1002: else
1003: {
1004: printf("(base of natural logarithm)\n\n");
1005: }
1006:
1007: printf("-> 1: %s\n", d_REL);
1008:
1009: return;
1010: }
1011: else if ((*s_etat_processus).test_instruction == 'Y')
1012: {
1013: (*s_etat_processus).constante_symbolique = 'Y';
1014: (*s_etat_processus).nombre_arguments = -1;
1015: return;
1016: }
1017:
1018: /* Indicateur 35 armé => évaluation symbolique */
1019: if (test_cfsf(s_etat_processus, 35) == d_vrai)
1020: {
1021: if ((s_objet = allocation(s_etat_processus, NOM)) == NULL)
1022: {
1023: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1024: return;
1025: }
1026:
1027: if (((*((struct_nom *) (*s_objet).objet)).nom =
1028: malloc(2 * sizeof(unsigned char))) == NULL)
1029: {
1030: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1031: return;
1032: }
1033:
1034: strcpy((*((struct_nom *) (*s_objet).objet)).nom, "e");
1035: (*((struct_nom *) (*s_objet).objet)).symbole = d_faux;
1036: }
1037: else
1038: {
1039: if ((s_objet = allocation(s_etat_processus, REL)) == NULL)
1040: {
1041: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1042: return;
1043: }
1044:
1045: (*((real8 *) (*s_objet).objet)) = exp((real8) 1);
1046: }
1047:
1048: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1049: s_objet) == d_erreur)
1050: {
1051: return;
1052: }
1053:
1054: return;
1055: }
1056:
1057:
1058: /*
1059: ================================================================================
1060: Fonction 'eng'
1061: ================================================================================
1062: Entrées : pointeur sur une struct_processus
1063: --------------------------------------------------------------------------------
1064: Sorties :
1065: --------------------------------------------------------------------------------
1066: Effets de bord : néant
1067: ================================================================================
1068: */
1069:
1070: void
1071: instruction_eng(struct_processus *s_etat_processus)
1072: {
1073: struct_objet *s_objet_argument;
1074: struct_objet *s_objet;
1075:
1076: logical1 i43;
1077: logical1 i44;
1078:
1079: unsigned char *valeur_binaire;
1080:
1081: unsigned long i;
1082: unsigned long j;
1083:
1084: (*s_etat_processus).erreur_execution = d_ex;
1085:
1086: if ((*s_etat_processus).affichage_arguments == 'Y')
1087: {
1088: printf("\n ENG ");
1089:
1090: if ((*s_etat_processus).langue == 'F')
1091: {
1092: printf("(notation ingénieur)\n\n");
1093: printf(" Aucun argument\n");
1094: }
1095: else
1096: {
1097: printf("(engineer notation)\n\n");
1098: printf(" No argument\n");
1099: }
1100:
1101: return;
1102: }
1103: else if ((*s_etat_processus).test_instruction == 'Y')
1104: {
1105: (*s_etat_processus).nombre_arguments = -1;
1106: return;
1107: }
1108:
1109: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1110: {
1111: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1112: {
1113: return;
1114: }
1115: }
1116:
1117: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1118: &s_objet_argument) == d_erreur)
1119: {
1120: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1121: return;
1122: }
1123:
1124: if ((*s_objet_argument).type == INT)
1125: {
1126: if (((*((integer8 *) (*s_objet_argument).objet)) >= 0) &&
1127: ((*((integer8 *) (*s_objet_argument).objet)) <= 15))
1128: {
1129: if ((s_objet = allocation(s_etat_processus, BIN)) == NULL)
1130: {
1131: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1132: return;
1133: }
1134:
1135: (*((logical8 *) (*s_objet).objet)) =
1136: (*((integer8 *) (*s_objet_argument).objet));
1137:
1138: i43 = test_cfsf(s_etat_processus, 43);
1139: i44 = test_cfsf(s_etat_processus, 44);
1140:
1141: sf(s_etat_processus, 44);
1142: cf(s_etat_processus, 43);
1143:
1144: if ((valeur_binaire = formateur(s_etat_processus, 0, s_objet))
1145: == NULL)
1146: {
1147: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1148: return;
1149: }
1150:
1151: if (i43 == d_vrai)
1152: {
1153: sf(s_etat_processus, 43);
1154: }
1155: else
1156: {
1157: cf(s_etat_processus, 43);
1158: }
1159:
1160: if (i44 == d_vrai)
1161: {
1162: sf(s_etat_processus, 44);
1163: }
1164: else
1165: {
1166: cf(s_etat_processus, 44);
1167: }
1168:
1169: for(j = 53, i = strlen(valeur_binaire) - 2; i >= 2; i--)
1170: {
1171: if (valeur_binaire[i] == '0')
1172: {
1173: cf(s_etat_processus, j++);
1174: }
1175: else
1176: {
1177: sf(s_etat_processus, j++);
1178: }
1179: }
1180:
1181: for(; j <= 56; cf(s_etat_processus, j++));
1182:
1183: sf(s_etat_processus, 49);
1184: sf(s_etat_processus, 50);
1185:
1186: free(valeur_binaire);
1187: liberation(s_etat_processus, s_objet);
1188: }
1189: else
1190: {
1191: liberation(s_etat_processus, s_objet_argument);
1192:
1193: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1194: return;
1195: }
1196: }
1197: else
1198: {
1199: liberation(s_etat_processus, s_objet_argument);
1200:
1201: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1202: return;
1203: }
1204:
1205: liberation(s_etat_processus, s_objet_argument);
1206:
1207: return;
1208: }
1209:
1210:
1211: /*
1212: ================================================================================
1213: Fonction 'exp'
1214: ================================================================================
1215: Entrées : pointeur sur une struct_processus
1216: --------------------------------------------------------------------------------
1217: Sorties :
1218: --------------------------------------------------------------------------------
1219: Effets de bord : néant
1220: ================================================================================
1221: */
1222:
1223: void
1224: instruction_exp(struct_processus *s_etat_processus)
1225: {
1226: struct_liste_chainee *l_element_courant;
1227: struct_liste_chainee *l_element_precedent;
1228:
1229: struct_objet *s_copie_argument;
1230: struct_objet *s_objet_argument;
1231: struct_objet *s_objet_resultat;
1232:
1233: (*s_etat_processus).erreur_execution = d_ex;
1234:
1235: if ((*s_etat_processus).affichage_arguments == 'Y')
1236: {
1237: printf("\n EXP ");
1238:
1239: if ((*s_etat_processus).langue == 'F')
1240: {
1241: printf("(exponentielle)\n\n");
1242: }
1243: else
1244: {
1245: printf("(exponential)\n\n");
1246: }
1247:
1248: printf(" 1: %s, %s\n", d_INT, d_REL);
1249: printf("-> 1: %s\n\n", d_REL);
1250:
1251: printf(" 1: %s\n", d_CPL);
1252: printf("-> 1: %s\n\n", d_CPL);
1253:
1254: printf(" 1: %s, %s\n", d_NOM, d_ALG);
1255: printf("-> 1: %s\n\n", d_ALG);
1256:
1257: printf(" 1: %s\n", d_RPN);
1258: printf("-> 1: %s\n", d_RPN);
1259:
1260: return;
1261: }
1262: else if ((*s_etat_processus).test_instruction == 'Y')
1263: {
1264: (*s_etat_processus).nombre_arguments = 1;
1265: return;
1266: }
1267:
1268: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1269: {
1270: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1271: {
1272: return;
1273: }
1274: }
1275:
1276: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1277: &s_objet_argument) == d_erreur)
1278: {
1279: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1280: return;
1281: }
1282:
1283: /*
1284: --------------------------------------------------------------------------------
1285: Exponentielle d'un entier
1286: --------------------------------------------------------------------------------
1287: */
1288:
1289: if ((*s_objet_argument).type == INT)
1290: {
1291: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
1292: {
1293: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1294: return;
1295: }
1296:
1297: (*((real8 *) (*s_objet_resultat).objet)) =
1298: exp((real8) (*((integer8 *) (*s_objet_argument).objet)));
1299: }
1300:
1301: /*
1302: --------------------------------------------------------------------------------
1303: Exponentielle d'un réel
1304: --------------------------------------------------------------------------------
1305: */
1306:
1307: else if ((*s_objet_argument).type == REL)
1308: {
1309: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
1310: {
1311: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1312: return;
1313: }
1314:
1315: (*((real8 *) (*s_objet_resultat).objet)) =
1316: exp(((*((real8 *) (*s_objet_argument).objet))));
1317: }
1318:
1319: /*
1320: --------------------------------------------------------------------------------
1321: Exponentielle d'un complexe
1322: --------------------------------------------------------------------------------
1323: */
1324:
1325: else if ((*s_objet_argument).type == CPL)
1326: {
1327: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL)
1328: {
1329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1330: return;
1331: }
1332:
1333: f77expc_((struct_complexe16 *) (*s_objet_argument).objet,
1334: (struct_complexe16 *) (*s_objet_resultat).objet);
1335: }
1336:
1337: /*
1338: --------------------------------------------------------------------------------
1339: Exponentielle d'un nom
1340: --------------------------------------------------------------------------------
1341: */
1342:
1343: else if ((*s_objet_argument).type == NOM)
1344: {
1345: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
1346: {
1347: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1348: return;
1349: }
1350:
1351: if (((*s_objet_resultat).objet =
1352: allocation_maillon(s_etat_processus)) == NULL)
1353: {
1354: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1355: return;
1356: }
1357:
1358: l_element_courant = (*s_objet_resultat).objet;
1359:
1360: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1361: == NULL)
1362: {
1363: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1364: return;
1365: }
1366:
1367: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1368: .nombre_arguments = 0;
1369: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1370: .fonction = instruction_vers_niveau_superieur;
1371:
1372: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1373: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1374: {
1375: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1376: return;
1377: }
1378:
1379: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1380: .nom_fonction, "<<");
1381:
1382: if (((*l_element_courant).suivant =
1383: allocation_maillon(s_etat_processus)) == NULL)
1384: {
1385: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1386: return;
1387: }
1388:
1389: l_element_courant = (*l_element_courant).suivant;
1390: (*l_element_courant).donnee = s_objet_argument;
1391:
1392: if (((*l_element_courant).suivant =
1393: allocation_maillon(s_etat_processus)) == NULL)
1394: {
1395: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1396: return;
1397: }
1398:
1399: l_element_courant = (*l_element_courant).suivant;
1400:
1401: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1402: == NULL)
1403: {
1404: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1405: return;
1406: }
1407:
1408: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1409: .nombre_arguments = 1;
1410: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1411: .fonction = instruction_exp;
1412:
1413: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1414: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
1415: {
1416: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1417: return;
1418: }
1419:
1420: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1421: .nom_fonction, "EXP");
1422:
1423: if (((*l_element_courant).suivant =
1424: allocation_maillon(s_etat_processus)) == NULL)
1425: {
1426: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1427: return;
1428: }
1429:
1430: l_element_courant = (*l_element_courant).suivant;
1431:
1432: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1433: == NULL)
1434: {
1435: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1436: return;
1437: }
1438:
1439: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1440: .nombre_arguments = 0;
1441: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1442: .fonction = instruction_vers_niveau_inferieur;
1443:
1444: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1445: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1446: {
1447: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1448: return;
1449: }
1450:
1451: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1452: .nom_fonction, ">>");
1453:
1454: (*l_element_courant).suivant = NULL;
1455: s_objet_argument = NULL;
1456: }
1457:
1458: /*
1459: --------------------------------------------------------------------------------
1460: Exponentielle d'une expression
1461: --------------------------------------------------------------------------------
1462: */
1463:
1464: else if (((*s_objet_argument).type == ALG) ||
1465: ((*s_objet_argument).type == RPN))
1466: {
1467: if ((s_copie_argument = copie_objet(s_etat_processus,
1468: s_objet_argument, 'N')) == NULL)
1469: {
1470: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1471: return;
1472: }
1473:
1474: l_element_courant = (struct_liste_chainee *)
1475: (*s_copie_argument).objet;
1476: l_element_precedent = l_element_courant;
1477:
1478: while((*l_element_courant).suivant != NULL)
1479: {
1480: l_element_precedent = l_element_courant;
1481: l_element_courant = (*l_element_courant).suivant;
1482: }
1483:
1484: if (((*l_element_precedent).suivant =
1485: allocation_maillon(s_etat_processus)) == NULL)
1486: {
1487: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1488: return;
1489: }
1490:
1491: if (((*(*l_element_precedent).suivant).donnee =
1492: allocation(s_etat_processus, FCT)) == NULL)
1493: {
1494: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1495: return;
1496: }
1497:
1498: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1499: .donnee).objet)).nombre_arguments = 1;
1500: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1501: .donnee).objet)).fonction = instruction_exp;
1502:
1503: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1504: .suivant).donnee).objet)).nom_fonction =
1505: malloc(4 * sizeof(unsigned char))) == NULL)
1506: {
1507: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1508: return;
1509: }
1510:
1511: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1512: .suivant).donnee).objet)).nom_fonction, "EXP");
1513:
1514: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1515:
1516: s_objet_resultat = s_copie_argument;
1517: }
1518:
1519: /*
1520: --------------------------------------------------------------------------------
1521: Fonction exponentielle impossible à réaliser
1522: --------------------------------------------------------------------------------
1523: */
1524:
1525: else
1526: {
1527: liberation(s_etat_processus, s_objet_argument);
1528:
1529: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1530: return;
1531: }
1532:
1533: liberation(s_etat_processus, s_objet_argument);
1534:
1535: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1536: s_objet_resultat) == d_erreur)
1537: {
1538: return;
1539: }
1540:
1541: return;
1542: }
1543:
1544:
1545: /*
1546: ================================================================================
1547: Fonction 'exp' (-1)
1548: ================================================================================
1549: Entrées : pointeur sur une struct_processus
1550: --------------------------------------------------------------------------------
1551: Sorties :
1552: --------------------------------------------------------------------------------
1553: Effets de bord : néant
1554: ================================================================================
1555: */
1556:
1557: void
1558: instruction_expm(struct_processus *s_etat_processus)
1559: {
1560: struct_liste_chainee *l_element_courant;
1561: struct_liste_chainee *l_element_precedent;
1562:
1563: struct_objet *s_copie_argument;
1564: struct_objet *s_objet_argument;
1565: struct_objet *s_objet_resultat;
1566:
1567: (*s_etat_processus).erreur_execution = d_ex;
1568:
1569: if ((*s_etat_processus).affichage_arguments == 'Y')
1570: {
1571: printf("\n EXPM ");
1572:
1573: if ((*s_etat_processus).langue == 'F')
1574: {
1575: printf("(exponentielle moins un)\n\n");
1576: }
1577: else
1578: {
1579: printf("(exp - 1)\n\n");
1580: }
1581:
1582: printf(" 1: %s, %s\n", d_INT, d_REL);
1583: printf("-> 1: %s\n\n", d_REL);
1584:
1585: printf(" 1: %s\n", d_CPL);
1586: printf("-> 1: %s\n\n", d_CPL);
1587:
1588: printf(" 1: %s, %s\n", d_NOM, d_ALG);
1589: printf("-> 1: %s\n\n", d_ALG);
1590:
1591: printf(" 1: %s\n", d_RPN);
1592: printf("-> 1: %s\n", d_RPN);
1593:
1594: return;
1595: }
1596: else if ((*s_etat_processus).test_instruction == 'Y')
1597: {
1598: (*s_etat_processus).nombre_arguments = 1;
1599: return;
1600: }
1601:
1602: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1603: {
1604: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1605: {
1606: return;
1607: }
1608: }
1609:
1610: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1611: &s_objet_argument) == d_erreur)
1612: {
1613: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1614: return;
1615: }
1616:
1617: /*
1618: --------------------------------------------------------------------------------
1619: Exponentielle (-1) d'un entier
1620: --------------------------------------------------------------------------------
1621: */
1622:
1623: if ((*s_objet_argument).type == INT)
1624: {
1625: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
1626: {
1627: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1628: return;
1629: }
1630:
1631: (*((real8 *) (*s_objet_resultat).objet)) =
1632: expm1((real8) (*((integer8 *) (*s_objet_argument).objet)));
1633: }
1634:
1635: /*
1636: --------------------------------------------------------------------------------
1637: Exponentielle (-1) d'un réel
1638: --------------------------------------------------------------------------------
1639: */
1640:
1641: else if ((*s_objet_argument).type == REL)
1642: {
1643: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
1644: {
1645: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1646: return;
1647: }
1648:
1649: (*((real8 *) (*s_objet_resultat).objet)) =
1650: expm1(((*((real8 *) (*s_objet_argument).objet))));
1651: }
1652:
1653: /*
1654: --------------------------------------------------------------------------------
1655: Exponentielle (-1) d'un nom
1656: --------------------------------------------------------------------------------
1657: */
1658:
1659: else if ((*s_objet_argument).type == NOM)
1660: {
1661: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
1662: {
1663: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1664: return;
1665: }
1666:
1667: if (((*s_objet_resultat).objet =
1668: allocation_maillon(s_etat_processus)) == NULL)
1669: {
1670: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1671: return;
1672: }
1673:
1674: l_element_courant = (*s_objet_resultat).objet;
1675:
1676: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1677: == NULL)
1678: {
1679: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1680: return;
1681: }
1682:
1683: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1684: .nombre_arguments = 0;
1685: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1686: .fonction = instruction_vers_niveau_superieur;
1687:
1688: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1689: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1690: {
1691: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1692: return;
1693: }
1694:
1695: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1696: .nom_fonction, "<<");
1697:
1698: if (((*l_element_courant).suivant =
1699: allocation_maillon(s_etat_processus)) == NULL)
1700: {
1701: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1702: return;
1703: }
1704:
1705: l_element_courant = (*l_element_courant).suivant;
1706: (*l_element_courant).donnee = s_objet_argument;
1707:
1708: if (((*l_element_courant).suivant =
1709: allocation_maillon(s_etat_processus)) == NULL)
1710: {
1711: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1712: return;
1713: }
1714:
1715: l_element_courant = (*l_element_courant).suivant;
1716:
1717: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1718: == NULL)
1719: {
1720: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1721: return;
1722: }
1723:
1724: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1725: .nombre_arguments = 1;
1726: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1727: .fonction = instruction_expm;
1728:
1729: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1730: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
1731: {
1732: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1733: return;
1734: }
1735:
1736: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1737: .nom_fonction, "EXPM");
1738:
1739: if (((*l_element_courant).suivant =
1740: allocation_maillon(s_etat_processus)) == NULL)
1741: {
1742: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1743: return;
1744: }
1745:
1746: l_element_courant = (*l_element_courant).suivant;
1747:
1748: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1749: == NULL)
1750: {
1751: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1752: return;
1753: }
1754:
1755: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1756: .nombre_arguments = 0;
1757: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1758: .fonction = instruction_vers_niveau_inferieur;
1759:
1760: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1761: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1762: {
1763: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1764: return;
1765: }
1766:
1767: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1768: .nom_fonction, ">>");
1769:
1770: (*l_element_courant).suivant = NULL;
1771: s_objet_argument = NULL;
1772: }
1773:
1774: /*
1775: --------------------------------------------------------------------------------
1776: Exponentielle (-1) d'une expression
1777: --------------------------------------------------------------------------------
1778: */
1779:
1780: else if (((*s_objet_argument).type == ALG) ||
1781: ((*s_objet_argument).type == RPN))
1782: {
1783: if ((s_copie_argument = copie_objet(s_etat_processus,
1784: s_objet_argument, 'N')) == NULL)
1785: {
1786: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1787: return;
1788: }
1789:
1790: l_element_courant = (struct_liste_chainee *)
1791: (*s_copie_argument).objet;
1792: l_element_precedent = l_element_courant;
1793:
1794: while((*l_element_courant).suivant != NULL)
1795: {
1796: l_element_precedent = l_element_courant;
1797: l_element_courant = (*l_element_courant).suivant;
1798: }
1799:
1800: if (((*l_element_precedent).suivant =
1801: allocation_maillon(s_etat_processus)) == NULL)
1802: {
1803: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1804: return;
1805: }
1806:
1807: if (((*(*l_element_precedent).suivant).donnee =
1808: allocation(s_etat_processus, FCT)) == NULL)
1809: {
1810: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1811: return;
1812: }
1813:
1814: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1815: .donnee).objet)).nombre_arguments = 1;
1816: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1817: .donnee).objet)).fonction = instruction_expm;
1818:
1819: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1820: .suivant).donnee).objet)).nom_fonction =
1821: malloc(5 * sizeof(unsigned char))) == NULL)
1822: {
1823: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1824: return;
1825: }
1826:
1827: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1828: .suivant).donnee).objet)).nom_fonction, "EXPM");
1829:
1830: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1831:
1832: s_objet_resultat = s_copie_argument;
1833: }
1834:
1835: /*
1836: --------------------------------------------------------------------------------
1837: Fonction exponentielle (-1) impossible à réaliser
1838: --------------------------------------------------------------------------------
1839: */
1840:
1841: else
1842: {
1843: liberation(s_etat_processus, s_objet_argument);
1844:
1845: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1846: return;
1847: }
1848:
1849: liberation(s_etat_processus, s_objet_argument);
1850:
1851: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1852: s_objet_resultat) == d_erreur)
1853: {
1854: return;
1855: }
1856:
1857: return;
1858: }
1859:
1860: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_e1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src