![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_t1.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_t1.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.55 ! bertrand 3: RPL/2 (R) version 4.1.20
1.54 bertrand 4: Copyright (C) 1989-2015 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.15 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'type'
29: ================================================================================
30: Entrées : structure processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_type(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet_argument;
42: struct_objet *s_objet_resultat;
43:
44: (*s_etat_processus).erreur_execution = d_ex;
45:
46: if ((*s_etat_processus).affichage_arguments == 'Y')
47: {
48: printf("\n TYPE ");
49:
50: if ((*s_etat_processus).langue == 'F')
51: {
52: printf("(type d'objet)\n\n");
53: }
54: else
55: {
56: printf("(object type)\n\n");
57: }
58:
59: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
60: " %s, %s, %s, %s, %s,\n"
61: " %s, %s, %s, %s, %s,\n"
1.47 bertrand 62: " %s, %s, %s, %s,\n"
63: " %s, %s, %s\n",
1.1 bertrand 64: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
65: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB, d_SCK,
1.47 bertrand 66: d_PRC, d_TAB, d_SQL, d_MTX, d_SPH);
1.13 bertrand 67: printf("-> 1: %s\n\n", d_INT);
68:
69: if ((*s_etat_processus).langue == 'F')
70: {
71: printf(" Valeurs renvoyées : \n\n");
72: printf(" 0 : scalaire (entier ou réel)\n");
73: printf(" 1 : complexe\n");
74: printf(" 2 : chaîne de caractères\n");
75: printf(" 3 : vecteur ou matrice de scalaires\n");
76: printf(" 4 : vecteur ou matrice de complexes\n");
77: printf(" 5 : liste\n");
78: printf(" 6 : adresse\n");
79: printf(" 7 : nom\n");
80: printf(" 8 : expression en notation polonaire inversée\n");
81: printf(" 9 : expression algébrique\n");
82: printf(" 10 : entier binaire\n");
83: printf(" 11 : descripteur de fichier\n");
84: printf(" 12 : descripteur de bibliothèque partagée\n");
85: printf(" 13 : descripteur de socket\n");
86: printf(" 14 : processus\n");
87: printf(" 15 : fonction\n");
88: printf(" 16 : table\n");
1.47 bertrand 89: printf(" 17 : connecteur SQL\n");
90: printf(" 18 : mutex\n");
91: printf(" 19 : sémaphore\n");
1.13 bertrand 92: }
93: else
94: {
95: printf(" Returned values : \n\n");
96: printf(" 0 : scalar, integer or real number\n");
97: printf(" 1 : complex\n");
98: printf(" 2 : string\n");
99: printf(" 3 : scalar vector or scalar matrix\n");
100: printf(" 4 : complex vector or complex matrix\n");
101: printf(" 5 : list\n");
102: printf(" 6 : address\n");
103: printf(" 7 : name\n");
104: printf(" 8 : RPN expression\n");
105: printf(" 9 : algebraic expression\n");
106: printf(" 10 : binary integer\n");
107: printf(" 11 : file descriptor\n");
108: printf(" 12 : shared library descriptor\n");
109: printf(" 13 : socket descriptor\n");
110: printf(" 14 : process\n");
111: printf(" 15 : function\n");
112: printf(" 16 : table\n");
1.47 bertrand 113: printf(" 17 : SQL connector\n");
114: printf(" 18 : mutex\n");
115: printf(" 19 : semaphore\n");
1.13 bertrand 116: }
1.1 bertrand 117:
118: return;
119: }
120: else if ((*s_etat_processus).test_instruction == 'Y')
121: {
122: (*s_etat_processus).nombre_arguments = -1;
123: return;
124: }
125:
126: if (test_cfsf(s_etat_processus, 31) == d_vrai)
127: {
128: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
129: {
130: return;
131: }
132: }
133:
134: if (depilement(s_etat_processus, &((*s_etat_processus)
135: .l_base_pile), &s_objet_argument) == d_erreur)
136: {
137: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
138: return;
139: }
140:
141: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
142: {
143: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
144: return;
145: }
146:
147: if (((*s_objet_argument).type == INT) ||
148: ((*s_objet_argument).type == REL))
149: {
150: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
151: }
152: else if ((*s_objet_argument).type == CPL)
153: {
154: (*((integer8 *) (*s_objet_resultat).objet)) = 1;
155: }
156: else if ((*s_objet_argument).type == CHN)
157: {
158: (*((integer8 *) (*s_objet_resultat).objet)) = 2;
159: }
160: else if (((*s_objet_argument).type == VIN) ||
161: ((*s_objet_argument).type == VRL) ||
162: ((*s_objet_argument).type == MIN) ||
163: ((*s_objet_argument).type == MRL))
164: {
165: (*((integer8 *) (*s_objet_resultat).objet)) = 3;
166: }
167: else if (((*s_objet_argument).type == VCX) ||
168: ((*s_objet_argument).type == MCX))
169: {
170: (*((integer8 *) (*s_objet_resultat).objet)) = 4;
171: }
172: else if ((*s_objet_argument).type == LST)
173: {
174: (*((integer8 *) (*s_objet_resultat).objet)) = 5;
175: }
176: else if ((*s_objet_argument).type == ADR)
177: {
178: (*((integer8 *) (*s_objet_resultat).objet)) = 6;
179: }
180: else if ((*s_objet_argument).type == NOM)
181: {
182: (*((integer8 *) (*s_objet_resultat).objet)) = 7;
183: }
184: else if ((*s_objet_argument).type == RPN)
185: {
186: (*((integer8 *) (*s_objet_resultat).objet)) = 8;
187: }
188: else if ((*s_objet_argument).type == ALG)
189: {
190: (*((integer8 *) (*s_objet_resultat).objet)) = 9;
191: }
192: else if ((*s_objet_argument).type == BIN)
193: {
194: (*((integer8 *) (*s_objet_resultat).objet)) = 10;
195: }
196: else if ((*s_objet_argument).type == FCH)
197: {
198: (*((integer8 *) (*s_objet_resultat).objet)) = 11;
199: }
200: else if ((*s_objet_argument).type == SLB)
201: {
202: (*((integer8 *) (*s_objet_resultat).objet)) = 12;
203: }
204: else if ((*s_objet_argument).type == SCK)
205: {
206: (*((integer8 *) (*s_objet_resultat).objet)) = 13;
207: }
208: else if ((*s_objet_argument).type == PRC)
209: {
210: (*((integer8 *) (*s_objet_resultat).objet)) = 14;
211: }
212: else if ((*s_objet_argument).type == FCT)
213: {
214: (*((integer8 *) (*s_objet_resultat).objet)) = 15;
215: }
216: else if ((*s_objet_argument).type == TBL)
217: {
218: (*((integer8 *) (*s_objet_resultat).objet)) = 16;
219: }
1.47 bertrand 220: else if ((*s_objet_argument).type == SQL)
221: {
222: (*((integer8 *) (*s_objet_resultat).objet)) = 17;
223: }
224: else if ((*s_objet_argument).type == MTX)
225: {
226: (*((integer8 *) (*s_objet_resultat).objet)) = 18;
227: }
228: else if ((*s_objet_argument).type == SPH)
229: {
230: (*((integer8 *) (*s_objet_resultat).objet)) = 19;
231: }
1.1 bertrand 232: else
233: {
234: /*
235: * Les autres types de données sont des types internes
236: */
237:
238: liberation(s_etat_processus, s_objet_argument);
239:
240: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
241: return;
242: }
243:
244: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
245: s_objet_resultat) == d_erreur)
246: {
247: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
248: return;
249: }
250:
251: liberation(s_etat_processus, s_objet_argument);
252:
253: return;
254: }
255:
256:
257: /*
258: ================================================================================
259: Fonction 'then'
260: ================================================================================
261: Entrées : structure processus
262: --------------------------------------------------------------------------------
263: Sorties :
264: --------------------------------------------------------------------------------
265: Effets de bord : néant
266: ================================================================================
267: */
268:
269: void
270: instruction_then(struct_processus *s_etat_processus)
271: {
272: logical1 condition;
273: logical1 drapeau_fin;
274: logical1 execution;
275:
276: struct_liste_chainee *s_registre;
277:
1.10 bertrand 278: struct_liste_pile_systeme *l_element_courant;
279:
1.1 bertrand 280: struct_objet *s_objet;
281:
282: unsigned char *instruction_majuscule;
283: unsigned char *tampon;
284:
1.45 bertrand 285: integer8 niveau;
1.1 bertrand 286:
287: void (*fonction)();
288:
289: (*s_etat_processus).erreur_execution = d_ex;
290:
291: if ((*s_etat_processus).affichage_arguments == 'Y')
292: {
293: printf("\n THEN ");
294:
295: if ((*s_etat_processus).langue == 'F')
296: {
297: printf("(structure de contrôle)\n\n");
298: printf(" Utilisation :\n\n");
299: }
300: else
301: {
302: printf("(control statement)\n\n");
303: printf(" Usage:\n\n");
304: }
305:
306: printf(" IF(ERR)\n");
307: printf(" (expression test 1)\n");
308: printf(" THEN\n");
309: printf(" (expression 1)\n");
310: printf(" [ELSEIF\n");
311: printf(" (expression test 2)\n");
312: printf(" THEN\n");
313: printf(" (expression 2)]\n");
314: printf(" ...\n");
315: printf(" [ELSE\n");
316: printf(" (expression n)]\n");
317: printf(" END\n\n");
318:
319: printf(" SELECT (expression test)\n");
320: printf(" CASE (clause 1) THEN (expression 1) END\n");
321: printf(" CASE (clause 2) THEN (expression 2) END\n");
322: printf(" ...\n");
323: printf(" CASE (clause n) THEN (expression n) END\n");
324: printf(" DEFAULT\n");
325: printf(" (expression)\n");
326: printf(" END\n\n");
327:
328: printf(" SELECT (expression test)\n");
329: printf(" CASE (clause 1) THEN (expression 1) END\n");
330: printf(" (expression)\n");
331: printf(" CASE (clause 2) THEN (expression 2) END\n");
332: printf(" END\n");
333:
334: return;
335: }
336: else if ((*s_etat_processus).test_instruction == 'Y')
337: {
338: (*s_etat_processus).nombre_arguments = -1;
339: return;
340: }
341:
342: if (((*(*s_etat_processus).l_base_pile_systeme).clause != 'I') &&
343: ((*(*s_etat_processus).l_base_pile_systeme).clause != 'T') &&
344: ((*(*s_etat_processus).l_base_pile_systeme).clause != 'R') &&
345: ((*(*s_etat_processus).l_base_pile_systeme).clause != 'X') &&
346: ((*(*s_etat_processus).l_base_pile_systeme).clause != 'C') &&
347: ((*(*s_etat_processus).l_base_pile_systeme).clause != 'K'))
348: {
349: (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_condition;
350: return;
351: }
352:
353: /*
354: * Traitement des erreurs
355: */
356:
357: if (((*(*s_etat_processus).l_base_pile_systeme).clause == 'R') ||
358: ((*(*s_etat_processus).l_base_pile_systeme).clause == 'X'))
359: {
360: if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
361: {
362: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
363: return;
364: }
365:
366: if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'R')
367: {
368:
369: /*
370: * Erreur à traiter : on saute jusques au ELSE ou au END
371: * correspondant.
372: */
373:
374: (*((integer8 *) (*s_objet).objet)) = 0;
375: }
376: else
377: {
378: (*((integer8 *) (*s_objet).objet)) = -1;
379: }
380:
381: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
382: s_objet) == d_erreur)
383: {
384: return;
385: }
386:
387: (*s_etat_processus).arret_si_exception = (*(*s_etat_processus)
388: .l_base_pile_systeme).arret_si_exception;
389: }
390:
391: /*
392: * Traitement standard de l'instruction 'THEN'
393: */
394:
395: if (test_cfsf(s_etat_processus, 31) == d_vrai)
396: {
397: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
398: {
399: return;
400: }
401: }
402:
403: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
404: &s_objet) == d_erreur)
405: {
406: return;
407: }
408:
1.12 bertrand 409: if (((*s_objet).type == INT) || ((*s_objet).type == REL))
1.1 bertrand 410: {
411: if ((*s_objet).type == INT)
412: {
413: condition = ((*((integer8 *) (*s_objet).objet)) == 0)
414: ? d_faux : d_vrai;
415: }
416: else
417: {
418: condition = ((*((real8 *) (*s_objet).objet)) == 0)
419: ? d_faux : d_vrai;
420: }
421:
422: if (condition == d_vrai)
423: {
424:
425: /*
426: * condition == d_vrai : exécution de ce qui se trouve entre
427: * THEN et ELSE ou END.
428: */
429:
1.11 bertrand 430: if (((*(*s_etat_processus).l_base_pile_systeme).clause ==
431: 'I') || ((*(*s_etat_processus).l_base_pile_systeme).clause
1.12 bertrand 432: == 'X'))
1.1 bertrand 433: {
434: (*(*s_etat_processus).l_base_pile_systeme).clause = 'T';
435: }
436: else
437: {
1.10 bertrand 438: if ((*s_etat_processus).l_base_pile_systeme == NULL)
439: {
440: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
441: return;
442: }
443:
444: l_element_courant = (*(*s_etat_processus).l_base_pile_systeme)
445: .suivant;
446:
447: while(l_element_courant != NULL)
448: {
449: if ((*l_element_courant).clause == 'K')
450: {
451: (*l_element_courant).clause = 'Q';
452: break;
453: }
454:
455: l_element_courant = (*l_element_courant).suivant;
456: }
1.1 bertrand 457: }
458: }
459: else
460: {
461: /*
462: * condition == d_faux : saut à END ou exécution de ce qui se
463: * trouve entre ELSE et END
464: */
465:
466: if ((*(*s_etat_processus).l_base_pile_systeme).clause != 'T')
467: {
468: /*
469: * Traitement de ELSEIF
470: */
471:
472: if (((*(*s_etat_processus).l_base_pile_systeme).clause !=
473: 'K') && ((*(*s_etat_processus).l_base_pile_systeme)
474: .clause != 'C'))
475: {
476: (*(*s_etat_processus).l_base_pile_systeme).clause = 'E';
477: }
478: }
479:
480: niveau = 0;
481: drapeau_fin = d_faux;
482:
483: if ((*s_etat_processus).mode_execution_programme == 'Y')
484: {
485: tampon = (*s_etat_processus).instruction_courante;
486:
487: do
488: {
489: if (recherche_instruction_suivante(s_etat_processus)
490: == d_erreur)
491: {
492: liberation(s_etat_processus, s_objet);
493:
494: if ((*s_etat_processus).instruction_courante != NULL)
495: {
496: free((*s_etat_processus).instruction_courante);
497: }
498:
499: (*s_etat_processus).instruction_courante = tampon;
500: (*s_etat_processus).erreur_execution =
501: d_ex_erreur_traitement_condition;
502: return;
503: }
504:
505: if ((instruction_majuscule = conversion_majuscule(
506: (*s_etat_processus).instruction_courante)) == NULL)
507: {
508: liberation(s_etat_processus, s_objet);
509:
510: free((*s_etat_processus).instruction_courante);
511: (*s_etat_processus).instruction_courante = tampon;
512: (*s_etat_processus).erreur_systeme =
513: d_es_allocation_memoire;
514: return;
515: }
516:
517: if (niveau == 0)
518: {
519: if (((*(*s_etat_processus).l_base_pile_systeme)
520: .clause != 'K') && ((*(*s_etat_processus)
521: .l_base_pile_systeme) .clause != 'C'))
522: {
523:
524: /*
525: * Traitement de IF/THEN/ELSEIF/THEN/ELSE/END
526: */
527:
528: if ((strcmp(instruction_majuscule, "END") == 0) ||
529: (strcmp(instruction_majuscule, "ELSE")
530: == 0) || (strcmp(instruction_majuscule,
531: "ELSEIF") == 0))
532: {
533: (*s_etat_processus).position_courante
1.45 bertrand 534: -= (integer8) (strlen(
535: instruction_majuscule) + 1);
1.1 bertrand 536: drapeau_fin = d_vrai;
537: }
538: else
539: {
540: drapeau_fin = d_faux;
541: }
542: }
543: else
544: {
545: /*
546: * Traitement de CASE/THEN/END
547: */
548:
549: if (strcmp(instruction_majuscule, "ELSE") == 0)
550: {
551: liberation(s_etat_processus, s_objet);
552:
553: free((*s_etat_processus).instruction_courante);
554: free(instruction_majuscule);
555:
556: (*s_etat_processus).instruction_courante =
557: tampon;
558: (*s_etat_processus).erreur_execution =
559: d_ex_erreur_traitement_condition;
560: return;
561: }
562: else if (strcmp(instruction_majuscule, "END") == 0)
563: {
1.10 bertrand 564: instruction_end(s_etat_processus);
1.1 bertrand 565: drapeau_fin = d_vrai;
566: }
567: else
568: {
569: drapeau_fin = d_faux;
570: }
571: }
572: }
573: else
574: {
575: drapeau_fin = d_faux;
576: }
577:
578: if ((strcmp(instruction_majuscule, "CASE") == 0) ||
579: (strcmp(instruction_majuscule, "DO") == 0) ||
580: (strcmp(instruction_majuscule, "IF") == 0) ||
581: (strcmp(instruction_majuscule, "IFERR") == 0) ||
582: (strcmp(instruction_majuscule, "SELECT") == 0) ||
583: (strcmp(instruction_majuscule, "WHILE") == 0))
584: {
585: niveau++;
586: }
587: else if (strcmp(instruction_majuscule, "END") == 0)
588: {
589: niveau--;
590: }
591:
592: free(instruction_majuscule);
593: free((*s_etat_processus).instruction_courante);
594: } while(drapeau_fin == d_faux);
595:
596: (*s_etat_processus).instruction_courante = tampon;
597: }
598: else
599: {
600: /*
601: * Vérification du pointeur de prédiction de saut.
602: */
603:
604: if (pthread_mutex_lock(&((*(*(*s_etat_processus)
605: .expression_courante).donnee).mutex)) != 0)
606: {
607: (*s_etat_processus).erreur_systeme = d_es_processus;
608: return;
609: }
610:
611: if ((*((struct_fonction *) (*(*(*s_etat_processus)
612: .expression_courante).donnee).objet)).prediction_saut
613: != NULL)
614: {
615: s_registre = (*s_etat_processus).expression_courante;
616:
617: (*s_etat_processus).expression_courante =
618: (struct_liste_chainee *)
619: (*((struct_fonction *) (*(*(*s_etat_processus)
620: .expression_courante).donnee).objet))
621: .prediction_saut;
622: fonction = (*((struct_fonction *)
623: (*(*(*s_etat_processus).expression_courante)
624: .donnee).objet)).fonction;
625: execution = (*((struct_fonction *)
626: (*(*s_registre).donnee).objet))
627: .prediction_execution;
628:
629: if (pthread_mutex_unlock(&((*(*s_registre).donnee).mutex))
630: != 0)
631: {
632: (*s_etat_processus).erreur_systeme = d_es_processus;
633: return;
634: }
635:
636: if (execution == d_vrai)
637: {
638: fonction(s_etat_processus);
639: }
640: }
641: else
642: {
643: if (pthread_mutex_unlock(&((*(*(*s_etat_processus)
644: .expression_courante).donnee).mutex)) != 0)
645: {
646: (*s_etat_processus).erreur_systeme = d_es_processus;
647: return;
648: }
649:
650: s_registre = (*s_etat_processus).expression_courante;
651: execution = d_faux;
652:
653: do
654: {
655: if (((*s_etat_processus).expression_courante =
656: (*(*s_etat_processus).expression_courante)
657: .suivant) == NULL)
658: {
659: liberation(s_etat_processus, s_objet);
660: (*s_etat_processus).erreur_execution =
661: d_ex_erreur_traitement_condition;
662: return;
663: }
664:
665: if ((*(*(*s_etat_processus).expression_courante)
666: .donnee).type == FCT)
667: {
668: fonction = (*((struct_fonction *)
669: (*(*(*s_etat_processus).expression_courante)
670: .donnee).objet)).fonction;
671:
672: if (niveau == 0)
673: {
674: if (((*(*s_etat_processus).l_base_pile_systeme)
675: .clause != 'K') &&
676: ((*(*s_etat_processus)
1.10 bertrand 677: .l_base_pile_systeme).clause != 'C'))
1.1 bertrand 678: {
679: /*
680: * Traitement de IF/THEN/ELSEIF/THEN/
681: * ELSE/END
682: */
683:
684: if ((fonction == instruction_end) ||
685: (fonction == instruction_else) ||
686: (fonction == instruction_elseif))
687: {
688: fonction(s_etat_processus);
689: execution = d_vrai;
690: drapeau_fin = d_vrai;
691: }
692: else
693: {
694: drapeau_fin = d_faux;
695: }
696: }
697: else
698: {
699: /*
700: * Traitement de CASE/THEN/END
701: */
702:
703: if (fonction == instruction_else)
704: {
705: liberation(s_etat_processus, s_objet);
706:
707: if ((drapeau_fin == d_faux) &&
708: ((*s_etat_processus)
709: .expression_courante != NULL))
710: {
711: (*s_etat_processus)
712: .expression_courante
713: = (*(*s_etat_processus)
714: .expression_courante)
715: .suivant;
716: }
717:
718: (*s_etat_processus).erreur_execution =
719: d_ex_erreur_traitement_condition;
720: return;
721: }
722: else if (fonction == instruction_end)
723: {
1.10 bertrand 724: fonction(s_etat_processus);
725: execution = d_vrai;
1.1 bertrand 726: drapeau_fin = d_vrai;
727: }
728: else
729: {
730: drapeau_fin = d_faux;
731: }
732: }
733: }
734: else
735: {
736: drapeau_fin = d_faux;
737: }
738:
739: if ((fonction == instruction_case) ||
740: (fonction == instruction_do) ||
741: (fonction == instruction_if) ||
742: (fonction == instruction_iferr) ||
743: (fonction == instruction_select) ||
744: (fonction == instruction_while))
745: {
746: niveau++;
747: }
748: else if (fonction == instruction_end)
749: {
750: niveau--;
751: }
752: }
753: } while(drapeau_fin == d_faux);
754:
755: if (pthread_mutex_lock(&((*(*(*s_etat_processus)
756: .expression_courante).donnee).mutex)) != 0)
757: {
758: (*s_etat_processus).erreur_systeme = d_es_processus;
759: return;
760: }
761:
762: (*((struct_fonction *) (*(*s_registre).donnee).objet))
763: .prediction_saut = (*s_etat_processus)
764: .expression_courante;
765: (*((struct_fonction *) (*(*s_registre).donnee).objet))
766: .prediction_execution = execution;
767:
768: if (pthread_mutex_unlock(&((*(*(*s_etat_processus)
769: .expression_courante).donnee).mutex)) != 0)
770: {
771: (*s_etat_processus).erreur_systeme = d_es_processus;
772: return;
773: }
774: }
775: }
776: }
777: }
778: else
779: {
780: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
781: return;
782: }
783:
784: liberation(s_etat_processus, s_objet);
785: return;
786: }
787:
788:
789: /*
790: ================================================================================
791: Fonction 'tan'
792: ================================================================================
793: Entrées : pointeur sur une structure struct_processus
794: --------------------------------------------------------------------------------
795: Sorties :
796: --------------------------------------------------------------------------------
797: Effets de bord : néant
798: ================================================================================
799: */
800:
801: void
802: instruction_tan(struct_processus *s_etat_processus)
803: {
804: real8 angle;
805:
806: integer4 erreur;
807:
808: struct_liste_chainee *l_element_courant;
809: struct_liste_chainee *l_element_precedent;
810:
811: struct_objet *s_copie_argument;
812: struct_objet *s_objet_argument;
813: struct_objet *s_objet_resultat;
814:
815: (*s_etat_processus).erreur_execution = d_ex;
816:
817: if ((*s_etat_processus).affichage_arguments == 'Y')
818: {
819: printf("\n TAN ");
820:
821: if ((*s_etat_processus).langue == 'F')
822: {
823: printf("(tangente)\n\n");
824: }
825: else
826: {
827: printf("(tangent)\n\n");
828: }
829:
830: printf(" 1: %s, %s\n", d_INT, d_REL);
831: printf("-> 1: %s\n\n", d_REL);
832:
833: printf(" 1: %s\n", d_CPL);
834: printf("-> 1: %s\n\n", d_CPL);
835:
836: printf(" 1: %s, %s\n", d_NOM, d_ALG);
837: printf("-> 1: %s\n\n", d_ALG);
838:
839: printf(" 1: %s\n", d_RPN);
840: printf("-> 1: %s\n", d_RPN);
841:
842: return;
843: }
844: else if ((*s_etat_processus).test_instruction == 'Y')
845: {
846: (*s_etat_processus).nombre_arguments = 1;
847: return;
848: }
849:
850: if (test_cfsf(s_etat_processus, 31) == d_vrai)
851: {
852: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
853: {
854: return;
855: }
856: }
857:
858: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
859: &s_objet_argument) == d_erreur)
860: {
861: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
862: return;
863: }
864:
865: /*
866: --------------------------------------------------------------------------------
867: Tangente d'un entier ou d'un réel
868: --------------------------------------------------------------------------------
869: */
870:
871: if (((*s_objet_argument).type == INT) ||
872: ((*s_objet_argument).type == REL))
873: {
874: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
875: {
876: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
877: return;
878: }
879:
880: if ((*s_objet_argument).type == INT)
881: {
882: angle = (real8) (*((integer8 *) (*s_objet_argument).objet));
883: }
884: else
885: {
886: angle = (*((real8 *) (*s_objet_argument).objet));
887: }
888:
889: if (test_cfsf(s_etat_processus, 60) == d_faux)
890: {
891: conversion_degres_vers_radians(&angle);
892: }
893:
894: if ((cos(angle) == 0) && (test_cfsf(s_etat_processus, 59) == d_vrai))
895: {
896: liberation(s_etat_processus, s_objet_argument);
897: liberation(s_etat_processus, s_objet_resultat);
898:
899: (*s_etat_processus).exception = d_ep_division_par_zero;
900: return;
901: }
902:
903: (*((real8 *) (*s_objet_resultat).objet)) = tan(angle);
904: }
905:
906: /*
907: --------------------------------------------------------------------------------
908: Tangente d'un complexe
909: --------------------------------------------------------------------------------
910: */
911:
912: else if ((*s_objet_argument).type == CPL)
913: {
914: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL)
915: {
916: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
917: return;
918: }
919:
920: f77tan_((struct_complexe16 *) (*s_objet_argument).objet,
921: (struct_complexe16 *) (*s_objet_resultat).objet, &erreur);
922:
923: if (erreur != 0)
924: {
925: liberation(s_etat_processus, s_objet_argument);
926: liberation(s_etat_processus, s_objet_resultat);
927:
928: (*s_etat_processus).exception = d_ep_division_par_zero;
929: return;
930: }
931: }
932:
933: /*
934: --------------------------------------------------------------------------------
935: Tangente d'un nom
936: --------------------------------------------------------------------------------
937: */
938:
939: else if ((*s_objet_argument).type == NOM)
940: {
941: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
942: {
943: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
944: return;
945: }
946:
947: if (((*s_objet_resultat).objet =
948: allocation_maillon(s_etat_processus)) == NULL)
949: {
950: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
951: return;
952: }
953:
954: l_element_courant = (*s_objet_resultat).objet;
955:
956: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
957: == NULL)
958: {
959: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
960: return;
961: }
962:
963: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
964: .nombre_arguments = 0;
965: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
966: .fonction = instruction_vers_niveau_superieur;
967:
968: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
969: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
970: {
971: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
972: return;
973: }
974:
975: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
976: .nom_fonction, "<<");
977:
978: if (((*l_element_courant).suivant =
979: allocation_maillon(s_etat_processus)) == NULL)
980: {
981: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
982: return;
983: }
984:
985: l_element_courant = (*l_element_courant).suivant;
986: (*l_element_courant).donnee = s_objet_argument;
987:
988: if (((*l_element_courant).suivant =
989: allocation_maillon(s_etat_processus)) == NULL)
990: {
991: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
992: return;
993: }
994:
995: l_element_courant = (*l_element_courant).suivant;
996:
997: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
998: == NULL)
999: {
1000: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1001: return;
1002: }
1003:
1004: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1005: .nombre_arguments = 1;
1006: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1007: .fonction = instruction_tan;
1008:
1009: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1010: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
1011: {
1012: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1013: return;
1014: }
1015:
1016: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1017: .nom_fonction, "TAN");
1018:
1019: if (((*l_element_courant).suivant =
1020: allocation_maillon(s_etat_processus)) == NULL)
1021: {
1022: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1023: return;
1024: }
1025:
1026: l_element_courant = (*l_element_courant).suivant;
1027:
1028: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1029: == NULL)
1030: {
1031: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1032: return;
1033: }
1034:
1035: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1036: .nombre_arguments = 0;
1037: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1038: .fonction = instruction_vers_niveau_inferieur;
1039:
1040: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1041: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1042: {
1043: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1044: return;
1045: }
1046:
1047: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1048: .nom_fonction, ">>");
1049:
1050: (*l_element_courant).suivant = NULL;
1051: s_objet_argument = NULL;
1052: }
1053:
1054: /*
1055: --------------------------------------------------------------------------------
1056: Tangente d'une expression
1057: --------------------------------------------------------------------------------
1058: */
1059:
1060: else if (((*s_objet_argument).type == ALG) ||
1061: ((*s_objet_argument).type == RPN))
1062: {
1063: if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument,
1064: 'N')) == NULL)
1065: {
1066: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1067: return;
1068: }
1069:
1070: l_element_courant = (struct_liste_chainee *)
1071: (*s_copie_argument).objet;
1072: l_element_precedent = l_element_courant;
1073:
1074: while((*l_element_courant).suivant != NULL)
1075: {
1076: l_element_precedent = l_element_courant;
1077: l_element_courant = (*l_element_courant).suivant;
1078: }
1079:
1080: if (((*l_element_precedent).suivant =
1081: allocation_maillon(s_etat_processus)) == NULL)
1082: {
1083: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1084: return;
1085: }
1086:
1087: if (((*(*l_element_precedent).suivant).donnee =
1088: allocation(s_etat_processus, FCT)) == NULL)
1089: {
1090: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1091: return;
1092: }
1093:
1094: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1095: .donnee).objet)).nombre_arguments = 1;
1096: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1097: .donnee).objet)).fonction = instruction_tan;
1098:
1099: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1100: .suivant).donnee).objet)).nom_fonction =
1101: malloc(4 * sizeof(unsigned char))) == NULL)
1102: {
1103: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1104: return;
1105: }
1106:
1107: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1108: .suivant).donnee).objet)).nom_fonction, "TAN");
1109:
1110: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1111:
1112: s_objet_resultat = s_copie_argument;
1113: }
1114:
1115: /*
1116: --------------------------------------------------------------------------------
1117: Réalisation impossible de la fonction tangente
1118: --------------------------------------------------------------------------------
1119: */
1120:
1121: else
1122: {
1123: liberation(s_etat_processus, s_objet_argument);
1124:
1125: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1126: return;
1127: }
1128:
1129: liberation(s_etat_processus, s_objet_argument);
1130:
1131: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1132: s_objet_resultat) == d_erreur)
1133: {
1134: return;
1135: }
1136:
1137: return;
1138: }
1139:
1140:
1141: /*
1142: ================================================================================
1143: Fonction 'tanh'
1144: ================================================================================
1145: Entrées : pointeur sur une structure struct_processus
1146: --------------------------------------------------------------------------------
1147: Sorties :
1148: --------------------------------------------------------------------------------
1149: Effets de bord : néant
1150: ================================================================================
1151: */
1152:
1153: void
1154: instruction_tanh(struct_processus *s_etat_processus)
1155: {
1156: real8 argument;
1157:
1158: integer4 erreur;
1159:
1160: struct_liste_chainee *l_element_courant;
1161: struct_liste_chainee *l_element_precedent;
1162:
1163: struct_objet *s_copie_argument;
1164: struct_objet *s_objet_argument;
1165: struct_objet *s_objet_resultat;
1166:
1167: (*s_etat_processus).erreur_execution = d_ex;
1168:
1169: if ((*s_etat_processus).affichage_arguments == 'Y')
1170: {
1171: printf("\n TANH ");
1172:
1173: if ((*s_etat_processus).langue == 'F')
1174: {
1175: printf("(tangente hyperbolique)\n\n");
1176: }
1177: else
1178: {
1179: printf("(hyperbolic tangent)\n\n");
1180: }
1181:
1182: printf(" 1: %s, %s\n", d_INT, d_REL);
1183: printf("-> 1: %s\n\n", d_INT);
1184:
1185: printf(" 1: %s\n", d_CPL);
1186: printf("-> 1: %s\n\n", d_CPL);
1187:
1188: printf(" 1: %s, %s\n", d_NOM, d_ALG);
1189: printf("-> 1: %s\n\n", d_ALG);
1190:
1191: printf(" 1: %s\n", d_RPN);
1192: printf("-> 1: %s\n", d_RPN);
1193:
1194: return;
1195: }
1196: else if ((*s_etat_processus).test_instruction == 'Y')
1197: {
1198: (*s_etat_processus).nombre_arguments = 1;
1199: return;
1200: }
1201:
1202: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1203: {
1204: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1205: {
1206: return;
1207: }
1208: }
1209:
1210: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1211: &s_objet_argument) == d_erreur)
1212: {
1213: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1214: return;
1215: }
1216:
1217: /*
1218: --------------------------------------------------------------------------------
1219: Tangente hyperbolique d'un entier ou d'un réel
1220: --------------------------------------------------------------------------------
1221: */
1222:
1223: if (((*s_objet_argument).type == INT) ||
1224: ((*s_objet_argument).type == REL))
1225: {
1226: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
1227: {
1228: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1229: return;
1230: }
1231:
1232: if ((*s_objet_argument).type == INT)
1233: {
1234: argument = (real8) (*((integer8 *) (*s_objet_argument).objet));
1235: }
1236: else
1237: {
1238: argument = (*((real8 *) (*s_objet_argument).objet));
1239: }
1240:
1241: (*((real8 *) (*s_objet_resultat).objet)) = tanh(argument);
1242: }
1243:
1244: /*
1245: --------------------------------------------------------------------------------
1246: Tangente hyperbolique d'un complexe
1247: --------------------------------------------------------------------------------
1248: */
1249:
1250: else if ((*s_objet_argument).type == CPL)
1251: {
1252: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL)
1253: {
1254: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1255: return;
1256: }
1257:
1258: f77tanh_((struct_complexe16 *) (*s_objet_argument).objet,
1259: (struct_complexe16 *) (*s_objet_resultat).objet, &erreur);
1260:
1261: if (erreur != 0)
1262: {
1263: liberation(s_etat_processus, s_objet_argument);
1264: liberation(s_etat_processus, s_objet_resultat);
1265:
1266: (*s_etat_processus).exception = d_ep_division_par_zero;
1267: return;
1268: }
1269: }
1270:
1271: /*
1272: --------------------------------------------------------------------------------
1273: Tangente hyperbolique d'un nom
1274: --------------------------------------------------------------------------------
1275: */
1276:
1277: else if ((*s_objet_argument).type == NOM)
1278: {
1279: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
1280: {
1281: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1282: return;
1283: }
1284:
1285: if (((*s_objet_resultat).objet =
1286: allocation_maillon(s_etat_processus)) == NULL)
1287: {
1288: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1289: return;
1290: }
1291:
1292: l_element_courant = (*s_objet_resultat).objet;
1293:
1294: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1295: == NULL)
1296: {
1297: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1298: return;
1299: }
1300:
1301: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1302: .nombre_arguments = 0;
1303: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1304: .fonction = instruction_vers_niveau_superieur;
1305:
1306: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1307: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1308: {
1309: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1310: return;
1311: }
1312:
1313: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1314: .nom_fonction, "<<");
1315:
1316: if (((*l_element_courant).suivant =
1317: allocation_maillon(s_etat_processus)) == NULL)
1318: {
1319: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1320: return;
1321: }
1322:
1323: l_element_courant = (*l_element_courant).suivant;
1324: (*l_element_courant).donnee = s_objet_argument;
1325:
1326: if (((*l_element_courant).suivant =
1327: allocation_maillon(s_etat_processus)) == NULL)
1328: {
1329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1330: return;
1331: }
1332:
1333: l_element_courant = (*l_element_courant).suivant;
1334:
1335: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1336: == NULL)
1337: {
1338: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1339: return;
1340: }
1341:
1342: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1343: .nombre_arguments = 1;
1344: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1345: .fonction = instruction_tanh;
1346:
1347: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1348: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
1349: {
1350: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1351: return;
1352: }
1353:
1354: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1355: .nom_fonction, "TANH");
1356:
1357: if (((*l_element_courant).suivant =
1358: allocation_maillon(s_etat_processus)) == NULL)
1359: {
1360: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1361: return;
1362: }
1363:
1364: l_element_courant = (*l_element_courant).suivant;
1365:
1366: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1367: == NULL)
1368: {
1369: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1370: return;
1371: }
1372:
1373: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1374: .nombre_arguments = 0;
1375: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1376: .fonction = instruction_vers_niveau_inferieur;
1377:
1378: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1379: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1380: {
1381: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1382: return;
1383: }
1384:
1385: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1386: .nom_fonction, ">>");
1387:
1388: (*l_element_courant).suivant = NULL;
1389: s_objet_argument = NULL;
1390: }
1391:
1392: /*
1393: --------------------------------------------------------------------------------
1394: Tangente hyperbolique d'une expression
1395: --------------------------------------------------------------------------------
1396: */
1397:
1398: else if (((*s_objet_argument).type == ALG) ||
1399: ((*s_objet_argument).type == RPN))
1400: {
1401: if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument,
1402: 'N')) == NULL)
1403: {
1404: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1405: return;
1406: }
1407:
1408: l_element_courant = (struct_liste_chainee *)
1409: (*s_copie_argument).objet;
1410: l_element_precedent = l_element_courant;
1411:
1412: while((*l_element_courant).suivant != NULL)
1413: {
1414: l_element_precedent = l_element_courant;
1415: l_element_courant = (*l_element_courant).suivant;
1416: }
1417:
1418: if (((*l_element_precedent).suivant =
1419: allocation_maillon(s_etat_processus)) == NULL)
1420: {
1421: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1422: return;
1423: }
1424:
1425: if (((*(*l_element_precedent).suivant).donnee =
1426: allocation(s_etat_processus, FCT)) == NULL)
1427: {
1428: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1429: return;
1430: }
1431:
1432: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1433: .donnee).objet)).nombre_arguments = 1;
1434: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1435: .donnee).objet)).fonction = instruction_tanh;
1436:
1437: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1438: .suivant).donnee).objet)).nom_fonction =
1439: malloc(5 * sizeof(unsigned char))) == NULL)
1440: {
1441: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1442: return;
1443: }
1444:
1445: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1446: .suivant).donnee).objet)).nom_fonction, "TANH");
1447:
1448: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1449:
1450: s_objet_resultat = s_copie_argument;
1451: }
1452:
1453: /*
1454: --------------------------------------------------------------------------------
1455: Réalisation impossible de la fonction tangente hyperbolique
1456: --------------------------------------------------------------------------------
1457: */
1458:
1459: else
1460: {
1461: liberation(s_etat_processus, s_objet_argument);
1462:
1463: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1464: return;
1465: }
1466:
1467: liberation(s_etat_processus, s_objet_argument);
1468:
1469: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1470: s_objet_resultat) == d_erreur)
1471: {
1472: return;
1473: }
1474:
1475: return;
1476: }
1477:
1478:
1479: /*
1480: ================================================================================
1481: Fonction 'true'
1482: ================================================================================
1483: Entrées : structure processus
1484: --------------------------------------------------------------------------------
1485: Sorties :
1486: --------------------------------------------------------------------------------
1487: Effets de bord : néant
1488: ================================================================================
1489: */
1490:
1491: void
1492: instruction_true(struct_processus *s_etat_processus)
1493: {
1494: struct_objet *s_objet;
1495:
1496: if ((*s_etat_processus).affichage_arguments == 'Y')
1497: {
1498: printf("\n TRUE ");
1499:
1500: if ((*s_etat_processus).langue == 'F')
1501: {
1502: printf("(valeur vraie)\n\n");
1503: }
1504: else
1505: {
1506: printf("(true value)\n\n");
1507: }
1508:
1509: printf("-> 1: %s\n", d_INT);
1510:
1511: return;
1512: }
1513: else if ((*s_etat_processus).test_instruction == 'Y')
1514: {
1515: (*s_etat_processus).nombre_arguments = -1;
1516: return;
1517: }
1518:
1519: if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
1520: {
1521: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1522: return;
1523: }
1524:
1525: (*((integer8 *) (*s_objet).objet)) = -1;
1526:
1527: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1528: s_objet) == d_erreur)
1529: {
1530: return;
1531: }
1532:
1533: return;
1534: }
1535:
1536: // vim: ts=4