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