Annotation of rpl/src/instructions_c1.c, revision 1.6
1.1 bertrand 1: /*
2: ================================================================================
1.6 ! bertrand 3: RPL/2 (R) version 4.0.14
1.1 bertrand 4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
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:
23: #include "rpl.conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'clear'
29: ================================================================================
30: Entrées : structure processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_clear(struct_processus *s_etat_processus)
40: {
41: struct_liste_chainee *l_element_courant;
42: struct_liste_chainee *l_element_suivant;
43:
44: (*s_etat_processus).erreur_execution = d_ex;
45:
46: if ((*s_etat_processus).affichage_arguments == 'Y')
47: {
48: printf("\n CLEAR ");
49:
50: if ((*s_etat_processus).langue == 'F')
51: {
52: printf("(efface la pile)\n\n");
53: printf(" Aucun argument\n");
54: }
55: else
56: {
57: printf("(clear stack)\n\n");
58: printf(" No argument\n");
59: }
60:
61: return;
62: }
63: else if ((*s_etat_processus).test_instruction == 'Y')
64: {
65: (*s_etat_processus).nombre_arguments = -1;
66: return;
67: }
68:
69: if (test_cfsf(s_etat_processus, 31) == d_vrai)
70: {
71: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
72: {
73: return;
74: }
75: }
76:
77: l_element_courant = (*s_etat_processus).l_base_pile;
78: while(l_element_courant != NULL)
79: {
80: liberation(s_etat_processus, (*l_element_courant).donnee);
81: l_element_suivant = (*l_element_courant).suivant;
82:
83: // On ne libère le maillon de la chaîne. On le sauvegarde
84: // arbitrairement dans le tampon.
85:
86: (*l_element_courant).donnee = NULL;
87: (*l_element_courant).suivant = (*s_etat_processus).pile_tampon;
88: (*s_etat_processus).pile_tampon = l_element_courant;
89: (*s_etat_processus).taille_pile_tampon++;
90:
91: l_element_courant = l_element_suivant;
92: }
93:
94: (*s_etat_processus).l_base_pile = NULL;
95: (*s_etat_processus).hauteur_pile_operationnelle = 0;
96:
97: return;
98: }
99:
100:
101: /*
102: ================================================================================
103: Fonction 'cllcd' (efface la sortie graphique)
104: ================================================================================
105: Entrées : structure processus
106: --------------------------------------------------------------------------------
107: Sorties :
108: --------------------------------------------------------------------------------
109: Effets de bord : néant
110: ================================================================================
111: */
112:
113: void
114: instruction_cllcd(struct_processus *s_etat_processus)
115: {
116: struct_fichier_graphique *l_element_precedent;
117:
118: struct_marque *marque;
119: struct_marque *prochaine_marque;
120:
121: (*s_etat_processus).erreur_execution = d_ex;
122:
123: if ((*s_etat_processus).affichage_arguments == 'Y')
124: {
125: printf("\n CLLCD ");
126:
127: if ((*s_etat_processus).langue == 'F')
128: {
129: printf("(efface la file graphique)\n\n");
130: printf(" Aucun argument\n");
131: }
132: else
133: {
134: printf("(erase the graphical queue)\n\n");
135: printf(" No argument\n");
136: }
137:
138: return;
139: }
140: else if ((*s_etat_processus).test_instruction == 'Y')
141: {
142: (*s_etat_processus).nombre_arguments = -1;
143: return;
144: }
145:
146: if (test_cfsf(s_etat_processus, 31) == d_vrai)
147: {
148: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
149: {
150: return;
151: }
152: }
153:
154: while((*s_etat_processus).fichiers_graphiques != NULL)
155: {
156: if (destruction_fichier((*(*s_etat_processus).fichiers_graphiques).nom)
157: == d_erreur)
158: {
159: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
160: return;
161: }
162:
163: free((*(*s_etat_processus).fichiers_graphiques).nom);
164:
165: if ((*(*s_etat_processus).fichiers_graphiques).legende != NULL)
166: {
167: free((*(*s_etat_processus).fichiers_graphiques).legende);
168: }
169:
170: l_element_precedent = (*s_etat_processus).fichiers_graphiques;
171: (*s_etat_processus).fichiers_graphiques =
172: (*(*s_etat_processus).fichiers_graphiques).suivant;
173:
174: free(l_element_precedent);
175: }
176:
177: if ((*s_etat_processus).entree_standard != NULL)
178: {
179: if (fprintf((*s_etat_processus).entree_standard, "quit\n") < 0)
180: {
181: (*s_etat_processus).erreur_systeme = d_es_processus;
182: return;
183: }
184:
185: if (fflush((*s_etat_processus).entree_standard) != 0)
186: {
187: (*s_etat_processus).erreur_systeme = d_es_processus;
188: return;
189: }
190:
191: if (pclose((*s_etat_processus).entree_standard) == -1)
192: {
193: (*s_etat_processus).erreur_systeme = d_es_processus;
194: return;
195: }
196:
197: (*s_etat_processus).entree_standard = NULL;
198: }
199:
200: free((*s_etat_processus).titre);
201: free((*s_etat_processus).legende);
202: free((*s_etat_processus).label_x);
203: free((*s_etat_processus).label_y);
204: free((*s_etat_processus).label_z);
205:
206: (*s_etat_processus).titre = malloc(sizeof(unsigned char));
207: (*s_etat_processus).label_x = malloc(sizeof(unsigned char));
208: (*s_etat_processus).label_y = malloc(sizeof(unsigned char));
209: (*s_etat_processus).label_z = malloc(sizeof(unsigned char));
210: (*s_etat_processus).legende = malloc(sizeof(unsigned char));
211:
212: if (((*s_etat_processus).titre == NULL) ||
213: ((*s_etat_processus).legende == NULL) ||
214: ((*s_etat_processus).label_x == NULL) ||
215: ((*s_etat_processus).label_y == NULL) ||
216: ((*s_etat_processus).label_z == NULL))
217: {
218: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
219: return;
220: }
221:
222: (*s_etat_processus).titre[0] = d_code_fin_chaine;
223: (*s_etat_processus).label_x[0] = d_code_fin_chaine;
224: (*s_etat_processus).label_y[0] = d_code_fin_chaine;
225: (*s_etat_processus).label_z[0] = d_code_fin_chaine;
226: (*s_etat_processus).legende[0] = d_code_fin_chaine;
227:
228: marque = (*s_etat_processus).s_marques;
229:
230: while(marque != NULL)
231: {
232: free((*marque).position);
233: free((*marque).label);
234: prochaine_marque = (*marque).suivant;
235: free(marque);
236: marque = prochaine_marque;
237: }
238:
239: (*s_etat_processus).s_marques = NULL;
240:
241: return;
242: }
243:
244:
245: /*
246: ================================================================================
247: Fonction 'cf'
248: ================================================================================
249: Entrées : structure processus
250: --------------------------------------------------------------------------------
251: Sorties :
252: --------------------------------------------------------------------------------
253: Effets de bord : néant
254: ================================================================================
255: */
256:
257: void
258: instruction_cf(struct_processus *s_etat_processus)
259: {
260: struct_objet *s_objet;
261:
262: (*s_etat_processus).erreur_execution = d_ex;
263:
264: if ((*s_etat_processus).affichage_arguments == 'Y')
265: {
266: printf("\n CF ");
267:
268: if ((*s_etat_processus).langue == 'F')
269: {
270: printf("(efface un indicateur binaire)\n\n");
271: }
272: else
273: {
274: printf("(clear flag)\n\n");
275: }
276:
277: printf(" 1: 1 <= %s <= 64\n", d_INT);
278:
279: return;
280: }
281: else if ((*s_etat_processus).test_instruction == 'Y')
282: {
283: (*s_etat_processus).nombre_arguments = -1;
284: return;
285: }
286:
287: if (test_cfsf(s_etat_processus, 31) == d_vrai)
288: {
289: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
290: {
291: return;
292: }
293: }
294:
295: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
296: &s_objet) == d_erreur)
297: {
298: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
299: return;
300: }
301:
302: if ((*s_objet).type == INT)
303: {
304: if (((*((integer8 *) (*s_objet).objet)) < 1) || ((*((integer8 *)
305: (*s_objet).objet)) > 64))
306: {
307: liberation(s_etat_processus, s_objet);
308:
309: (*s_etat_processus).erreur_execution = d_ex_drapeau_inexistant;
310: return;
311: }
312:
313: cf(s_etat_processus, (unsigned char) (*((integer8 *)
314: (*s_objet).objet)));
315: }
316: else
317: {
318: liberation(s_etat_processus, s_objet);
319:
320: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
321: return;
322: }
323:
324: liberation(s_etat_processus, s_objet);
325:
326: return;
327: }
328:
329:
330: /*
331: ================================================================================
332: Fonction 'ceil'
333: ================================================================================
334: Entrées :
335: --------------------------------------------------------------------------------
336: Sorties :
337: --------------------------------------------------------------------------------
338: Effets de bord : néant
339: ================================================================================
340: */
341:
342: void
343: instruction_ceil(struct_processus *s_etat_processus)
344: {
345: struct_liste_chainee *l_element_courant;
346: struct_liste_chainee *l_element_precedent;
347:
348: struct_objet *s_copie_argument;
349: struct_objet *s_objet_argument;
350: struct_objet *s_objet_resultat;
351:
352: (*s_etat_processus).erreur_execution = d_ex;
353:
354: if ((*s_etat_processus).affichage_arguments == 'Y')
355: {
356: printf("\n CEIL ");
357:
358: if ((*s_etat_processus).langue == 'F')
359: {
360: printf("(entier supérieur)\n\n");
361: }
362: else
363: {
364: printf("(ceil)\n\n");
365: }
366:
367: printf(" 1: %s\n", d_INT);
368: printf("-> 1: %s\n\n", d_INT);
369:
370: printf(" 1: %s\n", d_REL);
371: printf("-> 1: %s\n\n", d_REL);
372:
373: printf(" 1: %s, %s\n", d_NOM, d_ALG);
374: printf("-> 1: %s\n\n", d_ALG);
375:
376: printf(" 1: %s\n", d_RPN);
377: printf("-> 1: %s\n", d_RPN);
378:
379: return;
380: }
381: else if ((*s_etat_processus).test_instruction == 'Y')
382: {
383: (*s_etat_processus).nombre_arguments = 1;
384: return;
385: }
386:
387: if (test_cfsf(s_etat_processus, 31) == d_vrai)
388: {
389: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
390: {
391: return;
392: }
393: }
394:
395: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
396: &s_objet_argument) == d_erreur)
397: {
398: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
399: return;
400: }
401:
402: /*
403: --------------------------------------------------------------------------------
404: Plafond d'un entier
405: --------------------------------------------------------------------------------
406: */
407:
408: if ((*s_objet_argument).type == INT)
409: {
410: s_objet_resultat = s_objet_argument;
411: s_objet_argument = NULL;
412: }
413:
414: /*
415: --------------------------------------------------------------------------------
416: Plafond d'un réel
417: --------------------------------------------------------------------------------
418: */
419:
420: else if ((*s_objet_argument).type == REL)
421: {
422: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
423: {
424: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
425: return;
426: }
427:
428: (*((integer8 *) (*s_objet_resultat).objet)) =
429: ceil((*((real8 *) (*s_objet_argument).objet)));
430:
431: if (!(((((*((integer8 *) (*s_objet_resultat).objet)) - 1) <
432: (*((real8 *) (*s_objet_argument).objet))) && ((*((integer8 *)
433: (*s_objet_resultat).objet)) > (*((real8 *) (*s_objet_argument)
434: .objet))))))
435: {
436: free((*s_objet_resultat).objet);
437:
438: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL)
439: {
440: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
441: return;
442: }
443:
444: (*s_objet_resultat).type = REL;
445: (*((real8 *) (*s_objet_resultat).objet)) =
446: ceil((*((real8 *) (*s_objet_argument).objet)));
447: }
448: }
449:
450: /*
451: --------------------------------------------------------------------------------
452: Plafond d'un nom
453: --------------------------------------------------------------------------------
454: */
455:
456: else if ((*s_objet_argument).type == NOM)
457: {
458: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
459: {
460: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
461: return;
462: }
463:
464: if (((*s_objet_resultat).objet =
465: allocation_maillon(s_etat_processus)) == NULL)
466: {
467: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
468: return;
469: }
470:
471: l_element_courant = (*s_objet_resultat).objet;
472:
473: if (((*l_element_courant).donnee =
474: allocation(s_etat_processus, FCT)) == NULL)
475: {
476: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
477: return;
478: }
479:
480: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
481: .nombre_arguments = 0;
482: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
483: .fonction = instruction_vers_niveau_superieur;
484:
485: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
486: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
487: {
488: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
489: return;
490: }
491:
492: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
493: .nom_fonction, "<<");
494:
495: if (((*l_element_courant).suivant =
496: allocation_maillon(s_etat_processus)) == NULL)
497: {
498: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
499: return;
500: }
501:
502: l_element_courant = (*l_element_courant).suivant;
503: (*l_element_courant).donnee = s_objet_argument;
504:
505: if (((*l_element_courant).suivant =
506: allocation_maillon(s_etat_processus)) == NULL)
507: {
508: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
509: return;
510: }
511:
512: l_element_courant = (*l_element_courant).suivant;
513:
514: if (((*l_element_courant).donnee =
515: allocation(s_etat_processus, FCT)) == NULL)
516: {
517: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
518: return;
519: }
520:
521: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
522: .nombre_arguments = 1;
523: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
524: .fonction = instruction_ceil;
525:
526: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
527: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
528: {
529: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
530: return;
531: }
532:
533: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
534: .nom_fonction, "CEIL");
535:
536: if (((*l_element_courant).suivant =
537: allocation_maillon(s_etat_processus)) == NULL)
538: {
539: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
540: return;
541: }
542:
543: l_element_courant = (*l_element_courant).suivant;
544:
545: if (((*l_element_courant).donnee =
546: allocation(s_etat_processus, FCT)) == NULL)
547: {
548: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
549: return;
550: }
551:
552: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
553: .nombre_arguments = 0;
554: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
555: .fonction = instruction_vers_niveau_inferieur;
556:
557: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
558: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
559: {
560: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
561: return;
562: }
563:
564: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
565: .nom_fonction, ">>");
566:
567: (*l_element_courant).suivant = NULL;
568: s_objet_argument = NULL;
569: }
570:
571: /*
572: --------------------------------------------------------------------------------
573: Plafond d'une expression
574: --------------------------------------------------------------------------------
575: */
576:
577: else if (((*s_objet_argument).type == ALG) ||
578: ((*s_objet_argument).type == RPN))
579: {
580: if ((s_copie_argument = copie_objet(s_etat_processus,
581: s_objet_argument, 'N')) == NULL)
582: {
583: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
584: return;
585: }
586:
587: l_element_courant = (struct_liste_chainee *)
588: (*s_copie_argument).objet;
589: l_element_precedent = l_element_courant;
590:
591: while((*l_element_courant).suivant != NULL)
592: {
593: l_element_precedent = l_element_courant;
594: l_element_courant = (*l_element_courant).suivant;
595: }
596:
597: if (((*l_element_precedent).suivant =
598: allocation_maillon(s_etat_processus)) == NULL)
599: {
600: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
601: return;
602: }
603:
604: if (((*(*l_element_precedent).suivant).donnee =
605: allocation(s_etat_processus, FCT)) == NULL)
606: {
607: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
608: return;
609: }
610:
611: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
612: .donnee).objet)).nombre_arguments = 1;
613: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
614: .donnee).objet)).fonction = instruction_ceil;
615:
616: if (((*((struct_fonction *) (*(*(*l_element_precedent)
617: .suivant).donnee).objet)).nom_fonction =
618: malloc(5 * sizeof(unsigned char))) == NULL)
619: {
620: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
621: return;
622: }
623:
624: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
625: .suivant).donnee).objet)).nom_fonction, "CEIL");
626:
627: (*(*l_element_precedent).suivant).suivant = l_element_courant;
628:
629: s_objet_resultat = s_copie_argument;
630: }
631:
632: /*
633: --------------------------------------------------------------------------------
634: Fonction ceil impossible à réaliser
635: --------------------------------------------------------------------------------
636: */
637:
638: else
639: {
640: liberation(s_etat_processus, s_objet_argument);
641:
642: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
643: return;
644: }
645:
646: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
647: s_objet_resultat) == d_erreur)
648: {
649: return;
650: }
651:
652: liberation(s_etat_processus, s_objet_argument);
653:
654: return;
655: }
656:
657:
658: /*
659: ================================================================================
660: Fonction 'case'
661: ================================================================================
662: Entrées :
663: --------------------------------------------------------------------------------
664: Sorties :
665: --------------------------------------------------------------------------------
666: Effets de bord : néant
667: ================================================================================
668: */
669:
670: void
671: instruction_case(struct_processus *s_etat_processus)
672: {
673: struct_objet *s_objet;
674:
675: (*s_etat_processus).erreur_execution = d_ex;
676:
677: if ((*s_etat_processus).affichage_arguments == 'Y')
678: {
679: printf("\n CASE ");
680:
681: if ((*s_etat_processus).langue == 'F')
682: {
683: printf("(structure de contrôle)\n\n");
684: printf(" Utilisation :\n\n");
685: }
686: else
687: {
688: printf("(control statement)\n\n");
689: printf(" Usage:\n\n");
690: }
691:
692: printf(" SELECT (expression test)\n");
693: printf(" CASE (clause 1) THEN (expression 1) END\n");
694: printf(" CASE (clause 2) THEN (expression 2) END\n");
695: printf(" ...\n");
696: printf(" CASE (clause n) THEN (expression n) END\n");
697: printf(" DEFAULT\n");
698: printf(" (expression)\n");
699: printf(" END\n\n");
700:
701: printf(" SELECT (expression test)\n");
702: printf(" CASE (clause 1) THEN (expression 1) END\n");
703: printf(" (expression)\n");
704: printf(" CASE (clause 2) THEN (expression 2) END\n");
705: printf(" END\n");
706:
707: return;
708: }
709: else if ((*s_etat_processus).test_instruction == 'Y')
710: {
711: (*s_etat_processus).nombre_arguments = -1;
712: return;
713: }
714:
715: if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'S')
716: {
717:
718: /*
719: * Première apparition de l'instruction CASE dans la structure de test.
720: */
721:
722: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
723: &s_objet) == d_erreur)
724: {
725: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
726: return;
727: }
728:
729: (*(*s_etat_processus).l_base_pile_systeme).objet_de_test = s_objet;
730: (*(*s_etat_processus).l_base_pile_systeme).clause = 'K';
731: }
732:
733: if ((s_objet = copie_objet(s_etat_processus,
734: (*(*s_etat_processus).l_base_pile_systeme)
735: .objet_de_test, 'P')) == NULL)
736: {
737: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
738: return;
739: }
740:
741: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
742: s_objet) == d_erreur)
743: {
744: return;
745: }
746:
747: return;
748: }
749:
750:
751: /*
752: ================================================================================
753: Fonction 'c->r'
754: ================================================================================
755: Entrées : structure processus
756: --------------------------------------------------------------------------------
757: Sorties :
758: --------------------------------------------------------------------------------
759: Effets de bord : néant
760: ================================================================================
761: */
762:
763: void
764: instruction_c_vers_r(struct_processus *s_etat_processus)
765: {
766: struct_objet *s_objet_argument;
767: struct_objet *s_objet_resultat_1;
768: struct_objet *s_objet_resultat_2;
769:
770: unsigned long i;
771: unsigned long j;
772:
773: (*s_etat_processus).erreur_execution = d_ex;
774:
775: if ((*s_etat_processus).affichage_arguments == 'Y')
776: {
777: printf("\n C->R ");
778:
779: if ((*s_etat_processus).langue == 'F')
780: {
781: printf("(complexe vers réel)\n\n");
782: }
783: else
784: {
785: printf("(complex to real)\n\n");
786: }
787:
788: printf(" 1: %s\n", d_CPL);
789: printf("-> 2: %s\n", d_REL);
790: printf(" 1: %s\n\n", d_REL);
791:
792: printf(" 1: %s\n", d_VCX);
793: printf("-> 2: %s\n", d_VRL);
794: printf(" 1: %s\n\n", d_VRL);
795:
796: printf(" 1: %s\n", d_MCX);
797: printf("-> 2: %s\n", d_MRL);
798: printf(" 1: %s\n", d_MRL);
799:
800: return;
801: }
802: else if ((*s_etat_processus).test_instruction == 'Y')
803: {
804: (*s_etat_processus).nombre_arguments = -1;
805: return;
806: }
807:
808: if (test_cfsf(s_etat_processus, 31) == d_vrai)
809: {
810: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
811: {
812: return;
813: }
814: }
815:
816: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
817: &s_objet_argument) == d_erreur)
818: {
819: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
820: return;
821: }
822:
823: /*
824: --------------------------------------------------------------------------------
825: Eclatement d'un complexe
826: --------------------------------------------------------------------------------
827: */
828:
829: if ((*s_objet_argument).type == CPL)
830: {
831: if ((s_objet_resultat_1 = allocation(s_etat_processus, REL))
832: == NULL)
833: {
834: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
835: return;
836: }
837:
838: if ((s_objet_resultat_2 = allocation(s_etat_processus, REL))
839: == NULL)
840: {
841: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
842: return;
843: }
844:
845: (*((real8 *) (*s_objet_resultat_1).objet)) =
846: (*((struct_complexe16 *) (*s_objet_argument).objet))
847: .partie_imaginaire;
848:
849: (*((real8 *) (*s_objet_resultat_2).objet)) =
850: (*((struct_complexe16 *) (*s_objet_argument).objet))
851: .partie_reelle;
852: }
853:
854: /*
855: --------------------------------------------------------------------------------
856: Eclatement d'un vecteur
857: --------------------------------------------------------------------------------
858: */
859:
860: else if ((*s_objet_argument).type == VCX)
861: {
862: if ((s_objet_resultat_1 = allocation(s_etat_processus, VRL))
863: == NULL)
864: {
865: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
866: return;
867: }
868:
869: if ((s_objet_resultat_2 = allocation(s_etat_processus, VRL))
870: == NULL)
871: {
872: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
873: return;
874: }
875:
876: if (((*((struct_vecteur *) (*s_objet_resultat_1).objet)).tableau =
877: malloc((*(((struct_vecteur *) (*s_objet_argument)
878: .objet))).taille * sizeof(real8))) == NULL)
879: {
880: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
881: return;
882: }
883:
884: if (((*((struct_vecteur *) (*s_objet_resultat_2).objet)).tableau =
885: malloc((*(((struct_vecteur *) (*s_objet_argument)
886: .objet))).taille * sizeof(real8))) == NULL)
887: {
888: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
889: return;
890: }
891:
892: (*((struct_vecteur *) (*s_objet_resultat_1).objet)).taille =
893: (*(((struct_vecteur *) (*s_objet_argument).objet))).taille;
894: (*((struct_vecteur *) (*s_objet_resultat_2).objet)).taille =
895: (*(((struct_vecteur *) (*s_objet_argument).objet))).taille;
896:
897: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))
898: .taille; i++)
899: {
900: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat_1).objet))
901: .tableau)[i] = ((struct_complexe16 *) (*((struct_vecteur *)
902: (*s_objet_argument).objet)).tableau)[i].partie_imaginaire;
903:
904: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat_2).objet))
905: .tableau)[i] = ((struct_complexe16 *) (*((struct_vecteur *)
906: (*s_objet_argument).objet)).tableau)[i].partie_reelle;
907: }
908: }
909:
910: /*
911: --------------------------------------------------------------------------------
912: Eclatement d'une matrice
913: --------------------------------------------------------------------------------
914: */
915:
916: else if ((*s_objet_argument).type == MCX)
917: {
918: if ((s_objet_resultat_1 = allocation(s_etat_processus, MRL))
919: == NULL)
920: {
921: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
922: return;
923: }
924:
925: if ((s_objet_resultat_2 = allocation(s_etat_processus, MRL))
926: == NULL)
927: {
928: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
929: return;
930: }
931:
932: if (((*((struct_matrice *) (*s_objet_resultat_1).objet)).tableau =
933: malloc((*(((struct_matrice *) (*s_objet_argument)
934: .objet))).nombre_lignes * sizeof(real8 *))) == NULL)
935: {
936: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
937: return;
938: }
939:
940: if (((*((struct_matrice *) (*s_objet_resultat_2).objet)).tableau =
941: malloc((*(((struct_matrice *) (*s_objet_argument)
942: .objet))).nombre_lignes * sizeof(real8 *))) == NULL)
943: {
944: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
945: return;
946: }
947:
948: (*((struct_matrice *) (*s_objet_resultat_1).objet)).nombre_lignes =
949: (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;
950: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_lignes =
951: (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;
952: (*((struct_matrice *) (*s_objet_resultat_1).objet)).nombre_colonnes =
953: (*((struct_matrice *) (*s_objet_argument).objet))
954: .nombre_colonnes;
955: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_colonnes =
956: (*((struct_matrice *) (*s_objet_argument).objet))
957: .nombre_colonnes;
958:
959: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument).objet)))
960: .nombre_lignes; i++)
961: {
962: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_1)
963: .objet)).tableau)[i] = malloc(
964: (*(((struct_matrice *) (*s_objet_argument).objet)))
965: .nombre_colonnes * sizeof(real8))) == NULL)
966: {
967: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
968: return;
969: }
970:
971: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
972: .objet)).tableau)[i] = malloc(
973: (*(((struct_matrice *) (*s_objet_argument).objet)))
974: .nombre_colonnes * sizeof(real8))) == NULL)
975: {
976: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
977: return;
978: }
979:
980: for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument).objet)))
981: .nombre_colonnes; j++)
982: {
983: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_1).objet))
984: .tableau)[i][j] = ((struct_complexe16 **)
985: (*((struct_matrice *) (*s_objet_argument).objet))
986: .tableau)[i][j].partie_imaginaire;
987:
988: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2).objet))
989: .tableau)[i][j] = ((struct_complexe16 **)
990: (*((struct_matrice *) (*s_objet_argument).objet))
991: .tableau)[i][j].partie_reelle;
992: }
993: }
994: }
995:
996: /*
997: --------------------------------------------------------------------------------
998: Eclatement impossible
999: --------------------------------------------------------------------------------
1000: */
1001:
1002: else
1003: {
1004: liberation(s_etat_processus, s_objet_argument);
1005:
1006: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1007: return;
1008: }
1009:
1010: liberation(s_etat_processus, s_objet_argument);
1011:
1012: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1013: s_objet_resultat_2) == d_erreur)
1014: {
1015: return;
1016: }
1017:
1018: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1019: s_objet_resultat_1) == d_erreur)
1020: {
1021: return;
1022: }
1023:
1024: return;
1025: }
1026:
1027:
1028: /*
1029: ================================================================================
1030: Fonction 'conj'
1031: ================================================================================
1032: Entrées :
1033: --------------------------------------------------------------------------------
1034: Sorties :
1035: --------------------------------------------------------------------------------
1036: Effets de bord : néant
1037: ================================================================================
1038: */
1039:
1040: void
1041: instruction_conj(struct_processus *s_etat_processus)
1042: {
1043: struct_liste_chainee *l_element_courant;
1044: struct_liste_chainee *l_element_precedent;
1045:
1046: struct_objet *s_copie_argument;
1047: struct_objet *s_objet_argument;
1048: struct_objet *s_objet_resultat;
1049:
1050: unsigned long i;
1051: unsigned long j;
1052:
1053: (*s_etat_processus).erreur_execution = d_ex;
1054:
1055: if ((*s_etat_processus).affichage_arguments == 'Y')
1056: {
1057: printf("\n CONJ ");
1058:
1059: if ((*s_etat_processus).langue == 'F')
1060: {
1061: printf("(conjugaison)\n\n");
1062: }
1063: else
1064: {
1065: printf("(conjugated)\n\n");
1066: }
1067:
1068: printf(" 1: %s\n", d_INT);
1069: printf("-> 1: %s\n\n", d_INT);
1070:
1071: printf(" 1: %s\n", d_REL);
1072: printf("-> 1: %s\n\n", d_REL);
1073:
1074: printf(" 1: %s\n", d_CPL);
1075: printf("-> 1: %s\n\n", d_CPL);
1076:
1077: printf(" 1: %s\n", d_VIN);
1078: printf("-> 1: %s\n\n", d_VIN);
1079:
1080: printf(" 1: %s\n", d_VRL);
1081: printf("-> 1: %s\n\n", d_VRL);
1082:
1083: printf(" 1: %s\n", d_VCX);
1084: printf("-> 1: %s\n\n", d_VCX);
1085:
1086: printf(" 1: %s\n", d_MIN);
1087: printf("-> 1: %s\n\n", d_MIN);
1088:
1089: printf(" 1: %s\n", d_MRL);
1090: printf("-> 1: %s\n\n", d_MRL);
1091:
1092: printf(" 1: %s\n", d_MCX);
1093: printf("-> 1: %s\n\n", d_MCX);
1094:
1095: printf(" 1: %s, %s\n", d_NOM, d_ALG);
1096: printf("-> 1: %s\n\n", d_ALG);
1097:
1098: printf(" 1: %s\n", d_RPN);
1099: printf("-> 1: %s\n", d_RPN);
1100:
1101: return;
1102: }
1103: else if ((*s_etat_processus).test_instruction == 'Y')
1104: {
1105: (*s_etat_processus).nombre_arguments = 1;
1106: return;
1107: }
1108:
1109: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1110: {
1111: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1112: {
1113: return;
1114: }
1115: }
1116:
1117: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1118: &s_objet_argument) == d_erreur)
1119: {
1120: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1121: return;
1122: }
1123:
1124: /*
1125: --------------------------------------------------------------------------------
1126: Conjugué d'un entier ou d'un réel
1127: --------------------------------------------------------------------------------
1128: */
1129:
1130: if (((*s_objet_argument).type == INT) ||
1131: ((*s_objet_argument).type == REL))
1132: {
1133: s_objet_resultat = s_objet_argument;
1134: s_objet_argument = NULL;
1135: }
1136:
1137: /*
1138: --------------------------------------------------------------------------------
1139: Conjugué d'un complexe
1140: --------------------------------------------------------------------------------
1141: */
1142:
1143: else if ((*s_objet_argument).type == CPL)
1144: {
1145: (*((struct_complexe16 *) (*s_objet_argument).objet)).partie_reelle =
1146: (*((struct_complexe16 *) (*s_objet_argument).objet))
1147: .partie_reelle;
1148: (*((struct_complexe16 *) (*s_objet_argument).objet)).partie_imaginaire =
1149: -(*((struct_complexe16 *) (*s_objet_argument).objet))
1150: .partie_imaginaire;
1151:
1152: s_objet_resultat = s_objet_argument;
1153: s_objet_argument = NULL;
1154: }
1155:
1156: /*
1157: --------------------------------------------------------------------------------
1158: Conjugué d'un vecteur d'entiers ou de réels
1159: --------------------------------------------------------------------------------
1160: */
1161:
1162: else if (((*s_objet_argument).type == VIN) ||
1163: ((*s_objet_argument).type == VRL))
1164: {
1165: s_objet_resultat = s_objet_argument;
1166: s_objet_argument = NULL;
1167: }
1168:
1169: /*
1170: --------------------------------------------------------------------------------
1171: Conjugué d'un vecteur de complexes
1172: --------------------------------------------------------------------------------
1173: */
1174:
1175: else if ((*s_objet_argument).type == VCX)
1176: {
1177: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))
1178: .taille; i++)
1179: {
1180: ((struct_complexe16 *) (*(((struct_vecteur *) (*s_objet_argument)
1181: .objet))).tableau)[i].partie_reelle =
1182: ((struct_complexe16 *) (*(((struct_vecteur *)
1183: (*s_objet_argument).objet))).tableau)[i].partie_reelle;
1184: ((struct_complexe16 *) (*(((struct_vecteur *) (*s_objet_argument)
1185: .objet))).tableau)[i].partie_imaginaire =
1186: -((struct_complexe16 *) (*(((struct_vecteur *)
1187: (*s_objet_argument).objet))).tableau)[i].partie_imaginaire;
1188: }
1189:
1190: s_objet_resultat = s_objet_argument;
1191: s_objet_argument = NULL;
1192: }
1193:
1194: /*
1195: --------------------------------------------------------------------------------
1196: Conjuguée d'une matrice d'entiers ou de réels
1197: --------------------------------------------------------------------------------
1198: */
1199:
1200: else if (((*s_objet_argument).type == MIN) ||
1201: ((*s_objet_argument).type == MRL))
1202: {
1203: s_objet_resultat = s_objet_argument;
1204: s_objet_argument = NULL;
1205: }
1206:
1207: /*
1208: --------------------------------------------------------------------------------
1209: Conjuguée d'une matrice de complexes
1210: --------------------------------------------------------------------------------
1211: */
1212:
1213: else if ((*s_objet_argument).type == MCX)
1214: {
1215: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument).objet)))
1216: .nombre_lignes; i++)
1217: {
1218: for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument).objet)))
1219: .nombre_colonnes; j++)
1220: {
1221: ((struct_complexe16 **) (*(((struct_matrice *)
1222: (*s_objet_argument).objet))).tableau)[i][j]
1223: .partie_reelle = ((struct_complexe16 **)
1224: (*(((struct_matrice *) (*s_objet_argument).objet)))
1225: .tableau)[i][j].partie_reelle;
1226: ((struct_complexe16 **) (*(((struct_matrice *)
1227: (*s_objet_argument).objet))).tableau)[i][j]
1228: .partie_imaginaire = -((struct_complexe16 **)
1229: (*(((struct_matrice *) (*s_objet_argument).objet)))
1230: .tableau)[i][j].partie_imaginaire;
1231: }
1232: }
1233:
1234: s_objet_resultat = s_objet_argument;
1235: s_objet_argument = NULL;
1236: }
1237:
1238: /*
1239: --------------------------------------------------------------------------------
1240: Conjugué d'un nom
1241: --------------------------------------------------------------------------------
1242: */
1243:
1244: else if ((*s_objet_argument).type == NOM)
1245: {
1246: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
1247: == NULL)
1248: {
1249: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1250: return;
1251: }
1252:
1253: if (((*s_objet_resultat).objet =
1254: allocation_maillon(s_etat_processus)) == NULL)
1255: {
1256: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1257: return;
1258: }
1259:
1260: l_element_courant = (*s_objet_resultat).objet;
1261:
1262: if (((*l_element_courant).donnee =
1263: allocation(s_etat_processus, FCT)) == NULL)
1264: {
1265: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1266: return;
1267: }
1268:
1269: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1270: .nombre_arguments = 0;
1271: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1272: .fonction = instruction_vers_niveau_superieur;
1273:
1274: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1275: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1276: {
1277: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1278: return;
1279: }
1280:
1281: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1282: .nom_fonction, "<<");
1283:
1284: if (((*l_element_courant).suivant =
1285: allocation_maillon(s_etat_processus)) == NULL)
1286: {
1287: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1288: return;
1289: }
1290:
1291: l_element_courant = (*l_element_courant).suivant;
1292: (*l_element_courant).donnee = s_objet_argument;
1293:
1294: if (((*l_element_courant).suivant =
1295: allocation_maillon(s_etat_processus)) == NULL)
1296: {
1297: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1298: return;
1299: }
1300:
1301: l_element_courant = (*l_element_courant).suivant;
1302:
1303: if (((*l_element_courant).donnee =
1304: allocation(s_etat_processus, FCT)) == NULL)
1305: {
1306: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1307: return;
1308: }
1309:
1310: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1311: .nombre_arguments = 1;
1312: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1313: .fonction = instruction_conj;
1314:
1315: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1316: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
1317: {
1318: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1319: return;
1320: }
1321:
1322: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1323: .nom_fonction, "CONJ");
1324:
1325: if (((*l_element_courant).suivant =
1326: allocation_maillon(s_etat_processus)) == NULL)
1327: {
1328: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1329: return;
1330: }
1331:
1332: l_element_courant = (*l_element_courant).suivant;
1333:
1334: if (((*l_element_courant).donnee =
1335: allocation(s_etat_processus, FCT)) == NULL)
1336: {
1337: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1338: return;
1339: }
1340:
1341: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1342: .nombre_arguments = 0;
1343: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1344: .fonction = instruction_vers_niveau_inferieur;
1345:
1346: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1347: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1348: {
1349: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1350: return;
1351: }
1352:
1353: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1354: .nom_fonction, ">>");
1355:
1356: (*l_element_courant).suivant = NULL;
1357: s_objet_argument = NULL;
1358: }
1359:
1360: /*
1361: --------------------------------------------------------------------------------
1362: Conjuguée d'une expression
1363: --------------------------------------------------------------------------------
1364: */
1365:
1366: else if (((*s_objet_argument).type == ALG) ||
1367: ((*s_objet_argument).type == RPN))
1368: {
1369: if ((s_copie_argument = copie_objet(s_etat_processus,
1370: s_objet_argument, 'N')) == NULL)
1371: {
1372: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1373: return;
1374: }
1375:
1376: l_element_courant = (struct_liste_chainee *)
1377: (*s_copie_argument).objet;
1378: l_element_precedent = l_element_courant;
1379:
1380: while((*l_element_courant).suivant != NULL)
1381: {
1382: l_element_precedent = l_element_courant;
1383: l_element_courant = (*l_element_courant).suivant;
1384: }
1385:
1386: if (((*l_element_precedent).suivant =
1387: allocation_maillon(s_etat_processus)) == NULL)
1388: {
1389: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1390: return;
1391: }
1392:
1393: if (((*(*l_element_precedent).suivant).donnee =
1394: allocation(s_etat_processus, FCT)) == NULL)
1395: {
1396: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1397: return;
1398: }
1399:
1400: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1401: .donnee).objet)).nombre_arguments = 1;
1402: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1403: .donnee).objet)).fonction = instruction_conj;
1404:
1405: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1406: .suivant).donnee).objet)).nom_fonction =
1407: malloc(5 * sizeof(unsigned char))) == NULL)
1408: {
1409: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1410: return;
1411: }
1412:
1413: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1414: .suivant).donnee).objet)).nom_fonction, "CONJ");
1415:
1416: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1417:
1418: s_objet_resultat = s_copie_argument;
1419: }
1420:
1421: /*
1422: --------------------------------------------------------------------------------
1423: Conjugaison impossible
1424: --------------------------------------------------------------------------------
1425: */
1426:
1427: else
1428: {
1429: liberation(s_etat_processus, s_objet_argument);
1430:
1431: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1432: return;
1433: }
1434:
1435: liberation(s_etat_processus, s_objet_argument);
1436:
1437: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1438: s_objet_resultat) == d_erreur)
1439: {
1440: return;
1441: }
1442:
1443: return;
1444: }
1445:
1446:
1447: /*
1448: ================================================================================
1449: Fonction 'cos'
1450: ================================================================================
1451: Entrées : pointeur sur une structure struct_processus
1452: --------------------------------------------------------------------------------
1453: Sorties :
1454: --------------------------------------------------------------------------------
1455: Effets de bord : néant
1456: ================================================================================
1457: */
1458:
1459: void
1460: instruction_cos(struct_processus *s_etat_processus)
1461: {
1462: real8 angle;
1463:
1464: struct_liste_chainee *l_element_courant;
1465: struct_liste_chainee *l_element_precedent;
1466:
1467: struct_objet *s_copie_argument;
1468: struct_objet *s_objet_argument;
1469: struct_objet *s_objet_resultat;
1470:
1471: (*s_etat_processus).erreur_execution = d_ex;
1472:
1473: if ((*s_etat_processus).affichage_arguments == 'Y')
1474: {
1475: printf("\n COS ");
1476:
1477: if ((*s_etat_processus).langue == 'F')
1478: {
1479: printf("(cosinus)\n\n");
1480: }
1481: else
1482: {
1483: printf("(cosine)\n\n");
1484: }
1485:
1486: printf(" 1: %s, %s\n", d_INT, d_REL);
1487: printf("-> 1: %s\n\n", d_REL);
1488:
1489: printf(" 1: %s\n", d_CPL);
1490: printf("-> 1: %s\n\n", d_CPL);
1491:
1492: printf(" 1: %s, %s\n", d_NOM, d_ALG);
1493: printf("-> 1: %s\n\n", d_ALG);
1494:
1495: printf(" 1: %s\n", d_RPN);
1496: printf("-> 1: %s\n", d_RPN);
1497:
1498: return;
1499: }
1500: else if ((*s_etat_processus).test_instruction == 'Y')
1501: {
1502: (*s_etat_processus).nombre_arguments = 1;
1503: return;
1504: }
1505:
1506: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1507: {
1508: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1509: {
1510: return;
1511: }
1512: }
1513:
1514: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1515: &s_objet_argument) == d_erreur)
1516: {
1517: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1518: return;
1519: }
1520:
1521: /*
1522: --------------------------------------------------------------------------------
1523: Cosinus d'un entier ou d'un réel
1524: --------------------------------------------------------------------------------
1525: */
1526:
1527: if (((*s_objet_argument).type == INT) ||
1528: ((*s_objet_argument).type == REL))
1529: {
1530: if ((s_objet_resultat = allocation(s_etat_processus, REL))
1531: == NULL)
1532: {
1533: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1534: return;
1535: }
1536:
1537: if ((*s_objet_argument).type == INT)
1538: {
1539: angle = (real8) (*((integer8 *) (*s_objet_argument).objet));
1540: }
1541: else
1542: {
1543: angle = (*((real8 *) (*s_objet_argument).objet));
1544: }
1545:
1546: if (test_cfsf(s_etat_processus, 60) == d_faux)
1547: {
1548: conversion_degres_vers_radians(&angle);
1549: }
1550:
1551: (*((real8 *) (*s_objet_resultat).objet)) = cos(angle);
1552: }
1553:
1554: /*
1555: --------------------------------------------------------------------------------
1556: Cosinus d'un complexe
1557: --------------------------------------------------------------------------------
1558: */
1559:
1560: else if ((*s_objet_argument).type == CPL)
1561: {
1562: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
1563: == NULL)
1564: {
1565: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1566: return;
1567: }
1568:
1569: f77cos_((struct_complexe16 *) (*s_objet_argument).objet,
1570: (struct_complexe16 *) (*s_objet_resultat).objet);
1571: }
1572:
1573: /*
1574: --------------------------------------------------------------------------------
1575: Cosinus d'un nom
1576: --------------------------------------------------------------------------------
1577: */
1578:
1579: else if ((*s_objet_argument).type == NOM)
1580: {
1581: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
1582: == NULL)
1583: {
1584: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1585: return;
1586: }
1587:
1588: if (((*s_objet_resultat).objet =
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 = (*s_objet_resultat).objet;
1596:
1597: if (((*l_element_courant).donnee =
1598: allocation(s_etat_processus, FCT)) == NULL)
1599: {
1600: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1601: return;
1602: }
1603:
1604: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1605: .nombre_arguments = 0;
1606: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1607: .fonction = instruction_vers_niveau_superieur;
1608:
1609: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1610: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1611: {
1612: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1613: return;
1614: }
1615:
1616: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1617: .nom_fonction, "<<");
1618:
1619: if (((*l_element_courant).suivant =
1620: allocation_maillon(s_etat_processus)) == NULL)
1621: {
1622: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1623: return;
1624: }
1625:
1626: l_element_courant = (*l_element_courant).suivant;
1627: (*l_element_courant).donnee = s_objet_argument;
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 = 1;
1647: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1648: .fonction = instruction_cos;
1649:
1650: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1651: .nom_fonction = malloc(4 * 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, "COS");
1659:
1660: if (((*l_element_courant).suivant =
1661: allocation_maillon(s_etat_processus)) == NULL)
1662: {
1663: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1664: return;
1665: }
1666:
1667: l_element_courant = (*l_element_courant).suivant;
1668:
1669: if (((*l_element_courant).donnee =
1670: allocation(s_etat_processus, FCT)) == NULL)
1671: {
1672: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1673: return;
1674: }
1675:
1676: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1677: .nombre_arguments = 0;
1678: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1679: .fonction = instruction_vers_niveau_inferieur;
1680:
1681: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1682: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1683: {
1684: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1685: return;
1686: }
1687:
1688: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1689: .nom_fonction, ">>");
1690:
1691: (*l_element_courant).suivant = NULL;
1692: s_objet_argument = NULL;
1693: }
1694:
1695: /*
1696: --------------------------------------------------------------------------------
1697: Cosinus d'une expression
1698: --------------------------------------------------------------------------------
1699: */
1700:
1701: else if (((*s_objet_argument).type == ALG) ||
1702: ((*s_objet_argument).type == RPN))
1703: {
1704: if ((s_copie_argument = copie_objet(s_etat_processus,
1705: s_objet_argument, 'N')) == NULL)
1706: {
1707: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1708: return;
1709: }
1710:
1711: l_element_courant = (struct_liste_chainee *)
1712: (*s_copie_argument).objet;
1713: l_element_precedent = l_element_courant;
1714:
1715: while((*l_element_courant).suivant != NULL)
1716: {
1717: l_element_precedent = l_element_courant;
1718: l_element_courant = (*l_element_courant).suivant;
1719: }
1720:
1721: if (((*l_element_precedent).suivant =
1722: allocation_maillon(s_etat_processus)) == NULL)
1723: {
1724: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1725: return;
1726: }
1727:
1728: if (((*(*l_element_precedent).suivant).donnee =
1729: allocation(s_etat_processus, FCT)) == NULL)
1730: {
1731: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1732: return;
1733: }
1734:
1735: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1736: .donnee).objet)).nombre_arguments = 1;
1737: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
1738: .donnee).objet)).fonction = instruction_cos;
1739:
1740: if (((*((struct_fonction *) (*(*(*l_element_precedent)
1741: .suivant).donnee).objet)).nom_fonction =
1742: malloc(4 * sizeof(unsigned char))) == NULL)
1743: {
1744: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1745: return;
1746: }
1747:
1748: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
1749: .suivant).donnee).objet)).nom_fonction, "COS");
1750:
1751: (*(*l_element_precedent).suivant).suivant = l_element_courant;
1752:
1753: s_objet_resultat = s_copie_argument;
1754: }
1755:
1756: /*
1757: --------------------------------------------------------------------------------
1758: Réalisation impossible de la fonction cosinus
1759: --------------------------------------------------------------------------------
1760: */
1761:
1762: else
1763: {
1764: liberation(s_etat_processus, s_objet_argument);
1765:
1766: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1767: return;
1768: }
1769:
1770: liberation(s_etat_processus, s_objet_argument);
1771:
1772: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1773: s_objet_resultat) == d_erreur)
1774: {
1775: return;
1776: }
1777:
1778: return;
1779: }
1780:
1781:
1782: /*
1783: ================================================================================
1784: Fonction 'cosh'
1785: ================================================================================
1786: Entrées : pointeur sur une structure struct_processus
1787: --------------------------------------------------------------------------------
1788: Sorties :
1789: --------------------------------------------------------------------------------
1790: Effets de bord : néant
1791: ================================================================================
1792: */
1793:
1794: void
1795: instruction_cosh(struct_processus *s_etat_processus)
1796: {
1797: real8 argument;
1798:
1799: struct_liste_chainee *l_element_courant;
1800: struct_liste_chainee *l_element_precedent;
1801:
1802: struct_objet *s_copie_argument;
1803: struct_objet *s_objet_argument;
1804: struct_objet *s_objet_resultat;
1805:
1806: (*s_etat_processus).erreur_execution = d_ex;
1807:
1808: if ((*s_etat_processus).affichage_arguments == 'Y')
1809: {
1810: printf("\n COSH ");
1811:
1812: if ((*s_etat_processus).langue == 'F')
1813: {
1814: printf("(cosinus hyperbolique)\n\n");
1815: }
1816: else
1817: {
1818: printf("(hyperbolic cosine)\n\n");
1819: }
1820:
1821: printf(" 1: %s, %s\n", d_INT, d_REL);
1822: printf("-> 1: %s\n\n", d_INT);
1823:
1824: printf(" 1: %s\n", d_CPL);
1825: printf("-> 1: %s\n\n", d_CPL);
1826:
1827: printf(" 1: %s, %s\n", d_NOM, d_ALG);
1828: printf("-> 1: %s\n\n", d_ALG);
1829:
1830: printf(" 1: %s\n", d_RPN);
1831: printf("-> 1: %s\n", d_RPN);
1832:
1833: return;
1834: }
1835: else if ((*s_etat_processus).test_instruction == 'Y')
1836: {
1837: (*s_etat_processus).nombre_arguments = 1;
1838: return;
1839: }
1840:
1841: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1842: {
1843: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1844: {
1845: return;
1846: }
1847: }
1848:
1849: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1850: &s_objet_argument) == d_erreur)
1851: {
1852: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1853: return;
1854: }
1855:
1856: /*
1857: --------------------------------------------------------------------------------
1858: Cosinus hyperbolique d'un entier ou d'un réel
1859: --------------------------------------------------------------------------------
1860: */
1861:
1862: if (((*s_objet_argument).type == INT) ||
1863: ((*s_objet_argument).type == REL))
1864: {
1865: if ((s_objet_resultat = allocation(s_etat_processus, REL))
1866: == NULL)
1867: {
1868: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1869: return;
1870: }
1871:
1872: if ((*s_objet_argument).type == INT)
1873: {
1874: argument = (real8) (*((integer8 *) (*s_objet_argument).objet));
1875: }
1876: else
1877: {
1878: argument = (*((real8 *) (*s_objet_argument).objet));
1879: }
1880:
1881: (*((real8 *) (*s_objet_resultat).objet)) = cosh(argument);
1882: }
1883:
1884: /*
1885: --------------------------------------------------------------------------------
1886: Cosinus hyperbolique d'un complexe
1887: --------------------------------------------------------------------------------
1888: */
1889:
1890: else if ((*s_objet_argument).type == CPL)
1891: {
1892: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
1893: == NULL)
1894: {
1895: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1896: return;
1897: }
1898:
1899: f77cosh_((struct_complexe16 *) (*s_objet_argument).objet,
1900: (struct_complexe16 *) (*s_objet_resultat).objet);
1901: }
1902:
1903: /*
1904: --------------------------------------------------------------------------------
1905: Cosinus hyperbolique d'un nom
1906: --------------------------------------------------------------------------------
1907: */
1908:
1909: else if ((*s_objet_argument).type == NOM)
1910: {
1911: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
1912: == NULL)
1913: {
1914: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1915: return;
1916: }
1917:
1918: if (((*s_objet_resultat).objet =
1919: allocation_maillon(s_etat_processus)) == NULL)
1920: {
1921: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1922: return;
1923: }
1924:
1925: l_element_courant = (*s_objet_resultat).objet;
1926:
1927: if (((*l_element_courant).donnee =
1928: allocation(s_etat_processus, FCT)) == NULL)
1929: {
1930: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1931: return;
1932: }
1933:
1934: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1935: .nombre_arguments = 0;
1936: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1937: .fonction = instruction_vers_niveau_superieur;
1938:
1939: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1940: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1941: {
1942: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1943: return;
1944: }
1945:
1946: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1947: .nom_fonction, "<<");
1948:
1949: if (((*l_element_courant).suivant =
1950: allocation_maillon(s_etat_processus)) == NULL)
1951: {
1952: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1953: return;
1954: }
1955:
1956: l_element_courant = (*l_element_courant).suivant;
1957: (*l_element_courant).donnee = s_objet_argument;
1958:
1959: if (((*l_element_courant).suivant =
1960: allocation_maillon(s_etat_processus)) == NULL)
1961: {
1962: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1963: return;
1964: }
1965:
1966: l_element_courant = (*l_element_courant).suivant;
1967:
1968: if (((*l_element_courant).donnee =
1969: allocation(s_etat_processus, FCT)) == NULL)
1970: {
1971: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1972: return;
1973: }
1974:
1975: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1976: .nombre_arguments = 1;
1977: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1978: .fonction = instruction_cosh;
1979:
1980: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1981: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
1982: {
1983: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1984: return;
1985: }
1986:
1987: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1988: .nom_fonction, "COSH");
1989:
1990: if (((*l_element_courant).suivant =
1991: allocation_maillon(s_etat_processus)) == NULL)
1992: {
1993: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1994: return;
1995: }
1996:
1997: l_element_courant = (*l_element_courant).suivant;
1998:
1999: if (((*l_element_courant).donnee =
2000: allocation(s_etat_processus, FCT)) == NULL)
2001: {
2002: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2003: return;
2004: }
2005:
2006: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2007: .nombre_arguments = 0;
2008: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2009: .fonction = instruction_vers_niveau_inferieur;
2010:
2011: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2012: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
2013: {
2014: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2015: return;
2016: }
2017:
2018: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2019: .nom_fonction, ">>");
2020:
2021: (*l_element_courant).suivant = NULL;
2022: s_objet_argument = NULL;
2023: }
2024:
2025: /*
2026: --------------------------------------------------------------------------------
2027: Cosinus hyperbolique d'une expression
2028: --------------------------------------------------------------------------------
2029: */
2030:
2031: else if (((*s_objet_argument).type == ALG) ||
2032: ((*s_objet_argument).type == RPN))
2033: {
2034: if ((s_copie_argument = copie_objet(s_etat_processus,
2035: s_objet_argument, 'N')) == NULL)
2036: {
2037: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2038: return;
2039: }
2040:
2041: l_element_courant = (struct_liste_chainee *)
2042: (*s_copie_argument).objet;
2043: l_element_precedent = l_element_courant;
2044:
2045: while((*l_element_courant).suivant != NULL)
2046: {
2047: l_element_precedent = l_element_courant;
2048: l_element_courant = (*l_element_courant).suivant;
2049: }
2050:
2051: if (((*l_element_precedent).suivant =
2052: allocation_maillon(s_etat_processus)) == NULL)
2053: {
2054: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2055: return;
2056: }
2057:
2058: if (((*(*l_element_precedent).suivant).donnee =
2059: allocation(s_etat_processus, FCT)) == NULL)
2060: {
2061: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2062: return;
2063: }
2064:
2065: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2066: .donnee).objet)).nombre_arguments = 1;
2067: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2068: .donnee).objet)).fonction = instruction_cosh;
2069:
2070: if (((*((struct_fonction *) (*(*(*l_element_precedent)
2071: .suivant).donnee).objet)).nom_fonction =
2072: malloc(5 * sizeof(unsigned char))) == NULL)
2073: {
2074: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2075: return;
2076: }
2077:
2078: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
2079: .suivant).donnee).objet)).nom_fonction, "COSH");
2080:
2081: (*(*l_element_precedent).suivant).suivant = l_element_courant;
2082:
2083: s_objet_resultat = s_copie_argument;
2084: }
2085:
2086: /*
2087: --------------------------------------------------------------------------------
2088: Réalisation impossible de la fonction cosinus hyperbolique
2089: --------------------------------------------------------------------------------
2090: */
2091:
2092: else
2093: {
2094: liberation(s_etat_processus, s_objet_argument);
2095:
2096: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2097: return;
2098: }
2099:
2100: liberation(s_etat_processus, s_objet_argument);
2101:
2102: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2103: s_objet_resultat) == d_erreur)
2104: {
2105: return;
2106: }
2107:
2108: return;
2109: }
2110:
2111: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_c1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src