1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.32
4: Copyright (C) 1989-2020 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 'xroot'
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_xroot(struct_processus *s_etat_processus)
40: {
41: real8 argument;
42: real8 module;
43:
44: struct_liste_chainee *l_element_courant;
45: struct_liste_chainee *l_element_precedent;
46:
47: struct_objet *s_copie_argument_1;
48: struct_objet *s_copie_argument_2;
49: struct_objet *s_objet_argument_1;
50: struct_objet *s_objet_argument_2;
51: struct_objet *s_objet_resultat;
52:
53: unsigned long nombre_elements;
54:
55: (*s_etat_processus).erreur_execution = d_ex;
56:
57: if ((*s_etat_processus).affichage_arguments == 'Y')
58: {
59: printf("\n XROOT ");
60:
61: if ((*s_etat_processus).langue == 'F')
62: {
63: printf("(racine n-ième)\n\n");
64: }
65: else
66: {
67: printf("(Nth root)\n\n");
68: }
69:
70: printf(" 2: %s, %s, %s\n", d_INT, d_REL, d_CPL);
71: printf(" 1: %s\n", d_INT);
72: printf("-> 1: %s, %s\n\n", d_REL, d_CPL);
73:
74: printf(" 2: %s, %s, %s, %s, %s, %s\n",
75: d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN);
76: printf(" 1: %s, %s, %s, %s, %s, %s\n",
77: d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN);
78: printf("-> 1: %s, %s\n", d_ALG, d_RPN);
79:
80: return;
81: }
82: else if ((*s_etat_processus).test_instruction == 'Y')
83: {
84: (*s_etat_processus).nombre_arguments = 2;
85: return;
86: }
87:
88: if (test_cfsf(s_etat_processus, 31) == d_vrai)
89: {
90: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
91: {
92: return;
93: }
94: }
95:
96: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
97: &s_objet_argument_1) == d_erreur)
98: {
99: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
100: return;
101: }
102:
103: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
104: &s_objet_argument_2) == d_erreur)
105: {
106: liberation(s_etat_processus, s_objet_argument_1);
107:
108: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
109: return;
110: }
111:
112: /*
113: --------------------------------------------------------------------------------
114: Racines n-ièmes de scalaires
115: --------------------------------------------------------------------------------
116: */
117:
118: if (((*s_objet_argument_1).type == INT) &&
119: ((*s_objet_argument_2).type == INT))
120: {
121: if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
122: {
123: liberation(s_etat_processus, s_objet_argument_1);
124: liberation(s_etat_processus, s_objet_argument_2);
125:
126: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
127: return;
128: }
129:
130: if (((*((integer8 *) (*s_objet_argument_2).objet)) < 0) &&
131: (((*((integer8 *) (*s_objet_argument_1).objet)) % 2) == 0))
132: {
133: /*
134: * Résultat Y^(1/X) complexe si X impair et Y négatif
135: */
136:
137: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
138: == NULL)
139: {
140: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
141: return;
142: }
143:
144: module = abs((real8) (*((integer8 *) (*s_objet_argument_2).objet)));
145: argument = ((*((integer8 *) (*s_objet_argument_2).objet)) >= 0)
146: ? 0 : (4 * atan((double) 1));
147:
148: argument /= ((double) (*((integer8 *) (*s_objet_argument_1)
149: .objet)));
150: module = pow(module, ((double) 1) / ((double) (*((integer8 *)
151: (*s_objet_argument_1).objet))));
152:
153: (*((complex16 *) (*s_objet_resultat).objet)).partie_reelle =
154: module * cos(argument);
155: (*((complex16 *) (*s_objet_resultat).objet)).partie_imaginaire =
156: module * sin(argument);
157: }
158: else
159: {
160: /*
161: * Résultat réel
162: */
163:
164: if ((s_objet_resultat = allocation(s_etat_processus, REL))
165: == NULL)
166: {
167: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
168: return;
169: }
170:
171: if ((*((integer8 *) (*s_objet_argument_2).objet)) >= 0)
172: {
173: (*((real8 *) (*s_objet_resultat).objet)) = pow(((double)
174: (*((integer8 *) (*s_objet_argument_2).objet))),
175: ((double) 1) / ((double) (*((integer8 *)
176: (*s_objet_argument_1).objet))));
177: }
178: else
179: {
180: (*((real8 *) (*s_objet_resultat).objet)) = -pow(((double)
181: -(*((integer8 *) (*s_objet_argument_2).objet))),
182: ((double) 1) / ((double) (*((integer8 *)
183: (*s_objet_argument_1).objet))));
184: }
185: }
186: }
187: else if (((*s_objet_argument_1).type == INT) &&
188: ((*s_objet_argument_2).type == REL))
189: {
190: if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
191: {
192: liberation(s_etat_processus, s_objet_argument_1);
193: liberation(s_etat_processus, s_objet_argument_2);
194:
195: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
196: return;
197: }
198:
199: if (((*((real8 *) (*s_objet_argument_2).objet)) < 0) &&
200: (((*((integer8 *) (*s_objet_argument_1).objet)) % 2) == 0))
201: {
202: /*
203: * Résultat Y^(1/X) complexe si X impair et Y négatif
204: */
205:
206: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
207: == NULL)
208: {
209: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
210: return;
211: }
212:
213: module = abs((*((real8 *) (*s_objet_argument_2).objet)));
214: argument = ((*((real8 *) (*s_objet_argument_2).objet)) >= 0)
215: ? 0 : (4 * atan((double) 1));
216:
217: argument /= ((double) (*((integer8 *) (*s_objet_argument_1)
218: .objet)));
219: module = pow(module, ((double) 1) / ((double) (*((integer8 *)
220: (*s_objet_argument_1).objet))));
221:
222: (*((complex16 *) (*s_objet_resultat).objet)).partie_reelle =
223: module * cos(argument);
224: (*((complex16 *) (*s_objet_resultat).objet)).partie_imaginaire =
225: module * sin(argument);
226: }
227: else
228: {
229: /*
230: * Résultat réel
231: */
232:
233: if ((s_objet_resultat = allocation(s_etat_processus, REL))
234: == NULL)
235: {
236: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
237: return;
238: }
239:
240: if ((*((real8 *) (*s_objet_argument_2).objet)) >= 0)
241: {
242: (*((real8 *) (*s_objet_resultat).objet)) = pow(
243: (*((real8 *) (*s_objet_argument_2).objet)),
244: ((double) 1) / ((double) (*((integer8 *)
245: (*s_objet_argument_1).objet))));
246: }
247: else
248: {
249: (*((real8 *) (*s_objet_resultat).objet)) = -pow(
250: -(*((real8 *) (*s_objet_argument_2).objet)),
251: ((double) 1) / ((double) (*((integer8 *)
252: (*s_objet_argument_1).objet))));
253: }
254: }
255: }
256: else if (((*s_objet_argument_1).type == INT) &&
257: ((*s_objet_argument_2).type == CPL))
258: {
259: if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
260: {
261: liberation(s_etat_processus, s_objet_argument_1);
262: liberation(s_etat_processus, s_objet_argument_2);
263:
264: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
265: return;
266: }
267:
268: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
269: == NULL)
270: {
271: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
272: return;
273: }
274:
275: f77absc_(((struct_complexe16 *) (*s_objet_argument_2).objet), &module);
276:
277: argument = atan2((*((struct_complexe16 *) (*s_objet_argument_2).objet))
278: .partie_imaginaire, (*((struct_complexe16 *)
279: (*s_objet_argument_2).objet)).partie_reelle);
280:
281: argument /= ((double) (*((integer8 *) (*s_objet_argument_1).objet)));
282: module = pow(module, ((double) 1) / ((double) (*((integer8 *)
283: (*s_objet_argument_1).objet))));
284:
285: (*((complex16 *) (*s_objet_resultat).objet)).partie_reelle =
286: module * cos(argument);
287: (*((complex16 *) (*s_objet_resultat).objet)).partie_imaginaire =
288: module * sin(argument);
289: }
290:
291: /*
292: --------------------------------------------------------------------------------
293: Résultat sous forme d'expression algébrique
294: --------------------------------------------------------------------------------
295: */
296:
297: else if ((((*s_objet_argument_2).type == NOM) &&
298: (((*s_objet_argument_1).type == NOM) ||
299: ((*s_objet_argument_1).type == INT))) ||
300: ((((*s_objet_argument_2).type == INT) ||
301: ((*s_objet_argument_2).type == REL) ||
302: ((*s_objet_argument_2).type == CPL)) &&
303: ((*s_objet_argument_1).type == NOM)))
304: {
305: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
306: == NULL)
307: {
308: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
309: return;
310: }
311:
312: if (((*s_objet_resultat).objet =
313: allocation_maillon(s_etat_processus)) == 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 = allocation(s_etat_processus, FCT))
322: == 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 = 2;
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 = allocation(s_etat_processus, FCT))
373: == 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 = 2;
381: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
382: .fonction = instruction_xroot;
383:
384: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
385: .nom_fonction = malloc(6 * 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, "XROOT");
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 = allocation(s_etat_processus, FCT))
404: == 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 = 2;
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: * Expression / Nom ou valeur numérique
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: ((*s_objet_argument_2).type == CPL)))
441: {
442: nombre_elements = 0;
443: l_element_courant = (struct_liste_chainee *)
444: (*s_objet_argument_1).objet;
445:
446: while(l_element_courant != NULL)
447: {
448: nombre_elements++;
449: l_element_courant = (*l_element_courant).suivant;
450: }
451:
452: if (nombre_elements == 2)
453: {
454: liberation(s_etat_processus, s_objet_argument_1);
455: liberation(s_etat_processus, s_objet_argument_2);
456:
457: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
458: return;
459: }
460:
461: if ((s_objet_resultat = copie_objet(s_etat_processus,
462: s_objet_argument_1, 'N')) == NULL)
463: {
464: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
465: return;
466: }
467:
468: l_element_courant = (struct_liste_chainee *)
469: (*s_objet_resultat).objet;
470: l_element_precedent = l_element_courant;
471: l_element_courant = (*l_element_courant).suivant;
472:
473: if (((*l_element_precedent).suivant =
474: allocation_maillon(s_etat_processus)) == NULL)
475: {
476: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
477: return;
478: }
479:
480: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
481: (*(*l_element_precedent).suivant).suivant = l_element_courant;
482:
483: while((*l_element_courant).suivant != NULL)
484: {
485: l_element_precedent = l_element_courant;
486: l_element_courant = (*l_element_courant).suivant;
487: }
488:
489: if (((*l_element_precedent).suivant =
490: allocation_maillon(s_etat_processus)) == NULL)
491: {
492: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
493: return;
494: }
495:
496: if (((*(*l_element_precedent).suivant).donnee =
497: allocation(s_etat_processus, FCT)) == NULL)
498: {
499: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
500: return;
501: }
502:
503: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
504: .donnee).objet)).nombre_arguments = 2;
505: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
506: .donnee).objet)).fonction = instruction_xroot;
507:
508: if (((*((struct_fonction *) (*(*(*l_element_precedent)
509: .suivant).donnee).objet)).nom_fonction =
510: malloc(6 * sizeof(unsigned char))) == NULL)
511: {
512: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
513: return;
514: }
515:
516: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
517: .suivant).donnee).objet)).nom_fonction, "XROOT");
518:
519: (*(*l_element_precedent).suivant).suivant = l_element_courant;
520:
521: s_objet_argument_2 = NULL;
522: }
523:
524: /*
525: * Expression / Nom ou valeur numérique
526: */
527:
528: else if ((((*s_objet_argument_1).type == NOM) ||
529: ((*s_objet_argument_1).type == INT)) &&
530: (((*s_objet_argument_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 = 2;
595: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
596: .donnee).objet)).fonction = instruction_xroot;
597:
598: if (((*((struct_fonction *) (*(*(*l_element_precedent)
599: .suivant).donnee).objet)).nom_fonction =
600: malloc(6 * 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, "XROOT");
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: free(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: free(l_element_courant);
696:
697: (*l_element_precedent).suivant = (struct_liste_chainee *)
698: (*s_copie_argument_1).objet;
699: free(s_copie_argument_1);
700:
701: l_element_courant = (*l_element_precedent).suivant;
702: while((*l_element_courant).suivant != NULL)
703: {
704: l_element_precedent = l_element_courant;
705: l_element_courant = (*l_element_courant).suivant;
706: }
707:
708: if (((*l_element_precedent).suivant =
709: allocation_maillon(s_etat_processus)) == NULL)
710: {
711: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
712: return;
713: }
714:
715: (*(*l_element_precedent).suivant).suivant = l_element_courant;
716: l_element_courant = (*l_element_precedent).suivant;
717:
718: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
719: == NULL)
720: {
721: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
722: return;
723: }
724:
725: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
726: .nombre_arguments = 2;
727: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
728: .fonction = instruction_xroot;
729:
730: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
731: .nom_fonction = malloc(6 * sizeof(unsigned char))) == NULL)
732: {
733: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
734: return;
735: }
736:
737: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
738: .nom_fonction, "XROOT");
739: }
740: else
741: {
742: liberation(s_etat_processus, s_objet_argument_1);
743: liberation(s_etat_processus, s_objet_argument_2);
744:
745: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
746: return;
747: }
748:
749: liberation(s_etat_processus, s_objet_argument_1);
750: liberation(s_etat_processus, s_objet_argument_2);
751:
752: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
753: s_objet_resultat) == d_erreur)
754: {
755: return;
756: }
757:
758: return;
759: }
760:
761:
762: /*
763: ================================================================================
764: Fonction 'xcol'
765: ================================================================================
766: Entrées : pointeur sur une structure struct_processus
767: --------------------------------------------------------------------------------
768: Sorties :
769: --------------------------------------------------------------------------------
770: Effets de bord : néant
771: ================================================================================
772: */
773:
774: void
775: instruction_xcol(struct_processus *s_etat_processus)
776: {
777: struct_objet *s_objet_argument;
778:
779: (*s_etat_processus).erreur_execution = d_ex;
780:
781: if ((*s_etat_processus).affichage_arguments == 'Y')
782: {
783: printf("\n XCOL ");
784:
785: if ((*s_etat_processus).langue == 'F')
786: {
787: printf("(définition de la colonne statistique X)\n\n");
788: }
789: else
790: {
791: printf("(definition of statistical X column)\n\n");
792: }
793:
794: printf(" 1: %s\n", d_INT);
795:
796: return;
797: }
798: else if ((*s_etat_processus).test_instruction == 'Y')
799: {
800: (*s_etat_processus).nombre_arguments = -1;
801: return;
802: }
803:
804: if (test_cfsf(s_etat_processus, 31) == d_vrai)
805: {
806: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
807: {
808: return;
809: }
810: }
811:
812: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
813: &s_objet_argument) == d_erreur)
814: {
815: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
816: return;
817: }
818:
819: if ((*s_objet_argument).type == INT)
820: {
821: if ((*((integer8 *) (*s_objet_argument).objet)) <= 0)
822: {
823: liberation(s_etat_processus, s_objet_argument);
824:
825: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
826: return;
827: }
828:
829: (*s_etat_processus).colonne_statistique_1 =
830: (*((integer8 *) (*s_objet_argument).objet));
831: }
832: else
833: {
834: liberation(s_etat_processus, s_objet_argument);
835:
836: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
837: return;
838: }
839:
840: liberation(s_etat_processus, s_objet_argument);
841:
842: return;
843: }
844:
845: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_x2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src