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