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