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