Annotation of rpl/src/instructions_a1.c, revision 1.33
1.1 bertrand 1: /*
2: ================================================================================
1.33 ! bertrand 3: RPL/2 (R) version 4.1.6
1.32 bertrand 4: Copyright (C) 1989-2012 Dr. BERTRAND Joël
1.1 bertrand 5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
1.11 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'abort'
29: ================================================================================
30: Entrées : pointeur sur une structure struct_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_abort(struct_processus *s_etat_processus)
40: {
41: struct timespec attente;
42:
43: (*s_etat_processus).erreur_execution = d_ex;
44:
45: if ((*s_etat_processus).affichage_arguments == 'Y')
46: {
47: printf("\n ABORT ");
48:
49: if ((*s_etat_processus).langue == 'F')
50: {
51: printf("(abandon du programme)\n\n");
52: printf(" Aucun argument\n");
53: }
54: else
55: {
56: printf("(program abort)\n\n");
57: printf(" No argument\n");
58: }
59:
60: return;
61: }
62: else if ((*s_etat_processus).test_instruction == 'Y')
63: {
64: (*s_etat_processus).nombre_arguments = -1;
65: return;
66: }
67:
68: if (test_cfsf(s_etat_processus, 31) == d_vrai)
69: {
70: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
71: {
72: return;
73: }
74: }
75:
1.28 bertrand 76: envoi_signal_processus((*s_etat_processus).pid_processus_pere,
77: rpl_sigabort);
1.1 bertrand 78: (*s_etat_processus).requete_arret = 'Y';
79:
80: attente.tv_sec = 0;
81: attente.tv_nsec = GRANULARITE_us * 1000;
82:
83: while((*s_etat_processus).var_volatile_requete_arret == 0)
84: {
1.29 bertrand 85: scrutation_interruptions(s_etat_processus);
1.1 bertrand 86: nanosleep(&attente, NULL);
87: INCR_GRANULARITE(attente.tv_nsec);
88: }
89:
90: if ((*s_etat_processus).traitement_instruction_halt == d_vrai)
91: {
92: (*s_etat_processus).execution_pas_suivant = d_vrai;
93: }
94:
95: return;
96: }
97:
98:
99: /*
100: ================================================================================
101: Fonction 'and'
102: ================================================================================
103: Entrées : pointeur sur une structure struct_processus
104: --------------------------------------------------------------------------------
105: Sorties :
106: --------------------------------------------------------------------------------
107: Effets de bord : néant
108: ================================================================================
109: */
110:
111: void
112: instruction_and(struct_processus *s_etat_processus)
113: {
114: struct_liste_chainee *l_element_courant;
115: struct_liste_chainee *l_element_precedent;
116:
117: struct_objet *s_copie_argument_1;
118: struct_objet *s_copie_argument_2;
119: struct_objet *s_objet_argument_1;
120: struct_objet *s_objet_argument_2;
121: struct_objet *s_objet_resultat;
122:
123: unsigned long nombre_elements;
124:
125: (*s_etat_processus).erreur_execution = d_ex;
126:
127: if ((*s_etat_processus).affichage_arguments == 'Y')
128: {
129: printf("\n AND ");
130:
131: if ((*s_etat_processus).langue == 'F')
132: {
133: printf("(opérateur et)\n\n");
134: }
135: else
136: {
137: printf("(and operator)\n\n");
138: }
139:
140: printf(" 2: %s, %s\n", d_INT, d_REL);
141: printf(" 1: %s, %s\n", d_INT, d_REL);
142: printf("-> 1: %s\n\n", d_INT);
143:
144: printf(" 2: %s\n", d_BIN);
145: printf(" 1: %s\n", d_BIN);
146: printf("-> 1: %s\n\n", d_BIN);
147:
148: printf(" 2: %s\n", d_NOM);
149: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
150: printf("-> 1: %s\n\n", d_ALG);
151:
152: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL);
153: printf(" 1: %s\n", d_NOM);
154: printf("-> 1: %s\n\n", d_ALG);
155:
156: printf(" 2: %s\n", d_ALG);
157: printf(" 1: %s\n", d_ALG);
158: printf("-> 1: %s\n\n", d_ALG);
159:
160: printf(" 2: %s\n", d_RPN);
161: printf(" 1: %s\n", d_RPN);
162: printf("-> 1: %s\n", d_RPN);
163:
164: return;
165: }
166: else if ((*s_etat_processus).test_instruction == 'Y')
167: {
168: (*s_etat_processus).nombre_arguments = 0;
169: return;
170: }
171:
172: if (test_cfsf(s_etat_processus, 31) == d_vrai)
173: {
174: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
175: {
176: return;
177: }
178: }
179:
180: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
181: &s_objet_argument_1) == d_erreur)
182: {
183: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
184: return;
185: }
186:
187: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
188: &s_objet_argument_2) == d_erreur)
189: {
190: liberation(s_etat_processus, s_objet_argument_1);
191:
192: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
193: return;
194: }
195:
196: /*
197: --------------------------------------------------------------------------------
198: AND logique
199: --------------------------------------------------------------------------------
200: */
201:
202: if (((((*s_objet_argument_1).type == INT) ||
203: ((*s_objet_argument_1).type == REL)) &&
204: (((*s_objet_argument_2).type == INT) ||
205: ((*s_objet_argument_2).type == REL))))
206: {
207: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
208: {
209: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
210: return;
211: }
212:
213: if ((*s_objet_argument_1).type == INT)
214: {
215: if ((*s_objet_argument_2).type == INT)
216: {
217: if (((*((integer8 *) (*s_objet_argument_1).objet)) != 0) &&
218: ((*((integer8 *) (*s_objet_argument_2).objet)) != 0))
219: {
220: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
221: }
222: else
223: {
224: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
225: }
226: }
227: else
228: {
229: if (((*((integer8 *) (*s_objet_argument_1).objet)) != 0) &&
230: ((*((real8 *) (*s_objet_argument_2).objet)) != 0))
231: {
232: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
233: }
234: else
235: {
236: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
237: }
238: }
239: }
240: else
241: {
242: if ((*s_objet_argument_2).type == INT)
243: {
244: if (((*((real8 *) (*s_objet_argument_1).objet)) != 0) &&
245: ((*((integer8 *) (*s_objet_argument_2).objet)) != 0))
246: {
247: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
248: }
249: else
250: {
251: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
252: }
253: }
254: else
255: {
256: if (((*((real8 *) (*s_objet_argument_1).objet)) != 0) &&
257: ((*((real8 *) (*s_objet_argument_2).objet)) != 0))
258: {
259: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
260: }
261: else
262: {
263: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
264: }
265: }
266: }
267: }
268:
269: /*
270: --------------------------------------------------------------------------------
271: AND binaire
272: --------------------------------------------------------------------------------
273: */
274:
275: else if (((*s_objet_argument_1).type == BIN) &&
276: ((*s_objet_argument_2).type == BIN))
277: {
278: if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
279: {
280: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
281: return;
282: }
283:
284: (*((logical8 *) (*s_objet_resultat).objet)) =
285: (*((logical8 *) (*s_objet_argument_1).objet)) &
286: (*((logical8 *) (*s_objet_argument_2).objet));
287: }
288:
289: /*
290: --------------------------------------------------------------------------------
291: AND entre des arguments complexes
292: --------------------------------------------------------------------------------
293: */
294:
295: /*
296: * Nom ou valeur numérique / Nom ou valeur numérique
297: */
298:
299: else if ((((*s_objet_argument_1).type == NOM) &&
300: (((*s_objet_argument_2).type == NOM) ||
301: ((*s_objet_argument_2).type == INT) ||
302: ((*s_objet_argument_2).type == REL))) ||
303: (((*s_objet_argument_2).type == NOM) &&
304: (((*s_objet_argument_1).type == INT) ||
305: ((*s_objet_argument_1).type == REL))))
306: {
307: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
308: {
309: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
310: return;
311: }
312:
313: if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus))
314: == NULL)
315: {
316: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
317: return;
318: }
319:
320: l_element_courant = (*s_objet_resultat).objet;
321:
322: if (((*l_element_courant).donnee =
323: allocation(s_etat_processus, FCT)) == NULL)
324: {
325: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
326: return;
327: }
328:
329: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
330: .nombre_arguments = 0;
331: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
332: .fonction = instruction_vers_niveau_superieur;
333:
334: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
335: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
336: {
337: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
338: return;
339: }
340:
341: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
342: .nom_fonction, "<<");
343:
344: if (((*l_element_courant).suivant =
345: allocation_maillon(s_etat_processus)) == NULL)
346: {
347: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
348: return;
349: }
350:
351: l_element_courant = (*l_element_courant).suivant;
352: (*l_element_courant).donnee = s_objet_argument_2;
353:
354: if (((*l_element_courant).suivant =
355: allocation_maillon(s_etat_processus)) == NULL)
356: {
357: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
358: return;
359: }
360:
361: l_element_courant = (*l_element_courant).suivant;
362: (*l_element_courant).donnee = s_objet_argument_1;
363:
364: if (((*l_element_courant).suivant =
365: allocation_maillon(s_etat_processus)) == NULL)
366: {
367: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
368: return;
369: }
370:
371: l_element_courant = (*l_element_courant).suivant;
372:
373: if (((*l_element_courant).donnee =
374: allocation(s_etat_processus, FCT)) == NULL)
375: {
376: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
377: return;
378: }
379:
380: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
381: .nombre_arguments = 0;
382: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
383: .fonction = instruction_and;
384:
385: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
386: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
387: {
388: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
389: return;
390: }
391:
392: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
393: .nom_fonction, "AND");
394:
395: if (((*l_element_courant).suivant =
396: allocation_maillon(s_etat_processus)) == NULL)
397: {
398: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
399: return;
400: }
401:
402: l_element_courant = (*l_element_courant).suivant;
403:
404: if (((*l_element_courant).donnee =
405: allocation(s_etat_processus, FCT)) == NULL)
406: {
407: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
408: return;
409: }
410:
411: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
412: .nombre_arguments = 0;
413: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
414: .fonction = instruction_vers_niveau_inferieur;
415:
416: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
417: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
418: {
419: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
420: return;
421: }
422:
423: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
424: .nom_fonction, ">>");
425:
426: (*l_element_courant).suivant = NULL;
427:
428: s_objet_argument_1 = NULL;
429: s_objet_argument_2 = NULL;
430: }
431:
432: /*
433: * Nom ou valeur numérique / Expression
434: */
435:
436: else if ((((*s_objet_argument_1).type == ALG) ||
437: ((*s_objet_argument_1).type == RPN)) &&
438: (((*s_objet_argument_2).type == NOM) ||
439: ((*s_objet_argument_2).type == INT) ||
440: ((*s_objet_argument_2).type == REL)))
441: {
442: nombre_elements = 0;
443: l_element_courant = (struct_liste_chainee *)
444: (*s_objet_argument_1).objet;
445:
446: while(l_element_courant != NULL)
447: {
448: nombre_elements++;
449: l_element_courant = (*l_element_courant).suivant;
450: }
451:
452: if (nombre_elements == 2)
453: {
454: liberation(s_etat_processus, s_objet_argument_1);
455: liberation(s_etat_processus, s_objet_argument_2);
456:
457: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
458: return;
459: }
460:
461: if ((s_objet_resultat = copie_objet(s_etat_processus,
462: s_objet_argument_1, 'N')) == NULL)
463: {
464: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
465: return;
466: }
467:
468: l_element_courant = (struct_liste_chainee *)
469: (*s_objet_resultat).objet;
470: l_element_precedent = l_element_courant;
471: l_element_courant = (*l_element_courant).suivant;
472:
473: if (((*l_element_precedent).suivant =
474: allocation_maillon(s_etat_processus)) == NULL)
475: {
476: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
477: return;
478: }
479:
480: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
481: (*(*l_element_precedent).suivant).suivant = l_element_courant;
482:
483: while((*l_element_courant).suivant != NULL)
484: {
485: l_element_precedent = l_element_courant;
486: l_element_courant = (*l_element_courant).suivant;
487: }
488:
489: if (((*l_element_precedent).suivant =
490: allocation_maillon(s_etat_processus)) == NULL)
491: {
492: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
493: return;
494: }
495:
496: if (((*(*l_element_precedent).suivant).donnee =
497: allocation(s_etat_processus, FCT)) == NULL)
498: {
499: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
500: return;
501: }
502:
503: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
504: .donnee).objet)).nombre_arguments = 0;
505: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
506: .donnee).objet)).fonction = instruction_and;
507:
508: if (((*((struct_fonction *) (*(*(*l_element_precedent)
509: .suivant).donnee).objet)).nom_fonction =
510: malloc(4 * sizeof(unsigned char))) == NULL)
511: {
512: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
513: return;
514: }
515:
516: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
517: .suivant).donnee).objet)).nom_fonction, "AND");
518:
519: (*(*l_element_precedent).suivant).suivant = l_element_courant;
520:
521: s_objet_argument_2 = NULL;
522: }
523:
524: /*
525: * Expression / Nom ou valeur numérique
526: */
527:
528: else if ((((*s_objet_argument_1).type == NOM) ||
529: ((*s_objet_argument_1).type == INT) ||
530: ((*s_objet_argument_1).type == REL)) &&
531: (((*s_objet_argument_2).type == ALG) ||
532: ((*s_objet_argument_2).type == RPN)))
533: {
534: nombre_elements = 0;
535: l_element_courant = (struct_liste_chainee *)
536: (*s_objet_argument_2).objet;
537:
538: while(l_element_courant != NULL)
539: {
540: nombre_elements++;
541: l_element_courant = (*l_element_courant).suivant;
542: }
543:
544: if (nombre_elements == 2)
545: {
546: liberation(s_etat_processus, s_objet_argument_1);
547: liberation(s_etat_processus, s_objet_argument_2);
548:
549: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
550: return;
551: }
552:
553: if ((s_objet_resultat = copie_objet(s_etat_processus,
554: s_objet_argument_2, 'N')) == NULL)
555: {
556: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
557: return;
558: }
559:
560: l_element_courant = (struct_liste_chainee *)
561: (*s_objet_resultat).objet;
562: l_element_precedent = l_element_courant;
563:
564: while((*l_element_courant).suivant != NULL)
565: {
566: l_element_precedent = l_element_courant;
567: l_element_courant = (*l_element_courant).suivant;
568: }
569:
570: if (((*l_element_precedent).suivant =
571: allocation_maillon(s_etat_processus)) == NULL)
572: {
573: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
574: return;
575: }
576:
577: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
578: l_element_precedent = (*l_element_precedent).suivant;
579:
580: if (((*l_element_precedent).suivant =
581: allocation_maillon(s_etat_processus)) == NULL)
582: {
583: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
584: return;
585: }
586:
587: if (((*(*l_element_precedent).suivant).donnee =
588: allocation(s_etat_processus, FCT)) == NULL)
589: {
590: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
591: return;
592: }
593:
594: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
595: .donnee).objet)).nombre_arguments = 0;
596: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
597: .donnee).objet)).fonction = instruction_and;
598:
599: if (((*((struct_fonction *) (*(*(*l_element_precedent)
600: .suivant).donnee).objet)).nom_fonction =
601: malloc(4 * sizeof(unsigned char))) == NULL)
602: {
603: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
604: return;
605: }
606:
607: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
608: .suivant).donnee).objet)).nom_fonction, "AND");
609:
610: (*(*l_element_precedent).suivant).suivant = l_element_courant;
611:
612: s_objet_argument_1 = NULL;
613: }
614:
615: /*
616: * Expression / Expression
617: */
618:
619: else if ((((*s_objet_argument_1).type == ALG) &&
620: ((*s_objet_argument_2).type == ALG)) ||
621: (((*s_objet_argument_1).type == RPN) &&
622: ((*s_objet_argument_2).type == RPN)))
623: {
624: nombre_elements = 0;
625: l_element_courant = (struct_liste_chainee *)
626: (*s_objet_argument_1).objet;
627:
628: while(l_element_courant != NULL)
629: {
630: nombre_elements++;
631: l_element_courant = (*l_element_courant).suivant;
632: }
633:
634: if (nombre_elements == 2)
635: {
636: liberation(s_etat_processus, s_objet_argument_1);
637: liberation(s_etat_processus, s_objet_argument_2);
638:
639: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
640: return;
641: }
642:
643: nombre_elements = 0;
644: l_element_courant = (struct_liste_chainee *)
645: (*s_objet_argument_2).objet;
646:
647: while(l_element_courant != NULL)
648: {
649: nombre_elements++;
650: l_element_courant = (*l_element_courant).suivant;
651: }
652:
653: if (nombre_elements == 2)
654: {
655: liberation(s_etat_processus, s_objet_argument_1);
656: liberation(s_etat_processus, s_objet_argument_2);
657:
658: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
659: return;
660: }
661:
662: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
663: s_objet_argument_1, 'N')) == NULL)
664: {
665: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
666: return;
667: }
668:
669: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
670: s_objet_argument_2, 'N')) == NULL)
671: {
672: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
673: return;
674: }
675:
676: l_element_courant = (struct_liste_chainee *)
677: (*s_copie_argument_1).objet;
678: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
679: (*s_copie_argument_1).objet)).suivant;
680:
681: liberation(s_etat_processus, (*l_element_courant).donnee);
682: liberation_maillon(s_etat_processus, l_element_courant);
683:
684: l_element_courant = (struct_liste_chainee *)
685: (*s_copie_argument_2).objet;
686: l_element_precedent = l_element_courant;
687: s_objet_resultat = s_copie_argument_2;
688:
689: while((*l_element_courant).suivant != NULL)
690: {
691: l_element_precedent = l_element_courant;
692: l_element_courant = (*l_element_courant).suivant;
693: }
694:
695: liberation(s_etat_processus, (*l_element_courant).donnee);
696: liberation_maillon(s_etat_processus, l_element_courant);
697:
698: (*l_element_precedent).suivant = (struct_liste_chainee *)
699: (*s_copie_argument_1).objet;
700: (*s_copie_argument_1).objet = NULL;
701: free(s_copie_argument_1);
702:
703: l_element_courant = (*l_element_precedent).suivant;
704: while((*l_element_courant).suivant != NULL)
705: {
706: l_element_precedent = l_element_courant;
707: l_element_courant = (*l_element_courant).suivant;
708: }
709:
710: if (((*l_element_precedent).suivant =
711: allocation_maillon(s_etat_processus)) == NULL)
712: {
713: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
714: return;
715: }
716:
717: (*(*l_element_precedent).suivant).suivant = l_element_courant;
718: l_element_courant = (*l_element_precedent).suivant;
719:
720: if (((*l_element_courant).donnee =
721: allocation(s_etat_processus, FCT)) == NULL)
722: {
723: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
724: return;
725: }
726:
727: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
728: .nombre_arguments = 0;
729: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
730: .fonction = instruction_and;
731:
732: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
733: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
734: {
735: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
736: return;
737: }
738:
739: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
740: .nom_fonction, "AND");
741: }
742:
743: /*
744: --------------------------------------------------------------------------------
745: AND impossible
746: --------------------------------------------------------------------------------
747: */
748:
749: else
750: {
751: liberation(s_etat_processus, s_objet_argument_1);
752: liberation(s_etat_processus, s_objet_argument_2);
753:
754: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
755: return;
756: }
757:
758: liberation(s_etat_processus, s_objet_argument_1);
759: liberation(s_etat_processus, s_objet_argument_2);
760:
761: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
762: s_objet_resultat) == d_erreur)
763: {
764: return;
765: }
766:
767: return;
768: }
769:
770:
771: /*
772: ================================================================================
773: Fonction 'abs'
774: ================================================================================
775: Entrées :
776: --------------------------------------------------------------------------------
777: Sorties :
778: --------------------------------------------------------------------------------
779: Effets de bord : néant
780: ================================================================================
781: */
782:
783: void
784: instruction_abs(struct_processus *s_etat_processus)
785: {
786: logical1 erreur_memoire;
787:
788: real8 tampon_flottant;
789:
790: struct_liste_chainee *l_element_courant;
791: struct_liste_chainee *l_element_precedent;
792:
793: struct_objet *s_copie_argument;
794: struct_objet *s_objet_argument;
795: struct_objet *s_objet_resultat;
796:
797: unsigned long i;
798: unsigned long j;
799: unsigned long k;
800: unsigned long nombre_elements;
801:
802: void *accumulateur;
803:
804: (*s_etat_processus).erreur_execution = d_ex;
805:
806: if ((*s_etat_processus).affichage_arguments == 'Y')
807: {
808: printf("\n ABS ");
809:
810: if ((*s_etat_processus).langue == 'F')
811: {
812: printf("(norme)\n\n");
813: }
814: else
815: {
816: printf("(norm)\n\n");
817: }
818:
819: printf(" 1: %s\n", d_INT);
820: printf("-> 1: %s\n\n", d_INT);
821:
822: printf(" 1: %s, %s\n", d_REL, d_CPL);
823: printf("-> 1: %s\n\n", d_REL);
824:
825: printf(" 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
826: printf("-> 1: %s\n\n", d_REL);
827:
828: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
829: printf("-> 1: %s\n\n", d_REL);
830:
831: printf(" 1: %s, %s\n", d_NOM, d_ALG);
832: printf("-> 1: %s\n\n", d_ALG);
833:
834: printf(" 1: %s\n", d_RPN);
835: printf("-> 1: %s\n", d_RPN);
836:
837: return;
838: }
839: else if ((*s_etat_processus).test_instruction == 'Y')
840: {
841: (*s_etat_processus).nombre_arguments = 1;
842: return;
843: }
844:
845: if (test_cfsf(s_etat_processus, 31) == d_vrai)
846: {
847: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
848: {
849: return;
850: }
851: }
852:
853: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
854: &s_objet_argument) == d_erreur)
855: {
856: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
857: return;
858: }
859:
860: /*
861: --------------------------------------------------------------------------------
862: Valeur absolue d'un entier
863: --------------------------------------------------------------------------------
864: */
865:
866: if ((*s_objet_argument).type == INT)
867: {
868: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
869: {
870: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
871: return;
872: }
873:
874: (*((integer8 *) (*s_objet_resultat).objet)) = abs((*((integer8 *)
875: (*s_objet_argument).objet)));
876: }
877:
878: /*
879: --------------------------------------------------------------------------------
880: Valeur absolue d'un réel
881: --------------------------------------------------------------------------------
882: */
883:
884: else if ((*s_objet_argument).type == REL)
885: {
886: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
887: {
888: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
889: return;
890: }
891:
892: (*((real8 *) (*s_objet_resultat).objet)) = fabs(*((real8 *)
893: (*s_objet_argument).objet));
894: }
895:
896: /*
897: --------------------------------------------------------------------------------
898: Valeur absolue d'un complexe
899: --------------------------------------------------------------------------------
900: */
901:
902: else if ((*s_objet_argument).type == CPL)
903: {
904: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
905: {
906: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
907: return;
908: }
909:
910: (*s_objet_resultat).type = REL;
911: f77absc_(((struct_complexe16 *) (*s_objet_argument).objet),
912: ((real8 *) (*s_objet_resultat).objet));
913: }
914:
915: /*
916: --------------------------------------------------------------------------------
917: Norme de Frobenius d'un tableau
918: --------------------------------------------------------------------------------
919: */
920:
921: /*
922: * Vecteur d'entiers
923: */
924:
925: else if ((*s_objet_argument).type == VIN)
926: {
927: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
928: {
929: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
930: return;
931: }
932:
933: if ((accumulateur = malloc((*(((struct_vecteur *)
934: (*s_objet_argument).objet))).taille * sizeof(real8))) == NULL)
935: {
936: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
937: return;
938: }
939:
940: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))
941: .taille; i++)
942: {
943: ((real8 *) accumulateur)[i] = (real8) (((integer8 *)
944: (*((struct_vecteur *) (*s_objet_argument).objet))
945: .tableau)[i] * ((integer8 *) (*((struct_vecteur *)
946: (*s_objet_argument).objet)).tableau)[i]);
947: }
948:
949: (*((real8 *) (*s_objet_resultat).objet)) =
950: sqrt(sommation_vecteur_reel(accumulateur,
951: &((*(((struct_vecteur *) (*s_objet_argument).objet))).taille),
952: &erreur_memoire));
953:
954: if (erreur_memoire == d_vrai)
955: {
956: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
957: return;
958: }
959:
960: free(accumulateur);
961: }
962:
963: /*
964: * Vecteur de réels
965: */
966:
967: else if ((*s_objet_argument).type == VRL)
968: {
969: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
970: {
971: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
972: return;
973: }
974:
975: if ((accumulateur = malloc((*(((struct_vecteur *)
976: (*s_objet_argument).objet))).taille * sizeof(real8))) == NULL)
977: {
978: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
979: return;
980: }
981:
982: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))
983: .taille; i++)
984: {
985: ((real8 *) accumulateur)[i] = ((real8 *) (*((struct_vecteur *)
986: (*s_objet_argument).objet)).tableau)[i] *
987: ((real8 *) (*((struct_vecteur *)
988: (*s_objet_argument).objet)).tableau)[i];
989: }
990:
991: (*((real8 *) (*s_objet_resultat).objet)) =
992: sqrt(sommation_vecteur_reel(accumulateur,
993: &((*(((struct_vecteur *) (*s_objet_argument).objet))).taille),
994: &erreur_memoire));
995:
996: if (erreur_memoire == d_vrai)
997: {
998: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
999: return;
1000: }
1001:
1002: free(accumulateur);
1003: }
1004:
1005: /*
1006: * Vecteur de complexes
1007: */
1008:
1009: else if ((*s_objet_argument).type == VCX)
1010: {
1011: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
1012: {
1013: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1014: return;
1015: }
1016:
1017: if ((accumulateur = malloc((*(((struct_vecteur *)
1018: (*s_objet_argument).objet))).taille * sizeof(real8))) == NULL)
1019: {
1020: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1021: return;
1022: }
1023:
1024: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))
1025: .taille; i++)
1026: {
1027: f77absc_(&(((struct_complexe16 *) (*((struct_vecteur *)
1028: (*s_objet_argument).objet)).tableau)[i]), &tampon_flottant);
1029: ((real8 *) accumulateur)[i] = (tampon_flottant * tampon_flottant);
1030: }
1031:
1032: (*((real8 *) (*s_objet_resultat).objet)) =
1033: sqrt(sommation_vecteur_reel(accumulateur,
1034: &((*(((struct_vecteur *) (*s_objet_argument).objet))).taille),
1035: &erreur_memoire));
1036:
1037: if (erreur_memoire == d_vrai)
1038: {
1039: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1040: return;
1041: }
1042:
1043: free(accumulateur);
1044: }
1045:
1046: /*
1047: * Matrice d'entiers
1048: */
1049:
1050: else if ((*s_objet_argument).type == MIN)
1051: {
1052: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
1053: {
1054: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1055: return;
1056: }
1057:
1058: if ((accumulateur = malloc((nombre_elements =
1059: (*(((struct_matrice *) (*s_objet_argument).objet)))
1060: .nombre_lignes * (*(((struct_matrice *) (*s_objet_argument)
1061: .objet))).nombre_colonnes) * sizeof(real8))) == NULL)
1062: {
1063: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1064: return;
1065: }
1066:
1067: for(k = 0, i = 0; i < (*(((struct_matrice *)
1068: (*s_objet_argument).objet))).nombre_lignes; i++)
1069: {
1070: for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument).objet)))
1071: .nombre_colonnes; j++)
1072: {
1073: ((real8 *) accumulateur)[k++] =
1074: ((integer8 **) (*((struct_matrice *)
1075: (*s_objet_argument).objet)).tableau)[i][j] *
1076: ((integer8 **) (*((struct_matrice *)
1077: (*s_objet_argument).objet)).tableau)[i][j];
1078: }
1079: }
1080:
1081: (*((real8 *) (*s_objet_resultat).objet)) =
1082: sqrt(sommation_vecteur_reel(accumulateur, &nombre_elements,
1083: &erreur_memoire));
1084:
1085: if (erreur_memoire == d_vrai)
1086: {
1087: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1088: return;
1089: }
1090:
1091: free(accumulateur);
1092: }
1093:
1094: /*
1095: * Matrice de réels
1096: */
1097:
1098: else if ((*s_objet_argument).type == MRL)
1099: {
1100: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
1101: {
1102: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1103: return;
1104: }
1105:
1106: if ((accumulateur = malloc((nombre_elements =
1107: (*(((struct_matrice *) (*s_objet_argument).objet)))
1108: .nombre_lignes * (*(((struct_matrice *) (*s_objet_argument)
1109: .objet))).nombre_colonnes) * sizeof(real8))) == NULL)
1110: {
1111: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1112: return;
1113: }
1114:
1115: for(k = 0, i = 0; i < (*(((struct_matrice *)
1116: (*s_objet_argument).objet))).nombre_lignes; i++)
1117: {
1118: for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument).objet)))
1119: .nombre_colonnes; j++)
1120: {
1121: ((real8 *) accumulateur)[k++] =
1122: ((real8 **) (*((struct_matrice *)
1123: (*s_objet_argument).objet)).tableau)[i][j] *
1124: ((real8 **) (*((struct_matrice *)
1125: (*s_objet_argument).objet)).tableau)[i][j];
1126: }
1127: }
1128:
1129: (*((real8 *) (*s_objet_resultat).objet)) =
1130: sqrt(sommation_vecteur_reel(accumulateur, &nombre_elements,
1131: &erreur_memoire));
1132:
1133: if (erreur_memoire == d_vrai)
1134: {
1135: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1136: return;
1137: }
1138:
1139: free(accumulateur);
1140: }
1141:
1142: /*
1143: * Matrice de complexes
1144: */
1145:
1146: else if ((*s_objet_argument).type == MCX)
1147: {
1148: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
1149: {
1150: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1151: return;
1152: }
1153:
1154: if ((accumulateur = malloc((nombre_elements =
1155: (*(((struct_matrice *) (*s_objet_argument).objet)))
1156: .nombre_lignes * (*(((struct_matrice *) (*s_objet_argument)
1157: .objet))).nombre_colonnes) * sizeof(real8))) == NULL)
1158: {
1159: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1160: return;
1161: }
1162:
1163: for(k = 0, i = 0; i < (*(((struct_matrice *)
1164: (*s_objet_argument).objet))).nombre_lignes; i++)
1165: {
1166: for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument).objet)))
1167: .nombre_colonnes; j++)
1168: {
1169: f77absc_(&(((struct_complexe16 **) (*((struct_matrice *)
1170: (*s_objet_argument).objet)).tableau)[i][j]),
1171: &tampon_flottant);
1172: ((real8 *) accumulateur)[k++] =
1173: (tampon_flottant * tampon_flottant);
1174: }
1175: }
1176:
1177: (*((real8 *) (*s_objet_resultat).objet)) =
1178: sqrt(sommation_vecteur_reel(accumulateur, &nombre_elements,
1179: &erreur_memoire));
1180:
1181: if (erreur_memoire == d_vrai)
1182: {
1183: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1184: return;
1185: }
1186:
1187: free(accumulateur);
1188: }
1189:
1190: /*
1191: --------------------------------------------------------------------------------
1192: Valeur absolue d'un nom
1193: --------------------------------------------------------------------------------
1194: */
1195:
1196: else if ((*s_objet_argument).type == NOM)
1197: {
1198: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
1199: {
1200: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1201: return;
1202: }
1203:
1204: if (((*s_objet_resultat).objet =
1205: allocation_maillon(s_etat_processus)) == NULL)
1206: {
1207: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1208: return;
1209: }
1210:
1211: l_element_courant = (*s_objet_resultat).objet;
1212:
1213: if (((*l_element_courant).donnee =
1214: allocation(s_etat_processus, FCT)) == NULL)
1215: {
1216: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1217: return;
1218: }
1219:
1220: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1221: .nombre_arguments = 0;
1222: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1223: .fonction = instruction_vers_niveau_superieur;
1224:
1225: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1226: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1227: {
1228: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1229: return;
1230: }
1231:
1232: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1233: .nom_fonction, "<<");
1234:
1235: if (((*l_element_courant).suivant =
1236: allocation_maillon(s_etat_processus)) == NULL)
1237: {
1238: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1239: return;
1240: }
1241:
1242: l_element_courant = (*l_element_courant).suivant;
1243: (*l_element_courant).donnee = s_objet_argument;
1244:
1245: if (((*l_element_courant).suivant =
1246: allocation_maillon(s_etat_processus)) == NULL)
1247: {
1248: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1249: return;
1250: }
1251:
1252: l_element_courant = (*l_element_courant).suivant;
1253:
1254: if (((*l_element_courant).donnee =
1255: allocation(s_etat_processus, FCT)) == NULL)
1256: {
1257: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1258: return;
1259: }
1260:
1261: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1262: .nombre_arguments = 1;
1263: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1264: .fonction = instruction_abs;
1265:
1266: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1267: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
1268: {
1269: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1270: return;
1271: }
1272:
1273: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1274: .nom_fonction, "ABS");
1275:
1276: if (((*l_element_courant).suivant =
1277: allocation_maillon(s_etat_processus)) == NULL)
1278: {
1279: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1280: return;
1281: }
1282:
1283: l_element_courant = (*l_element_courant).suivant;
1284:
1285: if (((*l_element_courant).donnee =
1286: allocation(s_etat_processus, FCT)) == NULL)
1287: {
1288: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1289: return;
1290: }
1291:
1292: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1293: .nombre_arguments = 0;
1294: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1295: .fonction = instruction_vers_niveau_inferieur;
1296:
1297: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1298: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1299: {
1300: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1301: return;
1302: }
1303:
1304: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1305: .nom_fonction, ">>");
1306:
1307: (*l_element_courant).suivant = NULL;
1308: s_objet_argument = NULL;
1309: }
1310:
1311: /*
1312: --------------------------------------------------------------------------------
1313: Valeur absolue d'une expression
1314: --------------------------------------------------------------------------------
1315: */
1316:
1317: else if (((*s_objet_argument).type == ALG) ||
1318: ((*s_objet_argument).type == RPN))
1319: {
1320: if ((s_copie_argument = copie_objet(s_etat_processus,
1321: s_objet_argument, 'N')) == NULL)
1322: {
1323: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1324: return;
1325: }
1326:
1327: l_element_courant = (struct_liste_chainee *)
1328: (*s_copie_argument).objet;
1329: l_element_precedent = l_element_courant;
1330:
1331: while((*l_element_courant).suivant != NULL)
1332: {
1333: l_element_precedent = l_element_courant;
1334: l_element_courant = (*l_element_courant).suivant;
1335: }
1336:
1337: if (((*l_element_precedent).suivant =
1338: allocation_maillon(s_etat_processus)) == NULL)
1339: {
1340: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1341: return;
1342: }
1343:
1344: if (((*(*l_element_precedent).suivant).donnee =
1345: allocation(s_etat_processus, FCT)) == NULL)
1346: {
1347: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1348: return;
1349: }
1350:
1351: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1352: .donnee).objet)).nombre_arguments = 1;
1353: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1354: .donnee).objet)).fonction = instruction_abs;
1355:
1356: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1357: .suivant).donnee).objet)).nom_fonction =
1358: malloc(4 * sizeof(unsigned char))) == NULL)
1359: {
1360: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1361: return;
1362: }
1363:
1364: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1365: .suivant).donnee).objet)).nom_fonction, "ABS");
1366:
1367: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1368:
1369: s_objet_resultat = s_copie_argument;
1370: }
1371:
1372: /*
1373: --------------------------------------------------------------------------------
1374: Valeur absolue impossible à réaliser
1375: --------------------------------------------------------------------------------
1376: */
1377:
1378: else
1379: {
1380: liberation(s_etat_processus, s_objet_argument);
1381:
1382: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1383: return;
1384: }
1385:
1386: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1387: s_objet_resultat) == d_erreur)
1388: {
1389: return;
1390: }
1391:
1392: liberation(s_etat_processus, s_objet_argument);
1393:
1394: return;
1395: }
1396:
1397:
1398: /*
1399: ================================================================================
1400: Fonction 'arg'
1401: ================================================================================
1402: Entrées : structure processus
1403: --------------------------------------------------------------------------------
1404: Sorties :
1405: --------------------------------------------------------------------------------
1406: Effets de bord : néant
1407: ================================================================================
1408: */
1409:
1410: void
1411: instruction_arg(struct_processus *s_etat_processus)
1412: {
1413: struct_liste_chainee *l_element_courant;
1414: struct_liste_chainee *l_element_precedent;
1415:
1416: struct_objet *s_copie_argument;
1417: struct_objet *s_objet_argument;
1418: struct_objet *s_objet_resultat;
1419:
1420: (*s_etat_processus).erreur_execution = d_ex;
1421:
1422: if ((*s_etat_processus).affichage_arguments == 'Y')
1423: {
1424: printf("\n ARG ");
1425:
1426: if ((*s_etat_processus).langue == 'F')
1427: {
1428: printf("(argument)\n\n");
1429: }
1430: else
1431: {
1432: printf("(argument)\n\n");
1433: }
1434:
1435: printf(" 1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
1436: printf("-> 1: %s\n\n", d_REL);
1437:
1438: printf(" 1: %s, %s\n", d_NOM, d_ALG);
1439: printf("-> 1: %s\n\n", d_ALG);
1440:
1441: printf(" 1: %s\n", d_RPN);
1442: printf("-> 1: %s\n", d_RPN);
1443:
1444: return;
1445: }
1446: else if ((*s_etat_processus).test_instruction == 'Y')
1447: {
1448: (*s_etat_processus).nombre_arguments = 1;
1449: return;
1450: }
1451:
1452: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1453: {
1454: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1455: {
1456: return;
1457: }
1458: }
1459:
1460: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1461: &s_objet_argument) == d_erreur)
1462: {
1463: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1464: return;
1465: }
1466:
1467: /*
1468: --------------------------------------------------------------------------------
1469: Argument d'un entier ou d'un réel
1470: --------------------------------------------------------------------------------
1471: */
1472:
1473: if (((*s_objet_argument).type == INT) ||
1474: ((*s_objet_argument).type == REL))
1475: {
1476: if ((s_objet_resultat = allocation(s_etat_processus, REL))
1477: == NULL)
1478: {
1479: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1480: return;
1481: }
1482:
1483: if ((*s_objet_argument).type == INT)
1484: {
1485: if ((*((integer8 *) (*s_objet_argument).objet)) >= 0)
1486: {
1487: (*((real8 *) (*s_objet_resultat).objet)) = 0;
1488: }
1489: else
1490: {
1491: (*((real8 *) (*s_objet_resultat).objet)) =
1492: 4 * atan((real8) 1);
1493: }
1494: }
1495: else
1496: {
1497: if ((*((real8 *) (*s_objet_argument).objet)) >= 0)
1498: {
1499: (*((real8 *) (*s_objet_resultat).objet)) = 0;
1500: }
1501: else
1502: {
1503: (*((real8 *) (*s_objet_resultat).objet)) =
1504: 4 * atan((real8) 1);
1505:
1506: if (test_cfsf(s_etat_processus, 60) == d_faux)
1507: {
1508: conversion_radians_vers_degres(&(*((real8 *)
1509: (*s_objet_resultat).objet)));
1510: }
1511: }
1512: }
1513: }
1514:
1515: /*
1516: --------------------------------------------------------------------------------
1517: Argument d'un complexe
1518: --------------------------------------------------------------------------------
1519: */
1520:
1521: else if ((*s_objet_argument).type == CPL)
1522: {
1523: if ((s_objet_resultat = allocation(s_etat_processus, REL))
1524: == NULL)
1525: {
1526: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1527: return;
1528: }
1529:
1530: (*((real8 *) (*s_objet_resultat).objet)) =
1531: atan2((*((struct_complexe16 *) (*s_objet_argument).objet))
1532: .partie_imaginaire, (*((struct_complexe16 *)
1533: (*s_objet_argument).objet)).partie_reelle);
1534:
1535: if (test_cfsf(s_etat_processus, 60) == d_faux)
1536: {
1537: conversion_radians_vers_degres(&(*((real8 *)
1538: (*s_objet_resultat).objet)));
1539: }
1540: }
1541:
1542: /*
1543: --------------------------------------------------------------------------------
1544: Argument d'un nom
1545: --------------------------------------------------------------------------------
1546: */
1547:
1548: else if ((*s_objet_argument).type == NOM)
1549: {
1550: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
1551: == NULL)
1552: {
1553: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1554: return;
1555: }
1556:
1557: if (((*s_objet_resultat).objet =
1558: allocation_maillon(s_etat_processus)) == NULL)
1559: {
1560: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1561: return;
1562: }
1563:
1564: l_element_courant = (*s_objet_resultat).objet;
1565:
1566: if (((*l_element_courant).donnee =
1567: allocation(s_etat_processus, FCT)) == NULL)
1568: {
1569: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1570: return;
1571: }
1572:
1573: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1574: .nombre_arguments = 0;
1575: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1576: .fonction = instruction_vers_niveau_superieur;
1577:
1578: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1579: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1580: {
1581: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1582: return;
1583: }
1584:
1585: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1586: .nom_fonction, "<<");
1587:
1588: if (((*l_element_courant).suivant =
1589: allocation_maillon(s_etat_processus)) == NULL)
1590: {
1591: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1592: return;
1593: }
1594:
1595: l_element_courant = (*l_element_courant).suivant;
1596: (*l_element_courant).donnee = s_objet_argument;
1597:
1598: if (((*l_element_courant).suivant =
1599: allocation_maillon(s_etat_processus)) == NULL)
1600: {
1601: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1602: return;
1603: }
1604:
1605: l_element_courant = (*l_element_courant).suivant;
1606:
1607: if (((*l_element_courant).donnee =
1608: allocation(s_etat_processus, FCT)) == NULL)
1609: {
1610: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1611: return;
1612: }
1613:
1614: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1615: .nombre_arguments = 1;
1616: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1617: .fonction = instruction_arg;
1618:
1619: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1620: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
1621: {
1622: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1623: return;
1624: }
1625:
1626: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1627: .nom_fonction, "ARG");
1628:
1629: if (((*l_element_courant).suivant =
1630: allocation_maillon(s_etat_processus)) == NULL)
1631: {
1632: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1633: return;
1634: }
1635:
1636: l_element_courant = (*l_element_courant).suivant;
1637:
1638: if (((*l_element_courant).donnee =
1639: allocation(s_etat_processus, FCT)) == NULL)
1640: {
1641: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1642: return;
1643: }
1644:
1645: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1646: .nombre_arguments = 0;
1647: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1648: .fonction = instruction_vers_niveau_inferieur;
1649:
1650: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1651: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1652: {
1653: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1654: return;
1655: }
1656:
1657: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1658: .nom_fonction, ">>");
1659:
1660: (*l_element_courant).suivant = NULL;
1661: s_objet_argument = NULL;
1662: }
1663:
1664: /*
1665: --------------------------------------------------------------------------------
1666: Argument d'une expression
1667: --------------------------------------------------------------------------------
1668: */
1669:
1670: else if (((*s_objet_argument).type == ALG) ||
1671: ((*s_objet_argument).type == RPN))
1672: {
1673: if ((s_copie_argument = copie_objet(s_etat_processus,
1674: s_objet_argument, 'N')) == NULL)
1675: {
1676: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1677: return;
1678: }
1679:
1680: l_element_courant = (struct_liste_chainee *)
1681: (*s_copie_argument).objet;
1682: l_element_precedent = l_element_courant;
1683:
1684: while((*l_element_courant).suivant != NULL)
1685: {
1686: l_element_precedent = l_element_courant;
1687: l_element_courant = (*l_element_courant).suivant;
1688: }
1689:
1690: if (((*l_element_precedent).suivant =
1691: allocation_maillon(s_etat_processus)) == NULL)
1692: {
1693: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1694: return;
1695: }
1696:
1697: if (((*(*l_element_precedent).suivant).donnee =
1698: allocation(s_etat_processus, FCT)) == NULL)
1699: {
1700: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1701: return;
1702: }
1703:
1704: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1705: .donnee).objet)).nombre_arguments = 1;
1706: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1707: .donnee).objet)).fonction = instruction_arg;
1708:
1709: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1710: .suivant).donnee).objet)).nom_fonction =
1711: malloc(4 * sizeof(unsigned char))) == NULL)
1712: {
1713: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1714: return;
1715: }
1716:
1717: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1718: .suivant).donnee).objet)).nom_fonction, "ARG");
1719:
1720: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1721:
1722: s_objet_resultat = s_copie_argument;
1723: }
1724:
1725: /*
1726: --------------------------------------------------------------------------------
1727: Réalisation impossible de la fonction argument
1728: --------------------------------------------------------------------------------
1729: */
1730:
1731: else
1732: {
1733: liberation(s_etat_processus, s_objet_argument);
1734:
1735: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1736: return;
1737: }
1738:
1739: liberation(s_etat_processus, s_objet_argument);
1740:
1741: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1742: s_objet_resultat) == d_erreur)
1743: {
1744: return;
1745: }
1746:
1747: return;
1748: }
1749:
1750:
1751: /*
1752: ================================================================================
1753: Fonction 'asin'
1754: ================================================================================
1755: Entrées : pointeur sur une structure struct_processus
1756: --------------------------------------------------------------------------------
1757: Sorties :
1758: --------------------------------------------------------------------------------
1759: Effets de bord : néant
1760: ================================================================================
1761: */
1762:
1763: void
1764: instruction_asin(struct_processus *s_etat_processus)
1765: {
1766: real8 argument;
1767:
1768: struct_complexe16 registre;
1769:
1770: struct_liste_chainee *l_element_courant;
1771: struct_liste_chainee *l_element_precedent;
1772:
1773: struct_objet *s_copie_argument;
1774: struct_objet *s_objet_argument;
1775: struct_objet *s_objet_resultat;
1776:
1777: (*s_etat_processus).erreur_execution = d_ex;
1778:
1779: if ((*s_etat_processus).affichage_arguments == 'Y')
1780: {
1781: printf("\n ASIN ");
1782:
1783: if ((*s_etat_processus).langue == 'F')
1784: {
1785: printf("(arcsinus)\n\n");
1786: }
1787: else
1788: {
1789: printf("(arcsine)\n\n");
1790: }
1791:
1792: printf(" 1: %s, %s\n", d_INT, d_REL);
1793: printf("-> 1: %s, %s\n\n", d_REL, d_CPL);
1794:
1795: printf(" 1: %s\n", d_CPL);
1796: printf("-> 1: %s\n\n", d_CPL);
1797:
1798: printf(" 1: %s, %s\n", d_NOM, d_ALG);
1799: printf("-> 1: %s\n\n", d_ALG);
1800:
1801: printf(" 1: %s\n", d_RPN);
1802: printf("-> 1: %s\n", d_RPN);
1803:
1804: return;
1805: }
1806: else if ((*s_etat_processus).test_instruction == 'Y')
1807: {
1808: (*s_etat_processus).nombre_arguments = 1;
1809: return;
1810: }
1811:
1812: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1813: {
1814: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1815: {
1816: return;
1817: }
1818: }
1819:
1820: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1821: &s_objet_argument) == d_erreur)
1822: {
1823: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1824: return;
1825: }
1826:
1827: /*
1828: --------------------------------------------------------------------------------
1829: Arcsinus d'un entier ou d'un réel
1830: --------------------------------------------------------------------------------
1831: */
1832:
1833: if (((*s_objet_argument).type == INT) ||
1834: ((*s_objet_argument).type == REL))
1835: {
1836: if ((*s_objet_argument).type == INT)
1837: {
1838: argument = (real8) (*((integer8 *) (*s_objet_argument).objet));
1839: }
1840: else
1841: {
1842: argument = (*((real8 *) (*s_objet_argument).objet));
1843: }
1844:
1845: if ((argument >= -1) && (argument <= 1))
1846: {
1847: /*
1848: * Résultat réel
1849: */
1850:
1851: if ((s_objet_resultat = allocation(s_etat_processus, REL))
1852: == NULL)
1853: {
1854: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1855: return;
1856: }
1857:
1858: (*((real8 *) (*s_objet_resultat).objet)) = asin(argument);
1859:
1860: if (test_cfsf(s_etat_processus, 60) == d_faux)
1861: {
1862: conversion_radians_vers_degres((real8 *)
1863: (*s_objet_resultat).objet);
1864: }
1865: }
1866: else
1867: {
1868: /*
1869: * Résultat complexe
1870: */
1871:
1872: registre.partie_reelle = argument;
1873: registre.partie_imaginaire = 0;
1874:
1875: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
1876: == NULL)
1877: {
1878: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1879: return;
1880: }
1881:
1882: f77asin_(®istre, (struct_complexe16 *)
1883: (*s_objet_resultat).objet);
1884: }
1885: }
1886:
1887: /*
1888: --------------------------------------------------------------------------------
1889: Arcsinus d'un complexe
1890: --------------------------------------------------------------------------------
1891: */
1892:
1893: else if ((*s_objet_argument).type == CPL)
1894: {
1895: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
1896: == NULL)
1897: {
1898: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1899: return;
1900: }
1901:
1902: f77asin_((struct_complexe16 *) (*s_objet_argument).objet,
1903: (struct_complexe16 *) (*s_objet_resultat).objet);
1904: }
1905:
1906: /*
1907: --------------------------------------------------------------------------------
1908: Arcsinus d'un nom
1909: --------------------------------------------------------------------------------
1910: */
1911:
1912: else if ((*s_objet_argument).type == NOM)
1913: {
1914: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
1915: == NULL)
1916: {
1917: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1918: return;
1919: }
1920:
1921: if (((*s_objet_resultat).objet =
1922: allocation_maillon(s_etat_processus)) == NULL)
1923: {
1924: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1925: return;
1926: }
1927:
1928: l_element_courant = (*s_objet_resultat).objet;
1929:
1930: if (((*l_element_courant).donnee =
1931: allocation(s_etat_processus, FCT)) == NULL)
1932: {
1933: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1934: return;
1935: }
1936:
1937: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1938: .nombre_arguments = 0;
1939: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1940: .fonction = instruction_vers_niveau_superieur;
1941:
1942: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1943: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1944: {
1945: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1946: return;
1947: }
1948:
1949: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1950: .nom_fonction, "<<");
1951:
1952: if (((*l_element_courant).suivant =
1953: allocation_maillon(s_etat_processus)) == NULL)
1954: {
1955: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1956: return;
1957: }
1958:
1959: l_element_courant = (*l_element_courant).suivant;
1960: (*l_element_courant).donnee = s_objet_argument;
1961:
1962: if (((*l_element_courant).suivant =
1963: allocation_maillon(s_etat_processus)) == NULL)
1964: {
1965: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1966: return;
1967: }
1968:
1969: l_element_courant = (*l_element_courant).suivant;
1970:
1971: if (((*l_element_courant).donnee =
1972: allocation(s_etat_processus, FCT)) == NULL)
1973: {
1974: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1975: return;
1976: }
1977:
1978: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1979: .nombre_arguments = 1;
1980: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1981: .fonction = instruction_asin;
1982:
1983: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1984: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
1985: {
1986: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1987: return;
1988: }
1989:
1990: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1991: .nom_fonction, "ASIN");
1992:
1993: if (((*l_element_courant).suivant =
1994: allocation_maillon(s_etat_processus)) == NULL)
1995: {
1996: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1997: return;
1998: }
1999:
2000: l_element_courant = (*l_element_courant).suivant;
2001:
2002: if (((*l_element_courant).donnee =
2003: allocation(s_etat_processus, FCT)) == NULL)
2004: {
2005: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2006: return;
2007: }
2008:
2009: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2010: .nombre_arguments = 0;
2011: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2012: .fonction = instruction_vers_niveau_inferieur;
2013:
2014: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2015: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
2016: {
2017: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2018: return;
2019: }
2020:
2021: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2022: .nom_fonction, ">>");
2023:
2024: (*l_element_courant).suivant = NULL;
2025: s_objet_argument = NULL;
2026: }
2027:
2028: /*
2029: --------------------------------------------------------------------------------
2030: Arcsinus d'une expression
2031: --------------------------------------------------------------------------------
2032: */
2033:
2034: else if (((*s_objet_argument).type == ALG) ||
2035: ((*s_objet_argument).type == RPN))
2036: {
2037: if ((s_copie_argument = copie_objet(s_etat_processus,
2038: s_objet_argument, 'N')) == NULL)
2039: {
2040: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2041: return;
2042: }
2043:
2044: l_element_courant = (struct_liste_chainee *)
2045: (*s_copie_argument).objet;
2046: l_element_precedent = l_element_courant;
2047:
2048: while((*l_element_courant).suivant != NULL)
2049: {
2050: l_element_precedent = l_element_courant;
2051: l_element_courant = (*l_element_courant).suivant;
2052: }
2053:
2054: if (((*l_element_precedent).suivant =
2055: allocation_maillon(s_etat_processus)) == NULL)
2056: {
2057: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2058: return;
2059: }
2060:
2061: if (((*(*l_element_precedent).suivant).donnee =
2062: allocation(s_etat_processus, FCT)) == NULL)
2063: {
2064: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2065: return;
2066: }
2067:
2068: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2069: .donnee).objet)).nombre_arguments = 1;
2070: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2071: .donnee).objet)).fonction = instruction_asin;
2072:
2073: if (((*((struct_fonction *) (*(*(*l_element_precedent)
2074: .suivant).donnee).objet)).nom_fonction =
2075: malloc(5 * sizeof(unsigned char))) == NULL)
2076: {
2077: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2078: return;
2079: }
2080:
2081: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
2082: .suivant).donnee).objet)).nom_fonction, "ASIN");
2083:
2084: (*(*l_element_precedent).suivant).suivant = l_element_courant;
2085:
2086: s_objet_resultat = s_copie_argument;
2087: }
2088:
2089: /*
2090: --------------------------------------------------------------------------------
2091: Réalisation impossible de la fonction arcsinus
2092: --------------------------------------------------------------------------------
2093: */
2094:
2095: else
2096: {
2097: liberation(s_etat_processus, s_objet_argument);
2098:
2099: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2100: return;
2101: }
2102:
2103: liberation(s_etat_processus, s_objet_argument);
2104:
2105: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2106: s_objet_resultat) == d_erreur)
2107: {
2108: return;
2109: }
2110:
2111: return;
2112: }
2113:
2114:
2115: /*
2116: ================================================================================
2117: Fonction 'acos'
2118: ================================================================================
2119: Entrées : pointeur sur une structure struct_processus
2120: --------------------------------------------------------------------------------
2121: Sorties :
2122: --------------------------------------------------------------------------------
2123: Effets de bord : néant
2124: ================================================================================
2125: */
2126:
2127: void
2128: instruction_acos(struct_processus *s_etat_processus)
2129: {
2130: real8 argument;
2131:
2132: struct_complexe16 registre;
2133:
2134: struct_liste_chainee *l_element_courant;
2135: struct_liste_chainee *l_element_precedent;
2136:
2137: struct_objet *s_copie_argument;
2138: struct_objet *s_objet_argument;
2139: struct_objet *s_objet_resultat;
2140:
2141: (*s_etat_processus).erreur_execution = d_ex;
2142:
2143: if ((*s_etat_processus).affichage_arguments == 'Y')
2144: {
2145: printf("\n ACOS ");
2146:
2147: if ((*s_etat_processus).langue == 'F')
2148: {
2149: printf("(arccosinus)\n\n");
2150: }
2151: else
2152: {
2153: printf("(arccosine)\n\n");
2154: }
2155:
2156: printf(" 1: %s, %s\n", d_INT, d_REL);
2157: printf("-> 1: %s, %s\n\n", d_REL, d_CPL);
2158:
2159: printf(" 1: %s\n", d_CPL);
2160: printf("-> 1: %s\n\n", d_CPL);
2161:
2162: printf(" 1: %s, %s\n", d_NOM, d_ALG);
2163: printf("-> 1: %s\n\n", d_ALG);
2164:
2165: printf(" 1: %s\n", d_RPN);
2166: printf("-> 1: %s\n", d_RPN);
2167:
2168: return;
2169: }
2170: else if ((*s_etat_processus).test_instruction == 'Y')
2171: {
2172: (*s_etat_processus).nombre_arguments = 1;
2173: return;
2174: }
2175:
2176: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2177: {
2178: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2179: {
2180: return;
2181: }
2182: }
2183:
2184: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2185: &s_objet_argument) == d_erreur)
2186: {
2187: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2188: return;
2189: }
2190:
2191: /*
2192: --------------------------------------------------------------------------------
2193: Arccossinus d'un entier ou d'un réel
2194: --------------------------------------------------------------------------------
2195: */
2196:
2197: if (((*s_objet_argument).type == INT) ||
2198: ((*s_objet_argument).type == REL))
2199: {
2200: if ((*s_objet_argument).type == INT)
2201: {
2202: argument = (real8) (*((integer8 *) (*s_objet_argument).objet));
2203: }
2204: else
2205: {
2206: argument = (*((real8 *) (*s_objet_argument).objet));
2207: }
2208:
2209: if ((argument >= -1) && (argument <= 1))
2210: {
2211: /*
2212: * Résultat réel
2213: */
2214:
2215: if ((s_objet_resultat = allocation(s_etat_processus, REL))
2216: == NULL)
2217: {
2218: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2219: return;
2220: }
2221:
2222: (*((real8 *) (*s_objet_resultat).objet)) = acos(argument);
2223:
2224: if (test_cfsf(s_etat_processus, 60) == d_faux)
2225: {
2226: conversion_radians_vers_degres((real8 *)
2227: (*s_objet_resultat).objet);
2228: }
2229: }
2230: else
2231: {
2232: /*
2233: * Résultat complexe
2234: */
2235:
2236: registre.partie_reelle = argument;
2237: registre.partie_imaginaire = 0;
2238:
2239: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
2240: == NULL)
2241: {
2242: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2243: return;
2244: }
2245:
2246: f77acos_(®istre, (struct_complexe16 *)
2247: (*s_objet_resultat).objet);
2248: }
2249: }
2250:
2251: /*
2252: --------------------------------------------------------------------------------
2253: Arccossinus d'un complexe
2254: --------------------------------------------------------------------------------
2255: */
2256:
2257: else if ((*s_objet_argument).type == CPL)
2258: {
2259: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
2260: == NULL)
2261: {
2262: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2263: return;
2264: }
2265:
2266: f77acos_((struct_complexe16 *) (*s_objet_argument).objet,
2267: (struct_complexe16 *) (*s_objet_resultat).objet);
2268: }
2269:
2270: /*
2271: --------------------------------------------------------------------------------
2272: Arccossinus d'un nom
2273: --------------------------------------------------------------------------------
2274: */
2275:
2276: else if ((*s_objet_argument).type == NOM)
2277: {
2278: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
2279: == NULL)
2280: {
2281: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2282: return;
2283: }
2284:
2285: if (((*s_objet_resultat).objet =
2286: allocation_maillon(s_etat_processus)) == NULL)
2287: {
2288: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2289: return;
2290: }
2291:
2292: l_element_courant = (*s_objet_resultat).objet;
2293:
2294: if (((*l_element_courant).donnee =
2295: allocation(s_etat_processus, FCT)) == NULL)
2296: {
2297: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2298: return;
2299: }
2300:
2301: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2302: .nombre_arguments = 0;
2303: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2304: .fonction = instruction_vers_niveau_superieur;
2305:
2306: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2307: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
2308: {
2309: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2310: return;
2311: }
2312:
2313: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2314: .nom_fonction, "<<");
2315:
2316: if (((*l_element_courant).suivant =
2317: allocation_maillon(s_etat_processus)) == NULL)
2318: {
2319: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2320: return;
2321: }
2322:
2323: l_element_courant = (*l_element_courant).suivant;
2324: (*l_element_courant).donnee = s_objet_argument;
2325:
2326: if (((*l_element_courant).suivant =
2327: allocation_maillon(s_etat_processus)) == NULL)
2328: {
2329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2330: return;
2331: }
2332:
2333: l_element_courant = (*l_element_courant).suivant;
2334:
2335: if (((*l_element_courant).donnee =
2336: allocation(s_etat_processus, FCT)) == NULL)
2337: {
2338: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2339: return;
2340: }
2341:
2342: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2343: .nombre_arguments = 1;
2344: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2345: .fonction = instruction_acos;
2346:
2347: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2348: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
2349: {
2350: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2351: return;
2352: }
2353:
2354: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2355: .nom_fonction, "ACOS");
2356:
2357: if (((*l_element_courant).suivant =
2358: allocation_maillon(s_etat_processus)) == NULL)
2359: {
2360: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2361: return;
2362: }
2363:
2364: l_element_courant = (*l_element_courant).suivant;
2365:
2366: if (((*l_element_courant).donnee =
2367: allocation(s_etat_processus, FCT)) == NULL)
2368: {
2369: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2370: return;
2371: }
2372:
2373: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2374: .nombre_arguments = 0;
2375: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2376: .fonction = instruction_vers_niveau_inferieur;
2377:
2378: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2379: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
2380: {
2381: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2382: return;
2383: }
2384:
2385: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2386: .nom_fonction, ">>");
2387:
2388: (*l_element_courant).suivant = NULL;
2389: s_objet_argument = NULL;
2390: }
2391:
2392: /*
2393: --------------------------------------------------------------------------------
2394: Arccossinus d'une expression
2395: --------------------------------------------------------------------------------
2396: */
2397:
2398: else if (((*s_objet_argument).type == ALG) ||
2399: ((*s_objet_argument).type == RPN))
2400: {
2401: if ((s_copie_argument = copie_objet(s_etat_processus,
2402: s_objet_argument, 'N')) == NULL)
2403: {
2404: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2405: return;
2406: }
2407:
2408: l_element_courant = (struct_liste_chainee *)
2409: (*s_copie_argument).objet;
2410: l_element_precedent = l_element_courant;
2411:
2412: while((*l_element_courant).suivant != NULL)
2413: {
2414: l_element_precedent = l_element_courant;
2415: l_element_courant = (*l_element_courant).suivant;
2416: }
2417:
2418: if (((*l_element_precedent).suivant =
2419: allocation_maillon(s_etat_processus)) == NULL)
2420: {
2421: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2422: return;
2423: }
2424:
2425: if (((*(*l_element_precedent).suivant).donnee =
2426: allocation(s_etat_processus, FCT)) == NULL)
2427: {
2428: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2429: return;
2430: }
2431:
2432: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2433: .donnee).objet)).nombre_arguments = 1;
2434: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2435: .donnee).objet)).fonction = instruction_acos;
2436:
2437: if (((*((struct_fonction *) (*(*(*l_element_precedent)
2438: .suivant).donnee).objet)).nom_fonction =
2439: malloc(5 * sizeof(unsigned char))) == NULL)
2440: {
2441: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2442: return;
2443: }
2444:
2445: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
2446: .suivant).donnee).objet)).nom_fonction, "ACOS");
2447:
2448: (*(*l_element_precedent).suivant).suivant = l_element_courant;
2449:
2450: s_objet_resultat = s_copie_argument;
2451: }
2452:
2453: /*
2454: --------------------------------------------------------------------------------
2455: Réalisation impossible de la fonction arccosinus
2456: --------------------------------------------------------------------------------
2457: */
2458:
2459: else
2460: {
2461: liberation(s_etat_processus, s_objet_argument);
2462:
2463: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2464: return;
2465: }
2466:
2467: liberation(s_etat_processus, s_objet_argument);
2468:
2469: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2470: s_objet_resultat) == d_erreur)
2471: {
2472: return;
2473: }
2474:
2475: return;
2476: }
2477:
2478:
2479: /*
2480: ================================================================================
2481: Fonction 'atan'
2482: ================================================================================
2483: Entrées : pointeur sur une structure struct_processus
2484: --------------------------------------------------------------------------------
2485: Sorties :
2486: --------------------------------------------------------------------------------
2487: Effets de bord : néant
2488: ================================================================================
2489: */
2490:
2491: void
2492: instruction_atan(struct_processus *s_etat_processus)
2493: {
2494: real8 argument;
2495:
2496: integer4 erreur;
2497:
2498: struct_liste_chainee *l_element_courant;
2499: struct_liste_chainee *l_element_precedent;
2500:
2501: struct_objet *s_copie_argument;
2502: struct_objet *s_objet_argument;
2503: struct_objet *s_objet_resultat;
2504:
2505: (*s_etat_processus).erreur_execution = d_ex;
2506:
2507: if ((*s_etat_processus).affichage_arguments == 'Y')
2508: {
2509: printf("\n ATAN ");
2510:
2511: if ((*s_etat_processus).langue == 'F')
2512: {
2513: printf("(arctangente)\n\n");
2514: }
2515: else
2516: {
2517: printf("(arctangent)\n\n");
2518: }
2519:
2520: printf(" 1: %s, %s\n", d_INT, d_REL);
2521: printf("-> 1: %s, %s\n\n", d_REL, d_CPL);
2522:
2523: printf(" 1: %s\n", d_CPL);
2524: printf("-> 1: %s\n\n", d_CPL);
2525:
2526: printf(" 1: %s, %s\n", d_NOM, d_ALG);
2527: printf("-> 1: %s\n\n", d_ALG);
2528:
2529: printf(" 1: %s\n", d_RPN);
2530: printf("-> 1: %s\n", d_RPN);
2531:
2532: return;
2533: }
2534: else if ((*s_etat_processus).test_instruction == 'Y')
2535: {
2536: (*s_etat_processus).nombre_arguments = 1;
2537: return;
2538: }
2539:
2540: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2541: {
2542: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2543: {
2544: return;
2545: }
2546: }
2547:
2548: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2549: &s_objet_argument) == d_erreur)
2550: {
2551: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2552: return;
2553: }
2554:
2555: /*
2556: --------------------------------------------------------------------------------
2557: Arctangente d'un entier ou d'un réel
2558: --------------------------------------------------------------------------------
2559: */
2560:
2561: if (((*s_objet_argument).type == INT) ||
2562: ((*s_objet_argument).type == REL))
2563: {
2564: if ((*s_objet_argument).type == INT)
2565: {
2566: argument = (real8) (*((integer8 *) (*s_objet_argument).objet));
2567: }
2568: else
2569: {
2570: argument = (*((real8 *) (*s_objet_argument).objet));
2571: }
2572:
2573: if ((s_objet_resultat = allocation(s_etat_processus, REL))
2574: == NULL)
2575: {
2576: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2577: return;
2578: }
2579:
2580: (*((real8 *) (*s_objet_resultat).objet)) = atan(argument);
2581:
2582: if (test_cfsf(s_etat_processus, 60) == d_faux)
2583: {
2584: conversion_radians_vers_degres((real8 *)
2585: (*s_objet_resultat).objet);
2586: }
2587: }
2588:
2589: /*
2590: --------------------------------------------------------------------------------
2591: Arctangente d'un complexe
2592: --------------------------------------------------------------------------------
2593: */
2594:
2595: else if ((*s_objet_argument).type == CPL)
2596: {
2597: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
2598: == NULL)
2599: {
2600: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2601: return;
2602: }
2603:
2604: f77atan_((struct_complexe16 *) (*s_objet_argument).objet,
2605: (struct_complexe16 *) (*s_objet_resultat).objet, &erreur);
2606:
2607: if (erreur != 0)
2608: {
2609: liberation(s_etat_processus, s_objet_argument);
2610: liberation(s_etat_processus, s_objet_resultat);
2611:
2612: free(s_objet_resultat);
2613:
2614: (*s_etat_processus).exception = d_ep_division_par_zero;
2615: return;
2616: }
2617: }
2618:
2619: /*
2620: --------------------------------------------------------------------------------
2621: Arctangente d'un nom
2622: --------------------------------------------------------------------------------
2623: */
2624:
2625: else if ((*s_objet_argument).type == NOM)
2626: {
2627: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
2628: == NULL)
2629: {
2630: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2631: return;
2632: }
2633:
2634: if (((*s_objet_resultat).objet =
2635: allocation_maillon(s_etat_processus)) == NULL)
2636: {
2637: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2638: return;
2639: }
2640:
2641: l_element_courant = (*s_objet_resultat).objet;
2642:
2643: if (((*l_element_courant).donnee =
2644: allocation(s_etat_processus, FCT)) == NULL)
2645: {
2646: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2647: return;
2648: }
2649:
2650: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2651: .nombre_arguments = 0;
2652: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2653: .fonction = instruction_vers_niveau_superieur;
2654:
2655: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2656: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
2657: {
2658: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2659: return;
2660: }
2661:
2662: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2663: .nom_fonction, "<<");
2664:
2665: if (((*l_element_courant).suivant =
2666: allocation_maillon(s_etat_processus)) == NULL)
2667: {
2668: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2669: return;
2670: }
2671:
2672: l_element_courant = (*l_element_courant).suivant;
2673: (*l_element_courant).donnee = s_objet_argument;
2674:
2675: if (((*l_element_courant).suivant =
2676: allocation_maillon(s_etat_processus)) == NULL)
2677: {
2678: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2679: return;
2680: }
2681:
2682: l_element_courant = (*l_element_courant).suivant;
2683:
2684: if (((*l_element_courant).donnee =
2685: allocation(s_etat_processus, FCT)) == NULL)
2686: {
2687: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2688: return;
2689: }
2690:
2691: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2692: .nombre_arguments = 1;
2693: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2694: .fonction = instruction_atan;
2695:
2696: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2697: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
2698: {
2699: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2700: return;
2701: }
2702:
2703: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2704: .nom_fonction, "ATAN");
2705:
2706: if (((*l_element_courant).suivant =
2707: allocation_maillon(s_etat_processus)) == NULL)
2708: {
2709: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2710: return;
2711: }
2712:
2713: l_element_courant = (*l_element_courant).suivant;
2714:
2715: if (((*l_element_courant).donnee =
2716: allocation(s_etat_processus, FCT)) == NULL)
2717: {
2718: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2719: return;
2720: }
2721:
2722: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2723: .nombre_arguments = 0;
2724: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2725: .fonction = instruction_vers_niveau_inferieur;
2726:
2727: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2728: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
2729: {
2730: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2731: return;
2732: }
2733:
2734: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2735: .nom_fonction, ">>");
2736:
2737: (*l_element_courant).suivant = NULL;
2738: s_objet_argument = NULL;
2739: }
2740:
2741: /*
2742: --------------------------------------------------------------------------------
2743: Arctangente d'une expression
2744: --------------------------------------------------------------------------------
2745: */
2746:
2747: else if (((*s_objet_argument).type == ALG) ||
2748: ((*s_objet_argument).type == RPN))
2749: {
2750: if ((s_copie_argument = copie_objet(s_etat_processus,
2751: s_objet_argument, 'N')) == NULL)
2752: {
2753: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2754: return;
2755: }
2756:
2757: l_element_courant = (struct_liste_chainee *)
2758: (*s_copie_argument).objet;
2759: l_element_precedent = l_element_courant;
2760:
2761: while((*l_element_courant).suivant != NULL)
2762: {
2763: l_element_precedent = l_element_courant;
2764: l_element_courant = (*l_element_courant).suivant;
2765: }
2766:
2767: if (((*l_element_precedent).suivant =
2768: allocation_maillon(s_etat_processus)) == NULL)
2769: {
2770: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2771: return;
2772: }
2773:
2774: if (((*(*l_element_precedent).suivant).donnee =
2775: allocation(s_etat_processus, FCT)) == NULL)
2776: {
2777: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2778: return;
2779: }
2780:
2781: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2782: .donnee).objet)).nombre_arguments = 1;
2783: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2784: .donnee).objet)).fonction = instruction_atan;
2785:
2786: if (((*((struct_fonction *) (*(*(*l_element_precedent)
2787: .suivant).donnee).objet)).nom_fonction =
2788: malloc(5 * sizeof(unsigned char))) == NULL)
2789: {
2790: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2791: return;
2792: }
2793:
2794: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
2795: .suivant).donnee).objet)).nom_fonction, "ATAN");
2796:
2797: (*(*l_element_precedent).suivant).suivant = l_element_courant;
2798:
2799: s_objet_resultat = s_copie_argument;
2800: }
2801:
2802: /*
2803: --------------------------------------------------------------------------------
2804: Réalisation impossible de la fonction arctangente
2805: --------------------------------------------------------------------------------
2806: */
2807:
2808: else
2809: {
2810: liberation(s_etat_processus, s_objet_argument);
2811:
2812: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2813: return;
2814: }
2815:
2816: liberation(s_etat_processus, s_objet_argument);
2817:
2818: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2819: s_objet_resultat) == d_erreur)
2820: {
2821: return;
2822: }
2823:
2824: return;
2825: }
2826:
2827: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_a1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src