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