1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.15
4: Copyright (C) 1989-2013 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 'trn'
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_trn(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet_argument;
42: struct_objet *s_objet_resultat;
43:
44: logical1 argument_nom;
45: logical1 variable_partagee;
46:
47: integer8 i;
48: integer8 j;
49:
50: (*s_etat_processus).erreur_execution = d_ex;
51:
52: if ((*s_etat_processus).affichage_arguments == 'Y')
53: {
54: printf("\n TRN ");
55:
56: if ((*s_etat_processus).langue == 'F')
57: {
58: printf("(transposition)\n\n");
59: }
60: else
61: {
62: printf("(transposition)\n\n");
63: }
64:
65: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
66: printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX);
67:
68: printf(" 1: %s\n", d_NOM);
69:
70: return;
71: }
72: else if ((*s_etat_processus).test_instruction == 'Y')
73: {
74: (*s_etat_processus).nombre_arguments = -1;
75: return;
76: }
77:
78: if (test_cfsf(s_etat_processus, 31) == d_vrai)
79: {
80: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
81: {
82: return;
83: }
84: }
85:
86: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
87: &s_objet_argument) == d_erreur)
88: {
89: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
90: return;
91: }
92:
93: variable_partagee = d_faux;
94:
95: if ((*s_objet_argument).type == NOM)
96: {
97: argument_nom = d_vrai;
98:
99: if (recherche_variable(s_etat_processus, (*((struct_nom *)
100: (*s_objet_argument).objet)).nom) == d_faux)
101: {
102: (*s_etat_processus).erreur_systeme = d_es;
103: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
104:
105: liberation(s_etat_processus, s_objet_argument);
106:
107: return;
108: }
109:
110: liberation(s_etat_processus, s_objet_argument);
111:
112: if ((*(*s_etat_processus).pointeur_variable_courante)
113: .variable_verrouillee == d_vrai)
114: {
115: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
116: return;
117: }
118:
119: if ((*(*s_etat_processus).pointeur_variable_courante).objet != NULL)
120: {
121: s_objet_argument = (*(*s_etat_processus).pointeur_variable_courante)
122: .objet;
123: }
124: else
125: {
126: if (recherche_variable_partagee(s_etat_processus,
127: (*(*s_etat_processus).pointeur_variable_courante).nom,
128: (*(*s_etat_processus).pointeur_variable_courante)
129: .variable_partagee, (*(*s_etat_processus)
130: .pointeur_variable_courante).origine) == NULL)
131: {
132: (*s_etat_processus).erreur_systeme = d_es;
133: (*s_etat_processus).erreur_execution =
134: d_ex_variable_non_definie;
135:
136: liberation(s_etat_processus, s_objet_argument);
137:
138: return;
139: }
140:
141: variable_partagee = d_vrai;
142: }
143: }
144: else
145: {
146: argument_nom = d_faux;
147: }
148:
149: /*
150: --------------------------------------------------------------------------------
151: Matrice transposée d'une matrice entière
152: --------------------------------------------------------------------------------
153: */
154:
155: if ((*s_objet_argument).type == MIN)
156: {
157: if ((s_objet_resultat = allocation(s_etat_processus, MIN)) == NULL)
158: {
159: if (variable_partagee == d_vrai)
160: {
161: if (pthread_mutex_unlock(&((*(*s_etat_processus)
162: .pointeur_variable_partagee_courante).mutex)) != 0)
163: {
164: (*s_etat_processus).erreur_systeme = d_es_processus;
165: return;
166: }
167: }
168:
169: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
170: return;
171: }
172:
173: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
174: (*((struct_matrice *) (*s_objet_argument).objet))
175: .nombre_colonnes;
176: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
177: (*((struct_matrice *) (*s_objet_argument).objet))
178: .nombre_lignes;
179:
180: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
181: malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat)
182: .objet)).nombre_lignes) * sizeof(integer8 *))) == NULL)
183: {
184: if (variable_partagee == d_vrai)
185: {
186: if (pthread_mutex_unlock(&((*(*s_etat_processus)
187: .pointeur_variable_partagee_courante).mutex)) != 0)
188: {
189: (*s_etat_processus).erreur_systeme = d_es_processus;
190: return;
191: }
192: }
193:
194: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
195: return;
196: }
197:
198: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
199: .nombre_lignes; i++)
200: {
201: if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
202: .objet)).tableau)[i] = malloc(((size_t)
203: (*((struct_matrice *) (*s_objet_resultat).objet))
204: .nombre_colonnes) * sizeof(integer8))) == NULL)
205: {
206: if (variable_partagee == d_vrai)
207: {
208: if (pthread_mutex_unlock(&((*(*s_etat_processus)
209: .pointeur_variable_partagee_courante).mutex)) != 0)
210: {
211: (*s_etat_processus).erreur_systeme = d_es_processus;
212: return;
213: }
214: }
215:
216: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
217: return;
218: }
219:
220: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
221: .nombre_colonnes; j++)
222: {
223: ((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
224: .objet)).tableau)[i][j] =
225: ((integer8 **) (*((struct_matrice *)
226: (*s_objet_argument).objet)).tableau)[j][i];
227: }
228: }
229: }
230:
231: /*
232: --------------------------------------------------------------------------------
233: Matrice tranposée d'une matrice réelle
234: --------------------------------------------------------------------------------
235: */
236:
237: else if ((*s_objet_argument).type == MRL)
238: {
239: if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL)
240: {
241: if (variable_partagee == d_vrai)
242: {
243: if (pthread_mutex_unlock(&((*(*s_etat_processus)
244: .pointeur_variable_partagee_courante).mutex)) != 0)
245: {
246: (*s_etat_processus).erreur_systeme = d_es_processus;
247: return;
248: }
249: }
250:
251: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
252: return;
253: }
254:
255: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
256: (*((struct_matrice *) (*s_objet_argument).objet))
257: .nombre_colonnes;
258: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
259: (*((struct_matrice *) (*s_objet_argument).objet))
260: .nombre_lignes;
261:
262: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
263: malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat)
264: .objet)).nombre_lignes) * sizeof(real8 *))) == NULL)
265: {
266: if (variable_partagee == d_vrai)
267: {
268: if (pthread_mutex_unlock(&((*(*s_etat_processus)
269: .pointeur_variable_partagee_courante).mutex)) != 0)
270: {
271: (*s_etat_processus).erreur_systeme = d_es_processus;
272: return;
273: }
274: }
275:
276: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
277: return;
278: }
279:
280: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
281: .nombre_lignes; i++)
282: {
283: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
284: .objet)).tableau)[i] = malloc(((size_t)
285: (*((struct_matrice *) (*s_objet_resultat).objet))
286: .nombre_colonnes) * sizeof(real8))) == NULL)
287: {
288: if (variable_partagee == d_vrai)
289: {
290: if (pthread_mutex_unlock(&((*(*s_etat_processus)
291: .pointeur_variable_partagee_courante).mutex)) != 0)
292: {
293: (*s_etat_processus).erreur_systeme = d_es_processus;
294: return;
295: }
296: }
297:
298: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
299: return;
300: }
301:
302: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
303: .nombre_colonnes; j++)
304: {
305: ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
306: .objet)).tableau)[i][j] =
307: ((real8 **) (*((struct_matrice *)
308: (*s_objet_argument).objet)).tableau)[j][i];
309: }
310: }
311: }
312:
313: /*
314: --------------------------------------------------------------------------------
315: Matrice transposée (et conjuguée) d'une matrice complexe
316: --------------------------------------------------------------------------------
317: */
318:
319: else if ((*s_objet_argument).type == MCX)
320: {
321: if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL)
322: {
323: if (variable_partagee == d_vrai)
324: {
325: if (pthread_mutex_unlock(&((*(*s_etat_processus)
326: .pointeur_variable_partagee_courante).mutex)) != 0)
327: {
328: (*s_etat_processus).erreur_systeme = d_es_processus;
329: return;
330: }
331: }
332:
333: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
334: return;
335: }
336:
337: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
338: (*((struct_matrice *) (*s_objet_argument).objet))
339: .nombre_colonnes;
340: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
341: (*((struct_matrice *) (*s_objet_argument).objet))
342: .nombre_lignes;
343:
344: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
345: malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat)
346: .objet)).nombre_lignes) * sizeof(struct_complexe16 *))) == NULL)
347: {
348: if (variable_partagee == d_vrai)
349: {
350: if (pthread_mutex_unlock(&((*(*s_etat_processus)
351: .pointeur_variable_partagee_courante).mutex)) != 0)
352: {
353: (*s_etat_processus).erreur_systeme = d_es_processus;
354: return;
355: }
356: }
357:
358: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
359: return;
360: }
361:
362: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
363: .nombre_lignes; i++)
364: {
365: if ((((struct_complexe16 **) (*((struct_matrice *)
366: (*s_objet_resultat).objet)).tableau)[i] =
367: malloc(((size_t) (*((struct_matrice *)
368: (*s_objet_resultat).objet)).nombre_colonnes) *
369: sizeof(struct_complexe16))) == NULL)
370: {
371: if (variable_partagee == d_vrai)
372: {
373: if (pthread_mutex_unlock(&((*(*s_etat_processus)
374: .pointeur_variable_partagee_courante).mutex)) != 0)
375: {
376: (*s_etat_processus).erreur_systeme = d_es_processus;
377: return;
378: }
379: }
380:
381: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
382: return;
383: }
384:
385: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
386: .nombre_colonnes; j++)
387: {
388: ((struct_complexe16 **) (*((struct_matrice *)
389: (*s_objet_resultat).objet)).tableau)[i][j]
390: .partie_reelle =
391: ((struct_complexe16 **) (*((struct_matrice *)
392: (*s_objet_argument).objet)).tableau)[j][i]
393: .partie_reelle;
394: ((struct_complexe16 **) (*((struct_matrice *)
395: (*s_objet_resultat).objet)).tableau)[i][j]
396: .partie_imaginaire =
397: -((struct_complexe16 **) (*((struct_matrice *)
398: (*s_objet_argument).objet)).tableau)[j][i]
399: .partie_imaginaire;
400: }
401: }
402: }
403:
404: /*
405: --------------------------------------------------------------------------------
406: Fonction transposée impossible à réaliser
407: --------------------------------------------------------------------------------
408: */
409:
410: else
411: {
412: if (argument_nom == d_faux)
413: {
414: liberation(s_etat_processus, s_objet_argument);
415: }
416:
417: if (variable_partagee == d_vrai)
418: {
419: if (pthread_mutex_unlock(&((*(*s_etat_processus)
420: .pointeur_variable_partagee_courante).mutex)) != 0)
421: {
422: (*s_etat_processus).erreur_systeme = d_es_processus;
423: return;
424: }
425: }
426:
427: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
428: return;
429: }
430:
431: liberation(s_etat_processus, s_objet_argument);
432:
433: if (argument_nom == d_faux)
434: {
435: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
436: s_objet_resultat) == d_erreur)
437: {
438: return;
439: }
440: }
441: else
442: {
443: if (variable_partagee == d_vrai)
444: {
445: (*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
446: s_objet_resultat;
447:
448: if (pthread_mutex_unlock(&((*(*s_etat_processus)
449: .pointeur_variable_partagee_courante).mutex)) != 0)
450: {
451: (*s_etat_processus).erreur_systeme = d_es_processus;
452: return;
453: }
454: }
455: else
456: {
457: (*(*s_etat_processus).pointeur_variable_courante).objet =
458: s_objet_resultat;
459: }
460: }
461:
462: return;
463: }
464:
465:
466: /*
467: ================================================================================
468: Fonction 'tot'
469: ================================================================================
470: Entrées : pointeur sur une structure struct_processus
471: --------------------------------------------------------------------------------
472: Sorties :
473: --------------------------------------------------------------------------------
474: Effets de bord : néant
475: ================================================================================
476: */
477:
478: void
479: instruction_tot(struct_processus *s_etat_processus)
480: {
481: struct_objet *s_objet_statistique;
482: struct_objet *s_objet_resultat;
483: struct_objet *s_objet_temporaire;
484:
485: integer8 nombre_colonnes;
486:
487: (*s_etat_processus).erreur_execution = d_ex;
488:
489: if ((*s_etat_processus).affichage_arguments == 'Y')
490: {
491: printf("\n TOT ");
492:
493: if ((*s_etat_processus).langue == 'F')
494: {
495: printf("(somme des colonnes statistiques)\n\n");
496: }
497: else
498: {
499: printf("(sum of statistical columns)\n\n");
500: }
501:
502: printf("-> 1: %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_REL);
503:
504: return;
505: }
506: else if ((*s_etat_processus).test_instruction == 'Y')
507: {
508: (*s_etat_processus).nombre_arguments = -1;
509: return;
510: }
511:
512: if (test_cfsf(s_etat_processus, 31) == d_vrai)
513: {
514: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
515: {
516: return;
517: }
518: }
519:
520: /*
521: * Recherche d'une variable globale référencée par SIGMA
522: */
523:
524: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
525: {
526: /*
527: * Aucune variable SIGMA
528: */
529:
530: (*s_etat_processus).erreur_systeme = d_es;
531:
532: if ((*s_etat_processus).erreur_execution == d_ex)
533: {
534: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
535: }
536:
537: return;
538: }
539: else
540: {
541: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
542: .type != MIN) && ((*(*(*s_etat_processus)
543: .pointeur_variable_courante).objet).type != MRL))
544: {
545: (*s_etat_processus).erreur_execution =
546: d_ex_matrice_statistique_invalide;
547: return;
548: }
549:
550: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
551: .pointeur_variable_courante).objet).objet)).nombre_colonnes;
552: }
553:
554: if (nombre_colonnes == 0)
555: {
556: (*s_etat_processus).erreur_execution =
557: d_ex_matrice_statistique_invalide;
558: return;
559: }
560:
561: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
562: .objet;
563:
564: if (((*s_objet_statistique).type == MIN) ||
565: ((*s_objet_statistique).type == MRL))
566: {
567: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
568: {
569: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
570: return;
571: }
572:
573: if (((*s_objet_resultat).objet = sommation_statistique(
574: (struct_matrice *) (*s_objet_statistique).objet)) == NULL)
575: {
576: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
577: return;
578: }
579:
580: if (nombre_colonnes == 1)
581: {
582: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
583: {
584: (*s_objet_resultat).type = VIN;
585: s_objet_temporaire = s_objet_resultat;
586:
587: if ((s_objet_resultat = allocation(s_etat_processus, INT))
588: == NULL)
589: {
590: (*s_etat_processus).erreur_systeme =
591: d_es_allocation_memoire;
592: return;
593: }
594:
595: (*((integer8 *) (*s_objet_resultat).objet)) =
596: ((integer8 *) (*((struct_vecteur *)
597: (*s_objet_temporaire).objet)).tableau)[0];
598:
599: liberation(s_etat_processus, s_objet_temporaire);
600: }
601: else
602: {
603: (*s_objet_resultat).type = VRL;
604: s_objet_temporaire = s_objet_resultat;
605:
606: if ((s_objet_resultat = allocation(s_etat_processus, REL))
607: == NULL)
608: {
609: (*s_etat_processus).erreur_systeme =
610: d_es_allocation_memoire;
611: return;
612: }
613:
614: (*((real8 *) (*s_objet_resultat).objet)) =
615: ((real8 *) (*((struct_vecteur *)
616: (*s_objet_temporaire).objet)).tableau)[0];
617:
618: liberation(s_etat_processus, s_objet_temporaire);
619: }
620: }
621: else
622: {
623: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
624: {
625: (*s_objet_resultat).type = VIN;
626: }
627: else
628: {
629: (*s_objet_resultat).type = VRL;
630: }
631: }
632:
633: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
634: s_objet_resultat) == d_erreur)
635: {
636: return;
637: }
638: }
639: else
640: {
641: (*s_etat_processus).erreur_execution =
642: d_ex_matrice_statistique_invalide;
643: return;
644: }
645:
646: return;
647: }
648:
649:
650: /*
651: ================================================================================
652: Fonction 'title'
653: ================================================================================
654: Entrées :
655: --------------------------------------------------------------------------------
656: Sorties :
657: --------------------------------------------------------------------------------
658: Effets de bord : néant
659: ================================================================================
660: */
661:
662: void
663: instruction_title(struct_processus *s_etat_processus)
664: {
665: struct_objet *s_objet;
666:
667: (*s_etat_processus).erreur_execution = d_ex;
668:
669: if ((*s_etat_processus).affichage_arguments == 'Y')
670: {
671: printf("\n TITLE ");
672:
673: if ((*s_etat_processus).langue == 'F')
674: {
675: printf("(titre d'un graphique)\n\n");
676: }
677: else
678: {
679: printf("(title of graphic)\n\n");
680: }
681:
682: printf(" 1: %s\n", d_CHN);
683:
684: return;
685: }
686: else if ((*s_etat_processus).test_instruction == 'Y')
687: {
688: (*s_etat_processus).nombre_arguments = -1;
689: return;
690: }
691:
692: if (test_cfsf(s_etat_processus, 31) == d_vrai)
693: {
694: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
695: {
696: return;
697: }
698: }
699:
700: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
701: &s_objet) == d_erreur)
702: {
703: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
704: return;
705: }
706:
707: if ((*s_objet).type == CHN)
708: {
709: free((*s_etat_processus).titre);
710:
711: if (((*s_etat_processus).titre = malloc((strlen((unsigned char *)
712: (*s_objet).objet) + 1) * sizeof(unsigned char))) == NULL)
713: {
714: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
715: return;
716: }
717:
718: strcpy((*s_etat_processus).titre, (unsigned char *) (*s_objet).objet);
719: liberation(s_etat_processus, s_objet);
720: }
721: else
722: {
723: liberation(s_etat_processus, s_objet);
724:
725: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
726: return;
727: }
728:
729: if (test_cfsf(s_etat_processus, 52) == d_faux)
730: {
731: if ((*s_etat_processus).fichiers_graphiques != NULL)
732: {
733: appel_gnuplot(s_etat_processus, 'N');
734: }
735: }
736:
737: return;
738: }
739:
740:
741: /*
742: ================================================================================
743: Fonction 'time'
744: ================================================================================
745: Entrées :
746: --------------------------------------------------------------------------------
747: Sorties :
748: --------------------------------------------------------------------------------
749: Effets de bord : néant
750: ================================================================================
751: */
752:
753: void
754: instruction_time(struct_processus *s_etat_processus)
755: {
756: struct rusage s_usage_processus_fils;
757: struct rusage s_usage_processus_pere;
758:
759: struct_liste_chainee *l_element_courant;
760:
761: struct_objet *s_objet;
762:
763: (*s_etat_processus).erreur_execution = d_ex;
764:
765: if ((*s_etat_processus).affichage_arguments == 'Y')
766: {
767: printf("\n TIME ");
768:
769: if ((*s_etat_processus).langue == 'F')
770: {
771: printf("(temps CPU)\n\n");
772: }
773: else
774: {
775: printf("(CPU time)\n\n");
776: }
777:
778: printf("-> 1: %s\n", d_LST);
779:
780: return;
781: }
782: else if ((*s_etat_processus).test_instruction == 'Y')
783: {
784: (*s_etat_processus).nombre_arguments = -1;
785: return;
786: }
787:
788: if (test_cfsf(s_etat_processus, 31) == d_vrai)
789: {
790: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
791: {
792: return;
793: }
794: }
795:
796: /*
797: * Lecture des différents temps
798: */
799:
800: # ifndef OS2
801: if ((getrusage(RUSAGE_SELF, &s_usage_processus_pere)) != 0)
802: {
803: (*s_etat_processus).erreur_systeme = d_es_processus;
804: return;
805: }
806:
807: if ((getrusage(RUSAGE_CHILDREN, &s_usage_processus_fils)) != 0)
808: {
809: (*s_etat_processus).erreur_systeme = d_es_processus;
810: return;
811: }
812: # else
813: s_usage_processus_pere.ru_utime.tv_sec = 0;
814: s_usage_processus_pere.ru_utime.tv_usec = 0;
815: s_usage_processus_pere.ru_stime.tv_sec = 0;
816: s_usage_processus_pere.ru_stime.tv_usec = 0;
817: s_usage_processus_fils.ru_utime.tv_sec = 0;
818: s_usage_processus_fils.ru_utime.tv_usec = 0;
819: s_usage_processus_fils.ru_stime.tv_sec = 0;
820: s_usage_processus_fils.ru_stime.tv_usec = 0;
821: # endif
822:
823: /*
824: * Initialisation de la liste
825: */
826:
827: if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
828: {
829: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
830: return;
831: }
832:
833: /*
834: * User time du processus père (séquenceur)
835: */
836:
837: if ((l_element_courant = allocation_maillon(s_etat_processus)) == NULL)
838: {
839: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
840: return;
841: }
842:
843: (*s_objet).objet = l_element_courant;
844:
845: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
846: == NULL)
847: {
848: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
849: return;
850: }
851:
852: (*((real8 *) (*(*l_element_courant).donnee).objet)) =
853: ((real8) s_usage_processus_pere.ru_utime.tv_sec) +
854: (((real8) s_usage_processus_pere.ru_utime.tv_usec) /
855: ((real8) 1E6));
856:
857: /*
858: * System time du processus père
859: */
860:
861: if (((*l_element_courant).suivant =
862: allocation_maillon(s_etat_processus)) == NULL)
863: {
864: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
865: return;
866: }
867:
868: l_element_courant = (*l_element_courant).suivant;
869:
870: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
871: == NULL)
872: {
873: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
874: return;
875: }
876:
877: (*((real8 *) (*(*l_element_courant).donnee).objet)) =
878: ((real8) s_usage_processus_pere.ru_stime.tv_sec) +
879: (((real8) s_usage_processus_pere.ru_stime.tv_usec) /
880: ((real8) 1E6));
881:
882: /*
883: * User time des processus fils achevés
884: */
885:
886: if (((*l_element_courant).suivant =
887: allocation_maillon(s_etat_processus)) == NULL)
888: {
889: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
890: return;
891: }
892:
893: l_element_courant = (*l_element_courant).suivant;
894:
895: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
896: == NULL)
897: {
898: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
899: return;
900: }
901:
902: (*((real8 *) (*(*l_element_courant).donnee).objet)) =
903: ((real8) s_usage_processus_fils.ru_utime.tv_sec) +
904: (((real8) s_usage_processus_fils.ru_utime.tv_usec) /
905: ((real8) 1E6));
906:
907: /*
908: * System time des processus fils achevés
909: */
910:
911: if (((*l_element_courant).suivant =
912: allocation_maillon(s_etat_processus)) == NULL)
913: {
914: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
915: return;
916: }
917:
918: l_element_courant = (*l_element_courant).suivant;
919:
920: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
921: == NULL)
922: {
923: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
924: return;
925: }
926:
927: (*((real8 *) (*(*l_element_courant).donnee).objet)) =
928: ((real8) s_usage_processus_fils.ru_stime.tv_sec) +
929: (((real8) s_usage_processus_fils.ru_stime.tv_usec) /
930: ((real8) 1E6));
931:
932: /*
933: * Fermeture de la liste
934: */
935:
936: (*l_element_courant).suivant = NULL;
937:
938: /*
939: * Empilement du résultat
940: */
941:
942: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
943: s_objet) == d_erreur)
944: {
945: return;
946: }
947:
948: return;
949: }
950:
951:
952: /*
953: ================================================================================
954: Fonction 'taylr'
955: ================================================================================
956: Entrées :
957: --------------------------------------------------------------------------------
958: Sorties :
959: --------------------------------------------------------------------------------
960: Effets de bord : néant
961: ================================================================================
962: */
963:
964: void
965: instruction_taylr(struct_processus *s_etat_processus)
966: {
967: integer8 i;
968:
969: logical1 last_valide;
970: logical1 zero;
971:
972: struct_liste_chainee *l_element_courant;
973:
974: struct_objet *s_objet_argument;
975: struct_objet *s_objet_argument_1;
976: struct_objet *s_objet_argument_2;
977: struct_objet *s_objet_argument_3;
978: struct_objet *s_objet_argument_4;
979: struct_objet *s_objet_resultat;
980: struct_objet *s_objet_variable_derivation;
981:
982: struct_variable s_variable;
983:
984: (*s_etat_processus).erreur_execution = d_ex;
985:
986: if ((*s_etat_processus).affichage_arguments == 'Y')
987: {
988: printf("\n TAYLR ");
989:
990: if ((*s_etat_processus).langue == 'F')
991: {
992: printf("(série de Taylor)\n\n");
993: }
994: else
995: {
996: printf("(Taylor serie)\n\n");
997: }
998:
999: printf(" 4: %s\n", d_ALG);
1000: printf(" 3: %s\n", d_NOM);
1001: printf(" 2: %s, %s\n", d_INT, d_REL);
1002: printf(" 1: %s\n", d_INT);
1003: printf("-> 1: %s\n\n", d_ALG);
1004:
1005: return;
1006: }
1007: else if ((*s_etat_processus).test_instruction == 'Y')
1008: {
1009: (*s_etat_processus).nombre_arguments = -1;
1010: return;
1011: }
1012:
1013: if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
1014: {
1015: if (empilement_pile_last(s_etat_processus, 4) == d_erreur)
1016: {
1017: return;
1018: }
1019: }
1020:
1021: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1022: &s_objet_argument_1) == d_erreur)
1023: {
1024: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1025: return;
1026: }
1027:
1028: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1029: &s_objet_argument_2) == d_erreur)
1030: {
1031: liberation(s_etat_processus, s_objet_argument_1);
1032:
1033: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1034: return;
1035: }
1036:
1037: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1038: &s_objet_argument_3) == d_erreur)
1039: {
1040: liberation(s_etat_processus, s_objet_argument_1);
1041: liberation(s_etat_processus, s_objet_argument_2);
1042:
1043: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1044: return;
1045: }
1046:
1047: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1048: &s_objet_argument_4) == d_erreur)
1049: {
1050: liberation(s_etat_processus, s_objet_argument_1);
1051: liberation(s_etat_processus, s_objet_argument_2);
1052: liberation(s_etat_processus, s_objet_argument_3);
1053: liberation(s_etat_processus, s_objet_argument_4);
1054:
1055: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1056: return;
1057: }
1058:
1059: if (((*s_objet_argument_4).type == ALG) &&
1060: ((*s_objet_argument_3).type == NOM) &&
1061: (((*s_objet_argument_2).type == INT) ||
1062: ((*s_objet_argument_2).type == REL)) &&
1063: ((*s_objet_argument_1).type == INT))
1064: {
1065: if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
1066: {
1067: liberation(s_etat_processus, s_objet_argument_1);
1068: liberation(s_etat_processus, s_objet_argument_2);
1069: liberation(s_etat_processus, s_objet_argument_3);
1070: liberation(s_etat_processus, s_objet_argument_4);
1071:
1072: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1073: return;
1074: }
1075:
1076: if ((*s_objet_argument_2).type == REL)
1077: {
1078: if ((*((real8 *) (*s_objet_argument_2).objet)) == 0)
1079: {
1080: zero = d_vrai;
1081: }
1082: else
1083: {
1084: zero = d_faux;
1085: }
1086: }
1087: else
1088: {
1089: if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0)
1090: {
1091: zero = d_vrai;
1092: }
1093: else
1094: {
1095: zero = d_faux;
1096: }
1097: }
1098:
1099: /*
1100: * Conversion du drapeau symbole des variables symboliques
1101: */
1102:
1103: l_element_courant = (*s_objet_argument_4).objet;
1104:
1105: while(l_element_courant != NULL)
1106: {
1107: if ((*(*l_element_courant).donnee).type == NOM)
1108: {
1109: if (strcmp((*((struct_nom *) (*(*l_element_courant).donnee)
1110: .objet)).nom, (*((struct_nom *) (*s_objet_argument_3)
1111: .objet)).nom) == 0)
1112: {
1113: (*((struct_nom *) (*(*l_element_courant).donnee).objet))
1114: .symbole = d_faux;
1115: }
1116: }
1117:
1118: l_element_courant = (*l_element_courant).suivant;
1119: }
1120:
1121: /*
1122: * Création de la variable locale et initialisation
1123: */
1124:
1125: (*s_etat_processus).niveau_courant++;
1126:
1127: if ((s_variable.nom = malloc((strlen((*((struct_nom *)
1128: (*s_objet_argument_3).objet)).nom) + 1) *
1129: sizeof(unsigned char))) == NULL)
1130: {
1131: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1132: return;
1133: }
1134:
1135: s_variable.niveau = (*s_etat_processus).niveau_courant;
1136: strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_argument_3)
1137: .objet)).nom);
1138:
1139: if ((s_variable.objet = copie_objet(s_etat_processus,
1140: s_objet_argument_2, 'O')) == NULL)
1141: {
1142: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1143: return;
1144: }
1145:
1146: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')
1147: == d_erreur)
1148: {
1149: return;
1150: }
1151:
1152: /*
1153: * Création de la série
1154: */
1155:
1156: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
1157: {
1158: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1159: return;
1160: }
1161:
1162: if (((*s_objet_resultat).objet =
1163: allocation_maillon(s_etat_processus)) == NULL)
1164: {
1165: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1166: return;
1167: }
1168:
1169: l_element_courant = (*s_objet_resultat).objet;
1170:
1171: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1172: == NULL)
1173: {
1174: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1175: return;
1176: }
1177:
1178: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1179: .nombre_arguments = 0;
1180: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1181: .fonction = instruction_vers_niveau_superieur;
1182:
1183: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1184: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1185: {
1186: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1187: return;
1188: }
1189:
1190: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1191: .nom_fonction, "<<");
1192:
1193: if (last_valide == d_vrai)
1194: {
1195: cf(s_etat_processus, 31);
1196: }
1197:
1198: /*
1199: * Calcul de la série de Taylor
1200: *
1201: * s(x) = \sum_{i=0}{n} (1/i!)*((d^i f(x=a))/d(x^i)*(x-a)^i)
1202: */
1203:
1204: for(i = 0; (i <= (*((integer8 *) (*s_objet_argument_1).objet))) &&
1205: ((*s_etat_processus).var_volatile_requete_arret == 0); i++)
1206: {
1207: /*
1208: * Calcul de ((d^i f(x=a))/d(x^i)*(x-a)^i)/i!
1209: */
1210:
1211: if (i != 0)
1212: {
1213: // Calcul de la valeur de la dérivée n-ième
1214: // Expression empilée puis dérivée et sauvegardée dans
1215: // s_argument_4.
1216:
1217: if (empilement(s_etat_processus, &((*s_etat_processus)
1218: .l_base_pile), s_objet_argument_4) == d_erreur)
1219: {
1220: if (last_valide == d_vrai)
1221: {
1222: sf(s_etat_processus, 31);
1223: }
1224:
1225: return;
1226: }
1227:
1228: if ((s_objet_variable_derivation =
1229: copie_objet(s_etat_processus, s_objet_argument_3, 'O'))
1230: == NULL)
1231: {
1232: (*s_etat_processus).erreur_systeme =
1233: d_es_allocation_memoire;
1234: return;
1235: }
1236:
1237: if (empilement(s_etat_processus, &((*s_etat_processus)
1238: .l_base_pile), s_objet_variable_derivation) == d_erreur)
1239: {
1240: if (last_valide == d_vrai)
1241: {
1242: sf(s_etat_processus, 31);
1243: }
1244:
1245: return;
1246: }
1247:
1248: instruction_der(s_etat_processus);
1249:
1250: if ((*s_etat_processus).erreur_execution != d_ex)
1251: {
1252: liberation(s_etat_processus, s_objet_argument_1);
1253: liberation(s_etat_processus, s_objet_argument_2);
1254: liberation(s_etat_processus, s_objet_argument_3);
1255:
1256: (*l_element_courant).suivant = NULL;
1257:
1258: liberation(s_etat_processus, s_objet_resultat);
1259:
1260: if (last_valide == d_vrai)
1261: {
1262: sf(s_etat_processus, 31);
1263: }
1264:
1265: return;
1266: }
1267: else if ((*s_etat_processus).erreur_systeme != d_es)
1268: {
1269: return;
1270: }
1271:
1272: if ((*s_etat_processus).var_volatile_requete_arret != 0)
1273: {
1274: /*
1275: * instruction_der() n'a rien renvoyé dans la pile. On
1276: * injecte une valeur nulle dans s_objet_argument_4.
1277: */
1278:
1279: if ((s_objet_argument_4 = allocation(s_etat_processus,
1280: INT)) == NULL)
1281: {
1282: (*s_etat_processus).erreur_systeme =
1283: d_es_allocation_memoire;
1284: return;
1285: }
1286: }
1287: else if (depilement(s_etat_processus, &((*s_etat_processus)
1288: .l_base_pile), &s_objet_argument_4) == d_erreur)
1289: {
1290: liberation(s_etat_processus, s_objet_argument_1);
1291: liberation(s_etat_processus, s_objet_argument_2);
1292: liberation(s_etat_processus, s_objet_argument_3);
1293:
1294: (*l_element_courant).suivant = NULL;
1295:
1296: liberation(s_etat_processus, s_objet_resultat);
1297:
1298: if (last_valide == d_vrai)
1299: {
1300: sf(s_etat_processus, 31);
1301: }
1302:
1303: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1304: return;
1305: }
1306: }
1307:
1308: if (evaluation(s_etat_processus, s_objet_argument_4, 'E')
1309: == d_erreur)
1310: {
1311: liberation(s_etat_processus, s_objet_argument_1);
1312: liberation(s_etat_processus, s_objet_argument_2);
1313: liberation(s_etat_processus, s_objet_argument_3);
1314: liberation(s_etat_processus, s_objet_argument_4);
1315:
1316: (*l_element_courant).suivant = NULL;
1317:
1318: liberation(s_etat_processus, s_objet_resultat);
1319:
1320: if (last_valide == d_vrai)
1321: {
1322: sf(s_etat_processus, 31);
1323: }
1324:
1325: return;
1326: }
1327:
1328: // Division par i!
1329:
1330: if (i > 1)
1331: {
1332:
1333: if ((s_objet_argument = allocation(s_etat_processus, INT))
1334: == NULL)
1335: {
1336: (*s_etat_processus).erreur_systeme =
1337: d_es_allocation_memoire;
1338: return;
1339: }
1340:
1341: (*((integer8 *) (*s_objet_argument).objet)) = i;
1342:
1343: if (empilement(s_etat_processus, &((*s_etat_processus)
1344: .l_base_pile), s_objet_argument) == d_erreur)
1345: {
1346: liberation(s_etat_processus, s_objet_argument_1);
1347: liberation(s_etat_processus, s_objet_argument_2);
1348: liberation(s_etat_processus, s_objet_argument_3);
1349: liberation(s_etat_processus, s_objet_argument_4);
1350:
1351: (*l_element_courant).suivant = NULL;
1352:
1353: liberation(s_etat_processus, s_objet_resultat);
1354: liberation(s_etat_processus, s_objet_argument);
1355:
1356: if (last_valide == d_vrai)
1357: {
1358: sf(s_etat_processus, 31);
1359: }
1360:
1361: return;
1362: }
1363:
1364: if (i > 2)
1365: {
1366: instruction_fact(s_etat_processus);
1367:
1368: if ((*s_etat_processus).erreur_execution != d_ex)
1369: {
1370: liberation(s_etat_processus, s_objet_argument_1);
1371: liberation(s_etat_processus, s_objet_argument_2);
1372: liberation(s_etat_processus, s_objet_argument_3);
1373: liberation(s_etat_processus, s_objet_argument_4);
1374:
1375: (*l_element_courant).suivant = NULL;
1376:
1377: liberation(s_etat_processus, s_objet_resultat);
1378:
1379: if (last_valide == d_vrai)
1380: {
1381: sf(s_etat_processus, 31);
1382: }
1383:
1384: return;
1385: }
1386: else if ((*s_etat_processus).erreur_systeme != d_es)
1387: {
1388: return;
1389: }
1390: }
1391:
1392: instruction_division(s_etat_processus);
1393:
1394: if ((*s_etat_processus).erreur_execution != d_ex)
1395: {
1396: liberation(s_etat_processus, s_objet_argument_1);
1397: liberation(s_etat_processus, s_objet_argument_2);
1398: liberation(s_etat_processus, s_objet_argument_3);
1399: liberation(s_etat_processus, s_objet_argument_4);
1400:
1401: (*l_element_courant).suivant = NULL;
1402:
1403: liberation(s_etat_processus, s_objet_resultat);
1404:
1405: if (last_valide == d_vrai)
1406: {
1407: sf(s_etat_processus, 31);
1408: }
1409:
1410: return;
1411: }
1412: else if ((*s_etat_processus).erreur_systeme != d_es)
1413: {
1414: return;
1415: }
1416: }
1417:
1418: if (((*l_element_courant).suivant =
1419: allocation_maillon(s_etat_processus)) == NULL)
1420: {
1421: (*s_etat_processus).erreur_systeme =
1422: d_es_allocation_memoire;
1423: return;
1424: }
1425:
1426: l_element_courant = (*l_element_courant).suivant;
1427:
1428: if (depilement(s_etat_processus, &((*s_etat_processus)
1429: .l_base_pile), &((*l_element_courant).donnee))
1430: == d_erreur)
1431: {
1432: liberation(s_etat_processus, s_objet_argument_1);
1433: liberation(s_etat_processus, s_objet_argument_2);
1434: liberation(s_etat_processus, s_objet_argument_3);
1435: liberation(s_etat_processus, s_objet_argument_4);
1436:
1437: (*l_element_courant).donnee = NULL;
1438: (*l_element_courant).suivant = NULL;
1439:
1440: liberation(s_etat_processus, s_objet_resultat);
1441:
1442: if (last_valide == d_vrai)
1443: {
1444: sf(s_etat_processus, 31);
1445: }
1446:
1447: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1448: return;
1449: }
1450:
1451: /*
1452: * Multiplication par le terme (x-a)**i
1453: */
1454:
1455: if (i != 0)
1456: {
1457: if (((*l_element_courant).suivant =
1458: allocation_maillon(s_etat_processus)) == NULL)
1459: {
1460: (*s_etat_processus).erreur_systeme =
1461: d_es_allocation_memoire;
1462: return;
1463: }
1464:
1465: l_element_courant = (*l_element_courant).suivant;
1466:
1467: if (((*l_element_courant).donnee =
1468: copie_objet(s_etat_processus, s_objet_argument_3, 'O'))
1469: == NULL)
1470: {
1471: (*s_etat_processus).erreur_systeme =
1472: d_es_allocation_memoire;
1473: return;
1474: }
1475:
1476: if (zero == d_faux)
1477: {
1478: if (((*l_element_courant).suivant =
1479: allocation_maillon(s_etat_processus)) == NULL)
1480: {
1481: (*s_etat_processus).erreur_systeme =
1482: d_es_allocation_memoire;
1483: return;
1484: }
1485:
1486: l_element_courant = (*l_element_courant).suivant;
1487:
1488: if (((*l_element_courant).donnee =
1489: copie_objet(s_etat_processus, s_objet_argument_2,
1490: 'O')) == NULL)
1491: {
1492: (*s_etat_processus).erreur_systeme =
1493: d_es_allocation_memoire;
1494: return;
1495: }
1496:
1497: if (((*l_element_courant).suivant =
1498: allocation_maillon(s_etat_processus)) == NULL)
1499: {
1500: (*s_etat_processus).erreur_systeme =
1501: d_es_allocation_memoire;
1502: return;
1503: }
1504:
1505: l_element_courant = (*l_element_courant).suivant;
1506:
1507: if (((*l_element_courant).donnee =
1508: allocation(s_etat_processus, FCT)) == NULL)
1509: {
1510: (*s_etat_processus).erreur_systeme =
1511: d_es_allocation_memoire;
1512: return;
1513: }
1514:
1515: (*((struct_fonction *) (*(*l_element_courant).donnee)
1516: .objet)).nombre_arguments = 0;
1517: (*((struct_fonction *) (*(*l_element_courant).donnee)
1518: .objet)).fonction = instruction_moins;
1519:
1520: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1521: .objet)).nom_fonction = malloc(2 *
1522: sizeof(unsigned char))) == NULL)
1523: {
1524: (*s_etat_processus).erreur_systeme =
1525: d_es_allocation_memoire;
1526: return;
1527: }
1528:
1529: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1530: .objet)).nom_fonction, "-");
1531: }
1532:
1533: if (i > 1)
1534: {
1535: if (((*l_element_courant).suivant =
1536: allocation_maillon(s_etat_processus)) == NULL)
1537: {
1538: (*s_etat_processus).erreur_systeme =
1539: d_es_allocation_memoire;
1540: return;
1541: }
1542:
1543: l_element_courant = (*l_element_courant).suivant;
1544:
1545: if (((*l_element_courant).donnee =
1546: allocation(s_etat_processus, INT)) == NULL)
1547: {
1548: (*s_etat_processus).erreur_systeme =
1549: d_es_allocation_memoire;
1550: return;
1551: }
1552:
1553: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = i;
1554:
1555: if (((*l_element_courant).suivant =
1556: allocation_maillon(s_etat_processus)) == NULL)
1557: {
1558: (*s_etat_processus).erreur_systeme =
1559: d_es_allocation_memoire;
1560: return;
1561: }
1562:
1563: l_element_courant = (*l_element_courant).suivant;
1564:
1565: if (((*l_element_courant).donnee =
1566: allocation(s_etat_processus, FCT)) == NULL)
1567: {
1568: (*s_etat_processus).erreur_systeme =
1569: d_es_allocation_memoire;
1570: return;
1571: }
1572:
1573: (*((struct_fonction *) (*(*l_element_courant).donnee)
1574: .objet)).nombre_arguments = 0;
1575: (*((struct_fonction *) (*(*l_element_courant).donnee)
1576: .objet)).fonction = instruction_puissance;
1577:
1578: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1579: .objet)).nom_fonction = malloc(2 *
1580: sizeof(unsigned char))) == NULL)
1581: {
1582: (*s_etat_processus).erreur_systeme =
1583: d_es_allocation_memoire;
1584: return;
1585: }
1586:
1587: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1588: .objet)).nom_fonction, "^");
1589: }
1590:
1591: if (((*l_element_courant).suivant =
1592: allocation_maillon(s_etat_processus)) == NULL)
1593: {
1594: (*s_etat_processus).erreur_systeme =
1595: d_es_allocation_memoire;
1596: return;
1597: }
1598:
1599: l_element_courant = (*l_element_courant).suivant;
1600:
1601: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1602: FCT)) == NULL)
1603: {
1604: (*s_etat_processus).erreur_systeme =
1605: d_es_allocation_memoire;
1606: return;
1607: }
1608:
1609: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1610: .nombre_arguments = 0;
1611: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1612: .fonction = instruction_multiplication;
1613:
1614: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1615: .objet)).nom_fonction = malloc(2 *
1616: sizeof(unsigned char))) == NULL)
1617: {
1618: (*s_etat_processus).erreur_systeme =
1619: d_es_allocation_memoire;
1620: return;
1621: }
1622:
1623: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1624: .objet)).nom_fonction, "*");
1625:
1626: if (((*l_element_courant).suivant =
1627: allocation_maillon(s_etat_processus)) == NULL)
1628: {
1629: (*s_etat_processus).erreur_systeme =
1630: d_es_allocation_memoire;
1631: return;
1632: }
1633:
1634: l_element_courant = (*l_element_courant).suivant;
1635:
1636: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1637: FCT)) == NULL)
1638: {
1639: (*s_etat_processus).erreur_systeme =
1640: 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_plus;
1648:
1649: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1650: .objet)).nom_fonction = malloc(2 *
1651: sizeof(unsigned char))) == NULL)
1652: {
1653: (*s_etat_processus).erreur_systeme =
1654: d_es_allocation_memoire;
1655: return;
1656: }
1657:
1658: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1659: .objet)).nom_fonction, "+");
1660: }
1661: }
1662:
1663: /*
1664: * Fermeture de l'expression
1665: */
1666:
1667: if (last_valide == d_vrai)
1668: {
1669: sf(s_etat_processus, 31);
1670: }
1671:
1672: if (((*l_element_courant).suivant =
1673: allocation_maillon(s_etat_processus)) == NULL)
1674: {
1675: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1676: return;
1677: }
1678:
1679: l_element_courant = (*l_element_courant).suivant;
1680:
1681: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1682: == NULL)
1683: {
1684: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1685: return;
1686: }
1687:
1688: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1689: .nombre_arguments = 0;
1690: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1691: .fonction = instruction_vers_niveau_inferieur;
1692:
1693: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1694: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1695: {
1696: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1697: return;
1698: }
1699:
1700: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1701: .nom_fonction, ">>");
1702:
1703: (*l_element_courant).suivant = NULL;
1704:
1705: /*
1706: * Destruction de la variable locale
1707: */
1708:
1709: (*s_etat_processus).niveau_courant--;
1710:
1711: if (retrait_variable(s_etat_processus, (*((struct_nom *)
1712: (*s_objet_argument_3).objet)).nom, 'L') == d_erreur)
1713: {
1714: liberation(s_etat_processus, s_objet_argument_1);
1715: liberation(s_etat_processus, s_objet_argument_2);
1716: liberation(s_etat_processus, s_objet_argument_3);
1717: liberation(s_etat_processus, s_objet_argument_4);
1718: liberation(s_etat_processus, s_objet_resultat);
1719:
1720: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1721: return;
1722: }
1723: }
1724: else
1725: {
1726: liberation(s_etat_processus, s_objet_argument_1);
1727: liberation(s_etat_processus, s_objet_argument_2);
1728: liberation(s_etat_processus, s_objet_argument_3);
1729: liberation(s_etat_processus, s_objet_argument_4);
1730:
1731: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1732: return;
1733: }
1734:
1735: liberation(s_etat_processus, s_objet_argument_1);
1736: liberation(s_etat_processus, s_objet_argument_2);
1737: liberation(s_etat_processus, s_objet_argument_3);
1738: liberation(s_etat_processus, s_objet_argument_4);
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 'target'
1753: ================================================================================
1754: Entrées :
1755: --------------------------------------------------------------------------------
1756: Sorties :
1757: --------------------------------------------------------------------------------
1758: Effets de bord : néant
1759: ================================================================================
1760: */
1761:
1762: void
1763: instruction_target(struct_processus *s_etat_processus)
1764: {
1765: struct_liste_chainee *l_element_courant;
1766:
1767: struct addrinfo *resolution;
1768: struct addrinfo *resolution_courante;
1769:
1770: struct_objet *s_objet_argument_1;
1771: struct_objet *s_objet_argument_2;
1772:
1773: unsigned long i;
1774: unsigned long nombre_elements;
1775:
1776: (*s_etat_processus).erreur_execution = d_ex;
1777:
1778: if ((*s_etat_processus).affichage_arguments == 'Y')
1779: {
1780: printf("\n TARGET ");
1781:
1782: if ((*s_etat_processus).langue == 'F')
1783: {
1784: printf("(cible d'une socket non connectée)\n\n");
1785: }
1786: else
1787: {
1788: printf("(target of unconnected socket)\n\n");
1789: }
1790:
1791: printf(" 2: %s, %s\n", d_CHN, d_LST);
1792: printf(" 1: %s\n", d_SCK);
1793: printf("-> 1: %s\n", d_SCK);
1794:
1795: return;
1796: }
1797: else if ((*s_etat_processus).test_instruction == 'Y')
1798: {
1799: (*s_etat_processus).nombre_arguments = -1;
1800: return;
1801: }
1802:
1803: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1804: {
1805: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
1806: {
1807: return;
1808: }
1809: }
1810:
1811: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1812: &s_objet_argument_1) == d_erreur)
1813: {
1814: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1815: return;
1816: }
1817:
1818: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1819: &s_objet_argument_2) == d_erreur)
1820: {
1821: liberation(s_etat_processus, s_objet_argument_1);
1822:
1823: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1824: return;
1825: }
1826:
1827: if ((*s_objet_argument_1).type == SCK)
1828: {
1829:
1830: /*
1831: * Vérification du type de socket
1832: */
1833:
1834: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
1835: "STREAM") == 0) || (strcmp((*((struct_socket *)
1836: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
1837: == 0))
1838: {
1839: liberation(s_etat_processus, s_objet_argument_1);
1840: liberation(s_etat_processus, s_objet_argument_2);
1841:
1842: (*s_etat_processus).erreur_execution =
1843: d_ex_erreur_parametre_fichier;
1844: return;
1845: }
1846:
1847: if ((*s_objet_argument_2).type == CHN)
1848: {
1849: /*
1850: * La socket ne peut être que du domaine UNIX
1851: */
1852:
1853: if ((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
1854: != PF_UNIX)
1855: {
1856: liberation(s_etat_processus, s_objet_argument_1);
1857: liberation(s_etat_processus, s_objet_argument_2);
1858:
1859: (*s_etat_processus).erreur_execution =
1860: d_ex_erreur_parametre_fichier;
1861: return;
1862: }
1863:
1864: free((*((struct_socket *) (*s_objet_argument_1).objet))
1865: .adresse_distante);
1866:
1867: if (((*((struct_socket *) (*s_objet_argument_1).objet))
1868: .adresse_distante = transliteration(s_etat_processus,
1869: (unsigned char *) (*s_objet_argument_2).objet,
1870: d_locale, "UTF-8")) == NULL)
1871: {
1872: liberation(s_etat_processus, s_objet_argument_1);
1873: liberation(s_etat_processus, s_objet_argument_2);
1874:
1875: return;
1876: }
1877: }
1878: else if ((*s_objet_argument_2).type == LST)
1879: {
1880: l_element_courant = (struct_liste_chainee *)
1881: (*s_objet_argument_2).objet;
1882: nombre_elements = 0;
1883:
1884: while(l_element_courant != NULL)
1885: {
1886: nombre_elements++;
1887: l_element_courant = (*l_element_courant).suivant;
1888: }
1889:
1890: if (nombre_elements != 2)
1891: {
1892: liberation(s_etat_processus, s_objet_argument_1);
1893: liberation(s_etat_processus, s_objet_argument_2);
1894:
1895: (*s_etat_processus).erreur_execution =
1896: d_ex_erreur_parametre_fichier;
1897: return;
1898: }
1899:
1900: l_element_courant = (struct_liste_chainee *)
1901: (*s_objet_argument_2).objet;
1902:
1903: if ((*(*l_element_courant).donnee).type == VIN)
1904: {
1905: if ((*((struct_vecteur *) (*(*l_element_courant).donnee).objet))
1906: .taille == 4)
1907: {
1908: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1909: .domaine != PF_INET)
1910: {
1911: liberation(s_etat_processus, s_objet_argument_1);
1912: liberation(s_etat_processus, s_objet_argument_2);
1913:
1914: (*s_etat_processus).erreur_execution =
1915: d_ex_erreur_parametre_fichier;
1916: return;
1917: }
1918:
1919: free((*((struct_socket *) (*s_objet_argument_1).objet))
1920: .adresse_distante);
1921:
1922: if (((*((struct_socket *) (*s_objet_argument_1)
1923: .objet)).adresse_distante = malloc(22 *
1924: sizeof(unsigned char))) == NULL)
1925: {
1926: (*s_etat_processus).erreur_systeme =
1927: d_es_allocation_memoire;
1928: return;
1929: }
1930:
1931: (*((struct_socket *) (*s_objet_argument_1).objet))
1932: .adresse_distante[0] = d_code_fin_chaine;
1933:
1934: for(i = 0; i < 4; i++)
1935: {
1936: if ((((integer8 *) (*((struct_vecteur *)
1937: (*(*l_element_courant).donnee).objet)).tableau)
1938: [i] >= 0) && (((integer8 *)
1939: (*((struct_vecteur *) (*(*l_element_courant)
1940: .donnee).objet)).tableau)[i] <= 255))
1941: {
1942: sprintf((*((struct_socket *) (*s_objet_argument_1)
1943: .objet)).adresse_distante,
1944: (i == 0) ? "%s%d" : "%s.%d",
1945: (*((struct_socket *) (*s_objet_argument_1)
1946: .objet)).adresse_distante, (int)
1947: ((integer8 *) (*((struct_vecteur *)
1948: (*(*l_element_courant).donnee).objet))
1949: .tableau)[i]);
1950: }
1951: else
1952: {
1953: liberation(s_etat_processus, s_objet_argument_1);
1954: liberation(s_etat_processus, s_objet_argument_2);
1955:
1956: (*s_etat_processus).erreur_execution =
1957: d_ex_erreur_parametre_fichier;
1958: return;
1959: }
1960: }
1961: }
1962: else if ((*((struct_vecteur *) (*(*l_element_courant).donnee)
1963: .objet)).taille == 16)
1964: {
1965: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1966: .domaine != PF_INET6)
1967: {
1968: liberation(s_etat_processus, s_objet_argument_1);
1969: liberation(s_etat_processus, s_objet_argument_2);
1970:
1971: (*s_etat_processus).erreur_execution =
1972: d_ex_erreur_parametre_fichier;
1973: return;
1974: }
1975:
1976: free((*((struct_socket *) (*s_objet_argument_1).objet))
1977: .adresse_distante);
1978:
1979: if (((*((struct_socket *) (*s_objet_argument_1)
1980: .objet)).adresse_distante = malloc(55 *
1981: sizeof(unsigned char))) == NULL)
1982: {
1983: (*s_etat_processus).erreur_systeme =
1984: d_es_allocation_memoire;
1985: return;
1986: }
1987:
1988: (*((struct_socket *) (*s_objet_argument_1).objet))
1989: .adresse_distante[0] = d_code_fin_chaine;
1990:
1991: for(i = 0; i < 16; i++)
1992: {
1993: if ((((integer8 *) (*((struct_vecteur *)
1994: (*(*l_element_courant).donnee).objet)).tableau)
1995: [i] >= 0) && (((integer8 *)
1996: (*((struct_vecteur *) (*(*l_element_courant)
1997: .donnee).objet)).tableau)[i] <= 255))
1998: {
1999: sprintf((*((struct_socket *) (*s_objet_argument_1)
2000: .objet)).adresse_distante,
2001: (i == 0) ? "%s%d" : "%s:%X",
2002: (*((struct_socket *) (*s_objet_argument_1)
2003: .objet)).adresse_distante, (int)
2004: ((integer8 *) (*((struct_vecteur *)
2005: (*(*l_element_courant).donnee).objet))
2006: .tableau)[i]);
2007: }
2008: else
2009: {
2010: liberation(s_etat_processus, s_objet_argument_1);
2011: liberation(s_etat_processus, s_objet_argument_2);
2012:
2013: (*s_etat_processus).erreur_execution =
2014: d_ex_erreur_parametre_fichier;
2015: return;
2016: }
2017: }
2018: }
2019: else
2020: {
2021: liberation(s_etat_processus, s_objet_argument_1);
2022: liberation(s_etat_processus, s_objet_argument_2);
2023:
2024: (*s_etat_processus).erreur_execution =
2025: d_ex_erreur_parametre_fichier;
2026: return;
2027: }
2028: }
2029: else if ((*(*l_element_courant).donnee).type == CHN)
2030: {
2031: resolution = NULL;
2032:
2033: if (getaddrinfo((unsigned char *) (*(*l_element_courant)
2034: .donnee).objet, NULL, NULL, &resolution) != 0)
2035: {
2036: liberation(s_etat_processus, s_objet_argument_1);
2037: liberation(s_etat_processus, s_objet_argument_2);
2038:
2039: if (resolution != NULL)
2040: {
2041: freeaddrinfo(resolution);
2042: }
2043:
2044: (*s_etat_processus).erreur_execution =
2045: d_ex_erreur_acces_fichier;
2046: return;
2047: }
2048:
2049: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2050: .domaine == PF_INET)
2051: { // Résolution du nom en IPv4
2052: resolution_courante = resolution;
2053:
2054: while(resolution_courante != NULL)
2055: {
2056: if ((*resolution_courante).ai_family == AF_INET)
2057: {
2058: break;
2059: }
2060:
2061: resolution_courante = (*resolution_courante).ai_next;
2062: }
2063:
2064: if (resolution_courante == NULL)
2065: {
2066: liberation(s_etat_processus, s_objet_argument_1);
2067: liberation(s_etat_processus, s_objet_argument_2);
2068:
2069: freeaddrinfo(resolution);
2070:
2071: (*s_etat_processus).erreur_execution =
2072: d_ex_erreur_acces_fichier;
2073: return;
2074: }
2075:
2076: free((*((struct_socket *) (*s_objet_argument_1).objet))
2077: .adresse_distante);
2078:
2079: if (((*((struct_socket *) (*s_objet_argument_1)
2080: .objet)).adresse_distante = malloc(22 *
2081: sizeof(unsigned char))) == NULL)
2082: {
2083: (*s_etat_processus).erreur_systeme =
2084: d_es_allocation_memoire;
2085: return;
2086: }
2087:
2088: sprintf((*((struct_socket *) (*s_objet_argument_1).objet))
2089: .adresse_distante, "%d.%d.%d.%d",
2090: (ntohl((*((struct sockaddr_in *)
2091: (*resolution_courante).ai_addr)).sin_addr.s_addr)
2092: >> 24) & 0xFF,
2093: (ntohl((*((struct sockaddr_in *)
2094: (*resolution_courante).ai_addr)).sin_addr.s_addr)
2095: >> 16) & 0xFF,
2096: (ntohl((*((struct sockaddr_in *)
2097: (*resolution_courante).ai_addr)).sin_addr.s_addr)
2098: >> 8) & 0xFF,
2099: ntohl((*((struct sockaddr_in *)
2100: (*resolution_courante).ai_addr)).sin_addr.s_addr)
2101: & 0xFF);
2102: }
2103: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2104: .domaine == PF_INET6)
2105: { // Résolution du nom en IPv6
2106: # ifdef IPV6
2107: resolution_courante = resolution;
2108:
2109: while(resolution_courante != NULL)
2110: {
2111: if ((*resolution_courante).ai_family == AF_INET6)
2112: {
2113: break;
2114: }
2115:
2116: resolution_courante = (*resolution_courante).ai_next;
2117: }
2118:
2119: if (resolution_courante == NULL)
2120: {
2121: liberation(s_etat_processus, s_objet_argument_1);
2122: liberation(s_etat_processus, s_objet_argument_2);
2123:
2124: freeaddrinfo(resolution);
2125:
2126: (*s_etat_processus).erreur_execution =
2127: d_ex_erreur_acces_fichier;
2128: return;
2129: }
2130:
2131: if (((*((struct_socket *) (*s_objet_argument_1)
2132: .objet)).adresse_distante = malloc(55 *
2133: sizeof(unsigned char))) == NULL)
2134: {
2135: (*s_etat_processus).erreur_systeme =
2136: d_es_allocation_memoire;
2137: return;
2138: }
2139:
2140: (*((struct_socket *) (*s_objet_argument_1).objet))
2141: .adresse_distante[0] = d_code_fin_chaine;
2142:
2143: for(i = 0; i < 16; i++)
2144: {
2145: sprintf((*((struct_socket *) (*s_objet_argument_1)
2146: .objet)).adresse_distante,
2147: (i == 0) ? "%s%X" : "%s:%X",
2148: (*((struct_socket *) (*s_objet_argument_1)
2149: .objet)).adresse_distante,
2150: (*((struct sockaddr_in6 *)
2151: (*resolution_courante).ai_addr)).sin6_addr
2152: .s6_addr[i]);
2153: }
2154: # else
2155: if ((*s_etat_processus).langue == 'F')
2156: {
2157: printf("+++Attention : Support du protocole"
2158: " IPv6 indisponible\n");
2159: }
2160: else
2161: {
2162: printf("+++Warning : IPv6 support "
2163: "unavailable\n");
2164: }
2165: # endif
2166: }
2167: else
2168: {
2169: liberation(s_etat_processus, s_objet_argument_1);
2170: liberation(s_etat_processus, s_objet_argument_2);
2171:
2172: freeaddrinfo(resolution);
2173:
2174: (*s_etat_processus).erreur_execution =
2175: d_ex_erreur_parametre_fichier;
2176: return;
2177: }
2178:
2179: freeaddrinfo(resolution);
2180: }
2181: else
2182: {
2183: liberation(s_etat_processus, s_objet_argument_1);
2184: liberation(s_etat_processus, s_objet_argument_2);
2185:
2186: (*s_etat_processus).erreur_execution =
2187: d_ex_erreur_parametre_fichier;
2188: return;
2189: }
2190:
2191: l_element_courant = (*l_element_courant).suivant;
2192:
2193: if ((*(*l_element_courant).donnee).type == INT)
2194: {
2195: if (((*((integer8 *) (*(*l_element_courant).donnee).objet))
2196: >= 0) && ((*((integer8 *) (*(*l_element_courant)
2197: .donnee).objet)) <= 65535))
2198: {
2199: sprintf((*((struct_socket *) (*s_objet_argument_1)
2200: .objet)).adresse_distante, "%s(%u)",
2201: (*((struct_socket *) (*s_objet_argument_1)
2202: .objet)).adresse_distante, (unsigned int)
2203: (*((integer8 *) (*(*l_element_courant).donnee)
2204: .objet)));
2205: }
2206: else
2207: {
2208: liberation(s_etat_processus, s_objet_argument_1);
2209: liberation(s_etat_processus, s_objet_argument_2);
2210:
2211: (*s_etat_processus).erreur_execution =
2212: d_ex_erreur_parametre_fichier;
2213: return;
2214: }
2215: }
2216: else
2217: {
2218: liberation(s_etat_processus, s_objet_argument_1);
2219: liberation(s_etat_processus, s_objet_argument_2);
2220:
2221: (*s_etat_processus).erreur_execution =
2222: d_ex_erreur_parametre_fichier;
2223: return;
2224: }
2225: }
2226: else
2227: {
2228: liberation(s_etat_processus, s_objet_argument_1);
2229: liberation(s_etat_processus, s_objet_argument_2);
2230:
2231: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2232: return;
2233: }
2234: }
2235: else
2236: {
2237: liberation(s_etat_processus, s_objet_argument_1);
2238: liberation(s_etat_processus, s_objet_argument_2);
2239:
2240: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2241: return;
2242: }
2243:
2244: liberation(s_etat_processus, s_objet_argument_2);
2245:
2246: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2247: s_objet_argument_1) == d_erreur)
2248: {
2249: return;
2250: }
2251:
2252: return;
2253: }
2254:
2255:
2256: /*
2257: ================================================================================
2258: Fonction 'tail'
2259: ================================================================================
2260: Entrées :
2261: --------------------------------------------------------------------------------
2262: Sorties :
2263: --------------------------------------------------------------------------------
2264: Effets de bord : néant
2265: ================================================================================
2266: */
2267:
2268: void
2269: instruction_tail(struct_processus *s_etat_processus)
2270: {
2271: integer8 longueur;
2272:
2273: struct_liste_chainee *l_element_courant;
2274:
2275: struct_objet *s_objet_argument;
2276: struct_objet *s_objet_resultat;
2277:
2278: (*s_etat_processus).erreur_execution = d_ex;
2279:
2280: if ((*s_etat_processus).affichage_arguments == 'Y')
2281: {
2282: printf("\n TAIL ");
2283:
2284: if ((*s_etat_processus).langue == 'F')
2285: {
2286: printf("(remplace une liste par tous ses éléments hormis "
2287: "son premier)\n\n");
2288: }
2289: else
2290: {
2291: printf("(replace a list by all but its first element)\n\n");
2292: }
2293:
2294: printf(" 1: %s\n", d_LST);
2295: printf("-> 1: %s\n", d_LST);
2296:
2297: return;
2298: }
2299: else if ((*s_etat_processus).test_instruction == 'Y')
2300: {
2301: (*s_etat_processus).nombre_arguments = -1;
2302: return;
2303: }
2304:
2305: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2306: {
2307: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2308: {
2309: return;
2310: }
2311: }
2312:
2313: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2314: &s_objet_argument) == d_erreur)
2315: {
2316: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2317: return;
2318: }
2319:
2320: if ((*s_objet_argument).type == LST)
2321: {
2322: l_element_courant = (*s_objet_argument).objet;
2323: longueur = 0;
2324:
2325: while(l_element_courant != NULL)
2326: {
2327: longueur++;
2328: l_element_courant = (*l_element_courant).suivant;
2329: }
2330:
2331: if (longueur == 0)
2332: {
2333: if ((s_objet_resultat = allocation(s_etat_processus, LST))
2334: == NULL)
2335: {
2336: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2337: return;
2338: }
2339:
2340: (*s_objet_resultat).objet = NULL;
2341: }
2342: else
2343: {
2344: if ((s_objet_resultat = copie_objet(s_etat_processus,
2345: s_objet_argument, 'N')) == NULL)
2346: {
2347: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2348: return;
2349: }
2350:
2351: l_element_courant = (*s_objet_resultat).objet;
2352:
2353: (*s_objet_resultat).objet = (*((struct_liste_chainee *)
2354: (*s_objet_resultat).objet)).suivant;
2355:
2356: liberation(s_etat_processus, (*l_element_courant).donnee);
2357: free(l_element_courant);
2358: }
2359: }
2360: else
2361: {
2362: liberation(s_etat_processus, s_objet_argument);
2363:
2364: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2365: return;
2366: }
2367:
2368: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2369: s_objet_resultat) == d_erreur)
2370: {
2371: return;
2372: }
2373:
2374: liberation(s_etat_processus, s_objet_argument);
2375:
2376: return;
2377: }
2378:
2379: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_t2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src