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