![[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.20 ! bertrand 3: RPL/2 (R) version 4.0.20
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:
1.13 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 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:
1.15 bertrand 860: # ifndef OS2
1.1 bertrand 861: if ((getrusage(RUSAGE_SELF, &s_usage_processus_pere)) != 0)
862: {
863: (*s_etat_processus).erreur_systeme = d_es_processus;
864: return;
865: }
866:
867: if ((getrusage(RUSAGE_CHILDREN, &s_usage_processus_fils)) != 0)
868: {
869: (*s_etat_processus).erreur_systeme = d_es_processus;
870: return;
871: }
1.15 bertrand 872: # else
873: s_usage_processus_pere.ru_utime.tv_sec = 0;
874: s_usage_processus_pere.ru_utime.tv_usec = 0;
875: s_usage_processus_pere.ru_stime.tv_sec = 0;
876: s_usage_processus_pere.ru_stime.tv_usec = 0;
877: s_usage_processus_fils.ru_utime.tv_sec = 0;
878: s_usage_processus_fils.ru_utime.tv_usec = 0;
879: s_usage_processus_fils.ru_stime.tv_sec = 0;
880: s_usage_processus_fils.ru_stime.tv_usec = 0;
881: # endif
1.1 bertrand 882:
883: /*
884: * Initialisation de la liste
885: */
886:
887: if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
888: {
889: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
890: return;
891: }
892:
893: /*
894: * User time du processus père (séquenceur)
895: */
896:
897: if ((l_element_courant = allocation_maillon(s_etat_processus)) == NULL)
898: {
899: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
900: return;
901: }
902:
903: (*s_objet).objet = l_element_courant;
904:
905: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
906: == NULL)
907: {
908: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
909: return;
910: }
911:
912: (*((real8 *) (*(*l_element_courant).donnee).objet)) =
913: s_usage_processus_pere.ru_utime.tv_sec +
914: (((real8) s_usage_processus_pere.ru_utime.tv_usec) /
915: ((real8) 1E6));
916:
917: /*
918: * System time du processus père
919: */
920:
921: if (((*l_element_courant).suivant =
922: allocation_maillon(s_etat_processus)) == NULL)
923: {
924: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
925: return;
926: }
927:
928: l_element_courant = (*l_element_courant).suivant;
929:
930: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
931: == NULL)
932: {
933: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
934: return;
935: }
936:
937: (*((real8 *) (*(*l_element_courant).donnee).objet)) =
938: s_usage_processus_pere.ru_stime.tv_sec +
939: (((real8) s_usage_processus_pere.ru_stime.tv_usec) /
940: ((real8) 1E6));
941:
942: /*
943: * User time des processus fils achevés
944: */
945:
946: if (((*l_element_courant).suivant =
947: allocation_maillon(s_etat_processus)) == NULL)
948: {
949: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
950: return;
951: }
952:
953: l_element_courant = (*l_element_courant).suivant;
954:
955: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
956: == NULL)
957: {
958: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
959: return;
960: }
961:
962: (*((real8 *) (*(*l_element_courant).donnee).objet)) =
963: s_usage_processus_fils.ru_utime.tv_sec +
964: (((real8) s_usage_processus_fils.ru_utime.tv_usec) /
965: ((real8) 1E6));
966:
967: /*
968: * System time des processus fils achevés
969: */
970:
971: if (((*l_element_courant).suivant =
972: allocation_maillon(s_etat_processus)) == NULL)
973: {
974: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
975: return;
976: }
977:
978: l_element_courant = (*l_element_courant).suivant;
979:
980: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
981: == NULL)
982: {
983: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
984: return;
985: }
986:
987: (*((real8 *) (*(*l_element_courant).donnee).objet)) =
988: s_usage_processus_fils.ru_stime.tv_sec +
989: (((real8) s_usage_processus_fils.ru_stime.tv_usec) /
990: ((real8) 1E6));
991:
992: /*
993: * Fermeture de la liste
994: */
995:
996: (*l_element_courant).suivant = NULL;
997:
998: /*
999: * Empilement du résultat
1000: */
1001:
1002: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1003: s_objet) == d_erreur)
1004: {
1005: return;
1006: }
1007:
1008: return;
1009: }
1010:
1011:
1012: /*
1013: ================================================================================
1014: Fonction 'taylr'
1015: ================================================================================
1016: Entrées :
1017: --------------------------------------------------------------------------------
1018: Sorties :
1019: --------------------------------------------------------------------------------
1020: Effets de bord : néant
1021: ================================================================================
1022: */
1023:
1024: void
1025: instruction_taylr(struct_processus *s_etat_processus)
1026: {
1027: integer8 i;
1028:
1029: logical1 last_valide;
1030: logical1 zero;
1031:
1032: struct_liste_chainee *l_element_courant;
1033:
1034: struct_objet *s_objet_argument;
1035: struct_objet *s_objet_argument_1;
1036: struct_objet *s_objet_argument_2;
1037: struct_objet *s_objet_argument_3;
1038: struct_objet *s_objet_argument_4;
1039: struct_objet *s_objet_resultat;
1040: struct_objet *s_objet_variable_derivation;
1041:
1042: struct_variable s_variable;
1043:
1044: (*s_etat_processus).erreur_execution = d_ex;
1045:
1046: if ((*s_etat_processus).affichage_arguments == 'Y')
1047: {
1048: printf("\n TAYLR ");
1049:
1050: if ((*s_etat_processus).langue == 'F')
1051: {
1052: printf("(série de Taylor)\n\n");
1053: }
1054: else
1055: {
1056: printf("(Taylor serie)\n\n");
1057: }
1058:
1059: printf(" 4: %s\n", d_ALG);
1060: printf(" 3: %s\n", d_NOM);
1061: printf(" 2: %s, %s\n", d_INT, d_REL);
1062: printf(" 1: %s\n", d_INT);
1063: printf("-> 1: %s\n\n", d_ALG);
1064:
1065: return;
1066: }
1067: else if ((*s_etat_processus).test_instruction == 'Y')
1068: {
1069: (*s_etat_processus).nombre_arguments = -1;
1070: return;
1071: }
1072:
1073: if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
1074: {
1075: if (empilement_pile_last(s_etat_processus, 4) == d_erreur)
1076: {
1077: return;
1078: }
1079: }
1080:
1081: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1082: &s_objet_argument_1) == d_erreur)
1083: {
1084: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1085: return;
1086: }
1087:
1088: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1089: &s_objet_argument_2) == d_erreur)
1090: {
1091: liberation(s_etat_processus, s_objet_argument_1);
1092:
1093: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1094: return;
1095: }
1096:
1097: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1098: &s_objet_argument_3) == d_erreur)
1099: {
1100: liberation(s_etat_processus, s_objet_argument_1);
1101: liberation(s_etat_processus, s_objet_argument_2);
1102:
1103: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1104: return;
1105: }
1106:
1107: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1108: &s_objet_argument_4) == d_erreur)
1109: {
1110: liberation(s_etat_processus, s_objet_argument_1);
1111: liberation(s_etat_processus, s_objet_argument_2);
1112: liberation(s_etat_processus, s_objet_argument_3);
1113: liberation(s_etat_processus, s_objet_argument_4);
1114:
1115: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1116: return;
1117: }
1118:
1119: if (((*s_objet_argument_4).type == ALG) &&
1120: ((*s_objet_argument_3).type == NOM) &&
1121: (((*s_objet_argument_2).type == INT) ||
1122: ((*s_objet_argument_2).type == REL)) &&
1123: ((*s_objet_argument_1).type == INT))
1124: {
1125: if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
1126: {
1127: liberation(s_etat_processus, s_objet_argument_1);
1128: liberation(s_etat_processus, s_objet_argument_2);
1129: liberation(s_etat_processus, s_objet_argument_3);
1130: liberation(s_etat_processus, s_objet_argument_4);
1131:
1132: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1133: return;
1134: }
1135:
1136: if ((*s_objet_argument_2).type == REL)
1137: {
1138: if ((*((real8 *) (*s_objet_argument_2).objet)) == 0)
1139: {
1140: zero = d_vrai;
1141: }
1142: else
1143: {
1144: zero = d_faux;
1145: }
1146: }
1147: else
1148: {
1149: if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0)
1150: {
1151: zero = d_vrai;
1152: }
1153: else
1154: {
1155: zero = d_faux;
1156: }
1157: }
1158:
1159: /*
1160: * Conversion du drapeau symbole des variables symboliques
1161: */
1162:
1163: l_element_courant = (*s_objet_argument_4).objet;
1164:
1165: while(l_element_courant != NULL)
1166: {
1167: if ((*(*l_element_courant).donnee).type == NOM)
1168: {
1169: if (strcmp((*((struct_nom *) (*(*l_element_courant).donnee)
1170: .objet)).nom, (*((struct_nom *) (*s_objet_argument_3)
1171: .objet)).nom) == 0)
1172: {
1173: (*((struct_nom *) (*(*l_element_courant).donnee).objet))
1174: .symbole = d_faux;
1175: }
1176: }
1177:
1178: l_element_courant = (*l_element_courant).suivant;
1179: }
1180:
1181: /*
1182: * Création de la variable locale et initialisation
1183: */
1184:
1185: (*s_etat_processus).niveau_courant++;
1186:
1187: if ((s_variable.nom = malloc((strlen((*((struct_nom *)
1188: (*s_objet_argument_3).objet)).nom) + 1) *
1189: sizeof(unsigned char))) == NULL)
1190: {
1191: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1192: return;
1193: }
1194:
1195: s_variable.niveau = (*s_etat_processus).niveau_courant;
1196: strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_argument_3)
1197: .objet)).nom);
1198:
1199: if ((s_variable.objet = copie_objet(s_etat_processus,
1200: s_objet_argument_2, 'O')) == NULL)
1201: {
1202: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1203: return;
1204: }
1205:
1206: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')
1207: == d_erreur)
1208: {
1209: return;
1210: }
1211:
1212: /*
1213: * Création de la série
1214: */
1215:
1216: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
1217: {
1218: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1219: return;
1220: }
1221:
1222: if (((*s_objet_resultat).objet =
1223: allocation_maillon(s_etat_processus)) == NULL)
1224: {
1225: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1226: return;
1227: }
1228:
1229: l_element_courant = (*s_objet_resultat).objet;
1230:
1231: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1232: == NULL)
1233: {
1234: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1235: return;
1236: }
1237:
1238: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1239: .nombre_arguments = 0;
1240: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1241: .fonction = instruction_vers_niveau_superieur;
1242:
1243: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1244: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1245: {
1246: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1247: return;
1248: }
1249:
1250: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1251: .nom_fonction, "<<");
1252:
1253: if (last_valide == d_vrai)
1254: {
1255: cf(s_etat_processus, 31);
1256: }
1257:
1258: /*
1259: * Calcul de la série de Taylor
1260: *
1261: * s(x) = \sum_{i=0}{n} (1/i!)*((d^i f(x=a))/d(x^i)*(x-a)^i)
1262: */
1263:
1264: for(i = 0; (i <= (*((integer8 *) (*s_objet_argument_1).objet))) &&
1265: ((*s_etat_processus).var_volatile_requete_arret == 0); i++)
1266: {
1267: /*
1268: * Calcul de ((d^i f(x=a))/d(x^i)*(x-a)^i)/i!
1269: */
1270:
1271: if (i != 0)
1272: {
1273: // Calcul de la valeur de la dérivée n-ième
1274: // Expression empilée puis dérivée et sauvegardée dans
1275: // s_argument_4.
1276:
1277: if (empilement(s_etat_processus, &((*s_etat_processus)
1278: .l_base_pile), s_objet_argument_4) == d_erreur)
1279: {
1280: if (last_valide == d_vrai)
1281: {
1282: sf(s_etat_processus, 31);
1283: }
1284:
1285: return;
1286: }
1287:
1288: if ((s_objet_variable_derivation =
1289: copie_objet(s_etat_processus, s_objet_argument_3, 'O'))
1290: == NULL)
1291: {
1292: (*s_etat_processus).erreur_systeme =
1293: d_es_allocation_memoire;
1294: return;
1295: }
1296:
1297: if (empilement(s_etat_processus, &((*s_etat_processus)
1298: .l_base_pile), s_objet_variable_derivation) == d_erreur)
1299: {
1300: if (last_valide == d_vrai)
1301: {
1302: sf(s_etat_processus, 31);
1303: }
1304:
1305: return;
1306: }
1307:
1308: instruction_der(s_etat_processus);
1309:
1310: if ((*s_etat_processus).erreur_execution != d_ex)
1311: {
1312: liberation(s_etat_processus, s_objet_argument_1);
1313: liberation(s_etat_processus, s_objet_argument_2);
1314: liberation(s_etat_processus, s_objet_argument_3);
1315:
1316: (*l_element_courant).suivant = NULL;
1317:
1318: liberation(s_etat_processus, s_objet_resultat);
1319:
1320: if (last_valide == d_vrai)
1321: {
1322: sf(s_etat_processus, 31);
1323: }
1324:
1325: return;
1326: }
1327: else if ((*s_etat_processus).erreur_systeme != d_es)
1328: {
1329: return;
1330: }
1331:
1332: if ((*s_etat_processus).var_volatile_requete_arret != 0)
1333: {
1334: /*
1335: * instruction_der() n'a rien renvoyé dans la pile. On
1336: * injecte une valeur nulle dans s_objet_argument_4.
1337: */
1338:
1339: if ((s_objet_argument_4 = allocation(s_etat_processus,
1340: INT)) == NULL)
1341: {
1342: (*s_etat_processus).erreur_systeme =
1343: d_es_allocation_memoire;
1344: return;
1345: }
1346: }
1347: else if (depilement(s_etat_processus, &((*s_etat_processus)
1348: .l_base_pile), &s_objet_argument_4) == d_erreur)
1349: {
1350: liberation(s_etat_processus, s_objet_argument_1);
1351: liberation(s_etat_processus, s_objet_argument_2);
1352: liberation(s_etat_processus, s_objet_argument_3);
1353:
1354: (*l_element_courant).suivant = NULL;
1355:
1356: liberation(s_etat_processus, s_objet_resultat);
1357:
1358: if (last_valide == d_vrai)
1359: {
1360: sf(s_etat_processus, 31);
1361: }
1362:
1363: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1364: return;
1365: }
1366: }
1367:
1368: if (evaluation(s_etat_processus, s_objet_argument_4, 'E')
1369: == d_erreur)
1370: {
1371: liberation(s_etat_processus, s_objet_argument_1);
1372: liberation(s_etat_processus, s_objet_argument_2);
1373: liberation(s_etat_processus, s_objet_argument_3);
1374: liberation(s_etat_processus, s_objet_argument_4);
1375:
1376: (*l_element_courant).suivant = NULL;
1377:
1378: liberation(s_etat_processus, s_objet_resultat);
1379:
1380: if (last_valide == d_vrai)
1381: {
1382: sf(s_etat_processus, 31);
1383: }
1384:
1385: return;
1386: }
1387:
1388: // Division par i!
1389:
1390: if (i > 1)
1391: {
1392:
1393: if ((s_objet_argument = allocation(s_etat_processus, INT))
1394: == NULL)
1395: {
1396: (*s_etat_processus).erreur_systeme =
1397: d_es_allocation_memoire;
1398: return;
1399: }
1400:
1401: (*((integer8 *) (*s_objet_argument).objet)) = i;
1402:
1403: if (empilement(s_etat_processus, &((*s_etat_processus)
1404: .l_base_pile), s_objet_argument) == d_erreur)
1405: {
1406: liberation(s_etat_processus, s_objet_argument_1);
1407: liberation(s_etat_processus, s_objet_argument_2);
1408: liberation(s_etat_processus, s_objet_argument_3);
1409: liberation(s_etat_processus, s_objet_argument_4);
1410:
1411: (*l_element_courant).suivant = NULL;
1412:
1413: liberation(s_etat_processus, s_objet_resultat);
1414: liberation(s_etat_processus, s_objet_argument);
1415:
1416: if (last_valide == d_vrai)
1417: {
1418: sf(s_etat_processus, 31);
1419: }
1420:
1421: return;
1422: }
1423:
1424: if (i > 2)
1425: {
1426: instruction_fact(s_etat_processus);
1427:
1428: if ((*s_etat_processus).erreur_execution != d_ex)
1429: {
1430: liberation(s_etat_processus, s_objet_argument_1);
1431: liberation(s_etat_processus, s_objet_argument_2);
1432: liberation(s_etat_processus, s_objet_argument_3);
1433: liberation(s_etat_processus, s_objet_argument_4);
1434:
1435: (*l_element_courant).suivant = NULL;
1436:
1437: liberation(s_etat_processus, s_objet_resultat);
1438:
1439: if (last_valide == d_vrai)
1440: {
1441: sf(s_etat_processus, 31);
1442: }
1443:
1444: return;
1445: }
1446: else if ((*s_etat_processus).erreur_systeme != d_es)
1447: {
1448: return;
1449: }
1450: }
1451:
1452: instruction_division(s_etat_processus);
1453:
1454: if ((*s_etat_processus).erreur_execution != d_ex)
1455: {
1456: liberation(s_etat_processus, s_objet_argument_1);
1457: liberation(s_etat_processus, s_objet_argument_2);
1458: liberation(s_etat_processus, s_objet_argument_3);
1459: liberation(s_etat_processus, s_objet_argument_4);
1460:
1461: (*l_element_courant).suivant = NULL;
1462:
1463: liberation(s_etat_processus, s_objet_resultat);
1464:
1465: if (last_valide == d_vrai)
1466: {
1467: sf(s_etat_processus, 31);
1468: }
1469:
1470: return;
1471: }
1472: else if ((*s_etat_processus).erreur_systeme != d_es)
1473: {
1474: return;
1475: }
1476: }
1477:
1478: if (((*l_element_courant).suivant =
1479: allocation_maillon(s_etat_processus)) == NULL)
1480: {
1481: (*s_etat_processus).erreur_systeme =
1482: d_es_allocation_memoire;
1483: return;
1484: }
1485:
1486: l_element_courant = (*l_element_courant).suivant;
1487:
1488: if (depilement(s_etat_processus, &((*s_etat_processus)
1489: .l_base_pile), &((*l_element_courant).donnee))
1490: == d_erreur)
1491: {
1492: liberation(s_etat_processus, s_objet_argument_1);
1493: liberation(s_etat_processus, s_objet_argument_2);
1494: liberation(s_etat_processus, s_objet_argument_3);
1495: liberation(s_etat_processus, s_objet_argument_4);
1496:
1497: (*l_element_courant).donnee = NULL;
1498: (*l_element_courant).suivant = NULL;
1499:
1500: liberation(s_etat_processus, s_objet_resultat);
1501:
1502: if (last_valide == d_vrai)
1503: {
1504: sf(s_etat_processus, 31);
1505: }
1506:
1507: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1508: return;
1509: }
1510:
1511: /*
1512: * Multiplication par le terme (x-a)**i
1513: */
1514:
1515: if (i != 0)
1516: {
1517: if (((*l_element_courant).suivant =
1518: allocation_maillon(s_etat_processus)) == NULL)
1519: {
1520: (*s_etat_processus).erreur_systeme =
1521: d_es_allocation_memoire;
1522: return;
1523: }
1524:
1525: l_element_courant = (*l_element_courant).suivant;
1526:
1527: if (((*l_element_courant).donnee =
1528: copie_objet(s_etat_processus, s_objet_argument_3, 'O'))
1529: == NULL)
1530: {
1531: (*s_etat_processus).erreur_systeme =
1532: d_es_allocation_memoire;
1533: return;
1534: }
1535:
1536: if (zero == d_faux)
1537: {
1538: if (((*l_element_courant).suivant =
1539: allocation_maillon(s_etat_processus)) == NULL)
1540: {
1541: (*s_etat_processus).erreur_systeme =
1542: d_es_allocation_memoire;
1543: return;
1544: }
1545:
1546: l_element_courant = (*l_element_courant).suivant;
1547:
1548: if (((*l_element_courant).donnee =
1549: copie_objet(s_etat_processus, s_objet_argument_2,
1550: 'O')) == NULL)
1551: {
1552: (*s_etat_processus).erreur_systeme =
1553: d_es_allocation_memoire;
1554: return;
1555: }
1556:
1557: if (((*l_element_courant).suivant =
1558: allocation_maillon(s_etat_processus)) == NULL)
1559: {
1560: (*s_etat_processus).erreur_systeme =
1561: d_es_allocation_memoire;
1562: return;
1563: }
1564:
1565: l_element_courant = (*l_element_courant).suivant;
1566:
1567: if (((*l_element_courant).donnee =
1568: allocation(s_etat_processus, FCT)) == NULL)
1569: {
1570: (*s_etat_processus).erreur_systeme =
1571: d_es_allocation_memoire;
1572: return;
1573: }
1574:
1575: (*((struct_fonction *) (*(*l_element_courant).donnee)
1576: .objet)).nombre_arguments = 0;
1577: (*((struct_fonction *) (*(*l_element_courant).donnee)
1578: .objet)).fonction = instruction_moins;
1579:
1580: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1581: .objet)).nom_fonction = malloc(2 *
1582: sizeof(unsigned char))) == NULL)
1583: {
1584: (*s_etat_processus).erreur_systeme =
1585: d_es_allocation_memoire;
1586: return;
1587: }
1588:
1589: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1590: .objet)).nom_fonction, "-");
1591: }
1592:
1593: if (i > 1)
1594: {
1595: if (((*l_element_courant).suivant =
1596: allocation_maillon(s_etat_processus)) == NULL)
1597: {
1598: (*s_etat_processus).erreur_systeme =
1599: d_es_allocation_memoire;
1600: return;
1601: }
1602:
1603: l_element_courant = (*l_element_courant).suivant;
1604:
1605: if (((*l_element_courant).donnee =
1606: allocation(s_etat_processus, INT)) == NULL)
1607: {
1608: (*s_etat_processus).erreur_systeme =
1609: d_es_allocation_memoire;
1610: return;
1611: }
1612:
1613: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = i;
1614:
1615: if (((*l_element_courant).suivant =
1616: allocation_maillon(s_etat_processus)) == NULL)
1617: {
1618: (*s_etat_processus).erreur_systeme =
1619: d_es_allocation_memoire;
1620: return;
1621: }
1622:
1623: l_element_courant = (*l_element_courant).suivant;
1624:
1625: if (((*l_element_courant).donnee =
1626: allocation(s_etat_processus, FCT)) == NULL)
1627: {
1628: (*s_etat_processus).erreur_systeme =
1629: d_es_allocation_memoire;
1630: return;
1631: }
1632:
1633: (*((struct_fonction *) (*(*l_element_courant).donnee)
1634: .objet)).nombre_arguments = 0;
1635: (*((struct_fonction *) (*(*l_element_courant).donnee)
1636: .objet)).fonction = instruction_puissance;
1637:
1638: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1639: .objet)).nom_fonction = malloc(2 *
1640: sizeof(unsigned char))) == NULL)
1641: {
1642: (*s_etat_processus).erreur_systeme =
1643: d_es_allocation_memoire;
1644: return;
1645: }
1646:
1647: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1648: .objet)).nom_fonction, "^");
1649: }
1650:
1651: if (((*l_element_courant).suivant =
1652: allocation_maillon(s_etat_processus)) == NULL)
1653: {
1654: (*s_etat_processus).erreur_systeme =
1655: d_es_allocation_memoire;
1656: return;
1657: }
1658:
1659: l_element_courant = (*l_element_courant).suivant;
1660:
1661: if (((*l_element_courant).donnee = allocation(s_etat_processus,
1662: FCT)) == NULL)
1663: {
1664: (*s_etat_processus).erreur_systeme =
1665: d_es_allocation_memoire;
1666: return;
1667: }
1668:
1669: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1670: .nombre_arguments = 0;
1671: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1672: .fonction = instruction_multiplication;
1673:
1674: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1675: .objet)).nom_fonction = malloc(2 *
1676: sizeof(unsigned char))) == NULL)
1677: {
1678: (*s_etat_processus).erreur_systeme =
1679: d_es_allocation_memoire;
1680: return;
1681: }
1682:
1683: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1684: .objet)).nom_fonction, "*");
1685:
1686: if (((*l_element_courant).suivant =
1687: allocation_maillon(s_etat_processus)) == NULL)
1688: {
1689: (*s_etat_processus).erreur_systeme =
1690: 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,
1697: FCT)) == NULL)
1698: {
1699: (*s_etat_processus).erreur_systeme =
1700: d_es_allocation_memoire;
1701: return;
1702: }
1703:
1704: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1705: .nombre_arguments = 0;
1706: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1707: .fonction = instruction_plus;
1708:
1709: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
1710: .objet)).nom_fonction = malloc(2 *
1711: sizeof(unsigned char))) == NULL)
1712: {
1713: (*s_etat_processus).erreur_systeme =
1714: d_es_allocation_memoire;
1715: return;
1716: }
1717:
1718: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
1719: .objet)).nom_fonction, "+");
1720: }
1721: }
1722:
1723: /*
1724: * Fermeture de l'expression
1725: */
1726:
1727: if (last_valide == d_vrai)
1728: {
1729: sf(s_etat_processus, 31);
1730: }
1731:
1732: if (((*l_element_courant).suivant =
1733: allocation_maillon(s_etat_processus)) == NULL)
1734: {
1735: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1736: return;
1737: }
1738:
1739: l_element_courant = (*l_element_courant).suivant;
1740:
1741: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1742: == NULL)
1743: {
1744: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1745: return;
1746: }
1747:
1748: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1749: .nombre_arguments = 0;
1750: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1751: .fonction = instruction_vers_niveau_inferieur;
1752:
1753: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1754: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1755: {
1756: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1757: return;
1758: }
1759:
1760: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1761: .nom_fonction, ">>");
1762:
1763: (*l_element_courant).suivant = NULL;
1764:
1765: /*
1766: * Destruction de la variable locale
1767: */
1768:
1769: (*s_etat_processus).niveau_courant--;
1770:
1771: if (retrait_variable(s_etat_processus, (*((struct_nom *)
1772: (*s_objet_argument_3).objet)).nom, 'L') == d_erreur)
1773: {
1774: liberation(s_etat_processus, s_objet_argument_1);
1775: liberation(s_etat_processus, s_objet_argument_2);
1776: liberation(s_etat_processus, s_objet_argument_3);
1777: liberation(s_etat_processus, s_objet_argument_4);
1778: liberation(s_etat_processus, s_objet_resultat);
1779:
1780: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1781: return;
1782: }
1783: }
1784: else
1785: {
1786: liberation(s_etat_processus, s_objet_argument_1);
1787: liberation(s_etat_processus, s_objet_argument_2);
1788: liberation(s_etat_processus, s_objet_argument_3);
1789: liberation(s_etat_processus, s_objet_argument_4);
1790:
1791: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1792: return;
1793: }
1794:
1795: liberation(s_etat_processus, s_objet_argument_1);
1796: liberation(s_etat_processus, s_objet_argument_2);
1797: liberation(s_etat_processus, s_objet_argument_3);
1798: liberation(s_etat_processus, s_objet_argument_4);
1799:
1800: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1801: s_objet_resultat) == d_erreur)
1802: {
1803: return;
1804: }
1805:
1806: return;
1807: }
1808:
1809:
1810: /*
1811: ================================================================================
1812: Fonction 'target'
1813: ================================================================================
1814: Entrées :
1815: --------------------------------------------------------------------------------
1816: Sorties :
1817: --------------------------------------------------------------------------------
1818: Effets de bord : néant
1819: ================================================================================
1820: */
1821:
1822: void
1823: instruction_target(struct_processus *s_etat_processus)
1824: {
1825: struct_liste_chainee *l_element_courant;
1826:
1827: struct addrinfo *resolution;
1828: struct addrinfo *resolution_courante;
1829:
1830: struct_objet *s_objet_argument_1;
1831: struct_objet *s_objet_argument_2;
1832:
1833: unsigned long i;
1834: unsigned long nombre_elements;
1835:
1836: (*s_etat_processus).erreur_execution = d_ex;
1837:
1838: if ((*s_etat_processus).affichage_arguments == 'Y')
1839: {
1840: printf("\n TARGET ");
1841:
1842: if ((*s_etat_processus).langue == 'F')
1843: {
1844: printf("(cible d'une socket non connectée)\n\n");
1845: }
1846: else
1847: {
1848: printf("(target of unconnected socket)\n\n");
1849: }
1850:
1851: printf(" 2: %s, %s\n", d_CHN, d_LST);
1852: printf(" 1: %s\n", d_SCK);
1853: printf("-> 1: %s\n", d_SCK);
1854:
1855: return;
1856: }
1857: else if ((*s_etat_processus).test_instruction == 'Y')
1858: {
1859: (*s_etat_processus).nombre_arguments = -1;
1860: return;
1861: }
1862:
1863: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1864: {
1865: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
1866: {
1867: return;
1868: }
1869: }
1870:
1871: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1872: &s_objet_argument_1) == d_erreur)
1873: {
1874: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1875: return;
1876: }
1877:
1878: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1879: &s_objet_argument_2) == d_erreur)
1880: {
1881: liberation(s_etat_processus, s_objet_argument_1);
1882:
1883: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1884: return;
1885: }
1886:
1887: if ((*s_objet_argument_1).type == SCK)
1888: {
1889:
1890: /*
1891: * Vérification du type de socket
1892: */
1893:
1894: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
1895: "STREAM") == 0) || (strcmp((*((struct_socket *)
1896: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
1897: == 0))
1898: {
1899: liberation(s_etat_processus, s_objet_argument_1);
1900: liberation(s_etat_processus, s_objet_argument_2);
1901:
1902: (*s_etat_processus).erreur_execution =
1903: d_ex_erreur_parametre_fichier;
1904: return;
1905: }
1906:
1907: if ((*s_objet_argument_2).type == CHN)
1908: {
1909: /*
1910: * La socket ne peut être que du domaine UNIX
1911: */
1912:
1913: if ((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
1914: != PF_UNIX)
1915: {
1916: liberation(s_etat_processus, s_objet_argument_1);
1917: liberation(s_etat_processus, s_objet_argument_2);
1918:
1919: (*s_etat_processus).erreur_execution =
1920: d_ex_erreur_parametre_fichier;
1921: return;
1922: }
1923:
1924: free((*((struct_socket *) (*s_objet_argument_1).objet))
1925: .adresse_distante);
1926:
1927: if (((*((struct_socket *) (*s_objet_argument_1).objet))
1.5 bertrand 1928: .adresse_distante = transliteration(s_etat_processus,
1929: (unsigned char *) (*s_objet_argument_2).objet,
1930: d_locale, "UTF-8")) == NULL)
1.1 bertrand 1931: {
1.5 bertrand 1932: liberation(s_etat_processus, s_objet_argument_1);
1933: liberation(s_etat_processus, s_objet_argument_2);
1934:
1.1 bertrand 1935: return;
1936: }
1937: }
1938: else if ((*s_objet_argument_2).type == LST)
1939: {
1940: l_element_courant = (struct_liste_chainee *)
1941: (*s_objet_argument_2).objet;
1942: nombre_elements = 0;
1943:
1944: while(l_element_courant != NULL)
1945: {
1946: nombre_elements++;
1947: l_element_courant = (*l_element_courant).suivant;
1948: }
1949:
1950: if (nombre_elements != 2)
1951: {
1952: liberation(s_etat_processus, s_objet_argument_1);
1953: liberation(s_etat_processus, s_objet_argument_2);
1954:
1955: (*s_etat_processus).erreur_execution =
1956: d_ex_erreur_parametre_fichier;
1957: return;
1958: }
1959:
1960: l_element_courant = (struct_liste_chainee *)
1961: (*s_objet_argument_2).objet;
1962:
1963: if ((*(*l_element_courant).donnee).type == VIN)
1964: {
1965: if ((*((struct_vecteur *) (*(*l_element_courant).donnee).objet))
1966: .taille == 4)
1967: {
1968: if ((*((struct_socket *) (*s_objet_argument_1).objet))
1969: .domaine != PF_INET)
1970: {
1971: liberation(s_etat_processus, s_objet_argument_1);
1972: liberation(s_etat_processus, s_objet_argument_2);
1973:
1974: (*s_etat_processus).erreur_execution =
1975: d_ex_erreur_parametre_fichier;
1976: return;
1977: }
1978:
1979: free((*((struct_socket *) (*s_objet_argument_1).objet))
1980: .adresse_distante);
1981:
1982: if (((*((struct_socket *) (*s_objet_argument_1)
1983: .objet)).adresse_distante = malloc(22 *
1984: sizeof(unsigned char))) == NULL)
1985: {
1986: (*s_etat_processus).erreur_systeme =
1987: d_es_allocation_memoire;
1988: return;
1989: }
1990:
1991: (*((struct_socket *) (*s_objet_argument_1).objet))
1992: .adresse_distante[0] = d_code_fin_chaine;
1993:
1994: for(i = 0; i < 4; i++)
1995: {
1996: if ((((integer8 *) (*((struct_vecteur *)
1997: (*(*l_element_courant).donnee).objet)).tableau)
1998: [i] >= 0) && (((integer8 *)
1999: (*((struct_vecteur *) (*(*l_element_courant)
2000: .donnee).objet)).tableau)[i] <= 255))
2001: {
2002: sprintf((*((struct_socket *) (*s_objet_argument_1)
2003: .objet)).adresse_distante,
2004: (i == 0) ? "%s%d" : "%s.%d",
2005: (*((struct_socket *) (*s_objet_argument_1)
2006: .objet)).adresse_distante, (int)
2007: ((integer8 *) (*((struct_vecteur *)
2008: (*(*l_element_courant).donnee).objet))
2009: .tableau)[i]);
2010: }
2011: else
2012: {
2013: liberation(s_etat_processus, s_objet_argument_1);
2014: liberation(s_etat_processus, s_objet_argument_2);
2015:
2016: (*s_etat_processus).erreur_execution =
2017: d_ex_erreur_parametre_fichier;
2018: return;
2019: }
2020: }
2021: }
2022: else if ((*((struct_vecteur *) (*(*l_element_courant).donnee)
2023: .objet)).taille == 16)
2024: {
2025: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2026: .domaine != PF_INET6)
2027: {
2028: liberation(s_etat_processus, s_objet_argument_1);
2029: liberation(s_etat_processus, s_objet_argument_2);
2030:
2031: (*s_etat_processus).erreur_execution =
2032: d_ex_erreur_parametre_fichier;
2033: return;
2034: }
2035:
2036: free((*((struct_socket *) (*s_objet_argument_1).objet))
2037: .adresse_distante);
2038:
2039: if (((*((struct_socket *) (*s_objet_argument_1)
2040: .objet)).adresse_distante = malloc(55 *
2041: sizeof(unsigned char))) == NULL)
2042: {
2043: (*s_etat_processus).erreur_systeme =
2044: d_es_allocation_memoire;
2045: return;
2046: }
2047:
2048: (*((struct_socket *) (*s_objet_argument_1).objet))
2049: .adresse_distante[0] = d_code_fin_chaine;
2050:
2051: for(i = 0; i < 16; i++)
2052: {
2053: if ((((integer8 *) (*((struct_vecteur *)
2054: (*(*l_element_courant).donnee).objet)).tableau)
2055: [i] >= 0) && (((integer8 *)
2056: (*((struct_vecteur *) (*(*l_element_courant)
2057: .donnee).objet)).tableau)[i] <= 255))
2058: {
2059: sprintf((*((struct_socket *) (*s_objet_argument_1)
2060: .objet)).adresse_distante,
2061: (i == 0) ? "%s%d" : "%s:%X",
2062: (*((struct_socket *) (*s_objet_argument_1)
2063: .objet)).adresse_distante, (int)
2064: ((integer8 *) (*((struct_vecteur *)
2065: (*(*l_element_courant).donnee).objet))
2066: .tableau)[i]);
2067: }
2068: else
2069: {
2070: liberation(s_etat_processus, s_objet_argument_1);
2071: liberation(s_etat_processus, s_objet_argument_2);
2072:
2073: (*s_etat_processus).erreur_execution =
2074: d_ex_erreur_parametre_fichier;
2075: return;
2076: }
2077: }
2078: }
2079: else
2080: {
2081: liberation(s_etat_processus, s_objet_argument_1);
2082: liberation(s_etat_processus, s_objet_argument_2);
2083:
2084: (*s_etat_processus).erreur_execution =
2085: d_ex_erreur_parametre_fichier;
2086: return;
2087: }
2088: }
2089: else if ((*(*l_element_courant).donnee).type == CHN)
2090: {
2091: resolution = NULL;
2092:
2093: if (getaddrinfo((unsigned char *) (*(*l_element_courant)
2094: .donnee).objet, NULL, NULL, &resolution) != 0)
2095: {
2096: liberation(s_etat_processus, s_objet_argument_1);
2097: liberation(s_etat_processus, s_objet_argument_2);
2098:
2099: if (resolution != NULL)
2100: {
2101: freeaddrinfo(resolution);
2102: }
2103:
2104: (*s_etat_processus).erreur_execution =
2105: d_ex_erreur_acces_fichier;
2106: return;
2107: }
2108:
2109: if ((*((struct_socket *) (*s_objet_argument_1).objet))
2110: .domaine == PF_INET)
2111: { // Résolution du nom en IPv4
2112: resolution_courante = resolution;
2113:
2114: while(resolution_courante != NULL)
2115: {
2116: if ((*resolution_courante).ai_family == AF_INET)
2117: {
2118: break;
2119: }
2120:
2121: resolution_courante = (*resolution_courante).ai_next;
2122: }
2123:
2124: if (resolution_courante == NULL)
2125: {
2126: liberation(s_etat_processus, s_objet_argument_1);
2127: liberation(s_etat_processus, s_objet_argument_2);
2128:
2129: freeaddrinfo(resolution);
2130:
2131: (*s_etat_processus).erreur_execution =
2132: d_ex_erreur_acces_fichier;
2133: return;
2134: }
2135:
2136: free((*((struct_socket *) (*s_objet_argument_1).objet))
2137: .adresse_distante);
2138:
2139: if (((*((struct_socket *) (*s_objet_argument_1)
2140: .objet)).adresse_distante = malloc(22 *
2141: sizeof(unsigned char))) == NULL)
2142: {
2143: (*s_etat_processus).erreur_systeme =
2144: d_es_allocation_memoire;
2145: return;
2146: }
2147:
2148: sprintf((*((struct_socket *) (*s_objet_argument_1).objet))
2149: .adresse_distante, "%d.%d.%d.%d",
2150: (ntohl((*((struct sockaddr_in *)
2151: (*resolution_courante).ai_addr)).sin_addr.s_addr)
2152: >> 24) & 0xFF,
2153: (ntohl((*((struct sockaddr_in *)
2154: (*resolution_courante).ai_addr)).sin_addr.s_addr)
2155: >> 16) & 0xFF,
2156: (ntohl((*((struct sockaddr_in *)
2157: (*resolution_courante).ai_addr)).sin_addr.s_addr)
2158: >> 8) & 0xFF,
2159: ntohl((*((struct sockaddr_in *)
2160: (*resolution_courante).ai_addr)).sin_addr.s_addr)
2161: & 0xFF);
2162: }
2163: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
2164: .domaine == PF_INET6)
2165: { // Résolution du nom en IPv6
1.13 bertrand 2166: # ifdef IPV6
1.1 bertrand 2167: resolution_courante = resolution;
2168:
2169: while(resolution_courante != NULL)
2170: {
2171: if ((*resolution_courante).ai_family == AF_INET6)
2172: {
2173: break;
2174: }
2175:
2176: resolution_courante = (*resolution_courante).ai_next;
2177: }
2178:
2179: if (resolution_courante == NULL)
2180: {
2181: liberation(s_etat_processus, s_objet_argument_1);
2182: liberation(s_etat_processus, s_objet_argument_2);
2183:
2184: freeaddrinfo(resolution);
2185:
2186: (*s_etat_processus).erreur_execution =
2187: d_ex_erreur_acces_fichier;
2188: return;
2189: }
2190:
2191: if (((*((struct_socket *) (*s_objet_argument_1)
2192: .objet)).adresse_distante = malloc(55 *
2193: sizeof(unsigned char))) == NULL)
2194: {
2195: (*s_etat_processus).erreur_systeme =
2196: d_es_allocation_memoire;
2197: return;
2198: }
2199:
2200: (*((struct_socket *) (*s_objet_argument_1).objet))
2201: .adresse_distante[0] = d_code_fin_chaine;
2202:
2203: for(i = 0; i < 16; i++)
2204: {
2205: sprintf((*((struct_socket *) (*s_objet_argument_1)
2206: .objet)).adresse_distante,
2207: (i == 0) ? "%s%X" : "%s:%X",
2208: (*((struct_socket *) (*s_objet_argument_1)
2209: .objet)).adresse_distante,
2210: (*((struct sockaddr_in6 *)
2211: (*resolution_courante).ai_addr)).sin6_addr
2212: .s6_addr[i]);
2213: }
1.13 bertrand 2214: # else
1.15 bertrand 2215: if ((*s_etat_processus).langue == 'F')
2216: {
2217: printf("+++Attention : Support du protocole"
1.16 bertrand 2218: " IPv6 indisponible\n");
1.15 bertrand 2219: }
2220: else
2221: {
1.17 bertrand 2222: printf("+++Warning : IPv6 support "
1.15 bertrand 2223: "unavailable\n");
2224: }
1.13 bertrand 2225: # endif
1.1 bertrand 2226: }
2227: else
2228: {
2229: liberation(s_etat_processus, s_objet_argument_1);
2230: liberation(s_etat_processus, s_objet_argument_2);
2231:
2232: freeaddrinfo(resolution);
2233:
2234: (*s_etat_processus).erreur_execution =
2235: d_ex_erreur_parametre_fichier;
2236: return;
2237: }
2238:
2239: freeaddrinfo(resolution);
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 =
2247: d_ex_erreur_parametre_fichier;
2248: return;
2249: }
2250:
2251: l_element_courant = (*l_element_courant).suivant;
2252:
2253: if ((*(*l_element_courant).donnee).type == INT)
2254: {
2255: if (((*((integer8 *) (*(*l_element_courant).donnee).objet))
2256: >= 0) && ((*((integer8 *) (*(*l_element_courant)
2257: .donnee).objet)) <= 65535))
2258: {
2259: sprintf((*((struct_socket *) (*s_objet_argument_1)
2260: .objet)).adresse_distante, "%s(%u)",
2261: (*((struct_socket *) (*s_objet_argument_1)
2262: .objet)).adresse_distante, (unsigned int)
2263: (*((integer8 *) (*(*l_element_courant).donnee)
2264: .objet)));
2265: }
2266: else
2267: {
2268: liberation(s_etat_processus, s_objet_argument_1);
2269: liberation(s_etat_processus, s_objet_argument_2);
2270:
2271: (*s_etat_processus).erreur_execution =
2272: d_ex_erreur_parametre_fichier;
2273: return;
2274: }
2275: }
2276: else
2277: {
2278: liberation(s_etat_processus, s_objet_argument_1);
2279: liberation(s_etat_processus, s_objet_argument_2);
2280:
2281: (*s_etat_processus).erreur_execution =
2282: d_ex_erreur_parametre_fichier;
2283: return;
2284: }
2285: }
2286: else
2287: {
2288: liberation(s_etat_processus, s_objet_argument_1);
2289: liberation(s_etat_processus, s_objet_argument_2);
2290:
2291: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2292: return;
2293: }
2294: }
2295: else
2296: {
2297: liberation(s_etat_processus, s_objet_argument_1);
2298: liberation(s_etat_processus, s_objet_argument_2);
2299:
2300: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2301: return;
2302: }
2303:
2304: liberation(s_etat_processus, s_objet_argument_2);
2305:
2306: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2307: s_objet_argument_1) == d_erreur)
2308: {
2309: return;
2310: }
2311:
2312: return;
2313: }
2314:
2315:
2316: /*
2317: ================================================================================
2318: Fonction 'tail'
2319: ================================================================================
2320: Entrées :
2321: --------------------------------------------------------------------------------
2322: Sorties :
2323: --------------------------------------------------------------------------------
2324: Effets de bord : néant
2325: ================================================================================
2326: */
2327:
2328: void
2329: instruction_tail(struct_processus *s_etat_processus)
2330: {
2331: integer8 longueur;
2332:
2333: struct_liste_chainee *l_element_courant;
2334:
2335: struct_objet *s_objet_argument;
2336: struct_objet *s_objet_resultat;
2337:
2338: (*s_etat_processus).erreur_execution = d_ex;
2339:
2340: if ((*s_etat_processus).affichage_arguments == 'Y')
2341: {
2342: printf("\n TAIL ");
2343:
2344: if ((*s_etat_processus).langue == 'F')
2345: {
2346: printf("(remplace une liste par tous ses éléments hormis "
2347: "son premier)\n\n");
2348: }
2349: else
2350: {
2351: printf("(replace a list by all but its first element)\n\n");
2352: }
2353:
2354: printf(" 1: %s\n", d_LST);
2355: printf("-> 1: %s\n", d_LST);
2356:
2357: return;
2358: }
2359: else if ((*s_etat_processus).test_instruction == 'Y')
2360: {
2361: (*s_etat_processus).nombre_arguments = -1;
2362: return;
2363: }
2364:
2365: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2366: {
2367: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2368: {
2369: return;
2370: }
2371: }
2372:
2373: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2374: &s_objet_argument) == d_erreur)
2375: {
2376: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2377: return;
2378: }
2379:
2380: if ((*s_objet_argument).type == LST)
2381: {
2382: l_element_courant = (*s_objet_argument).objet;
2383: longueur = 0;
2384:
2385: while(l_element_courant != NULL)
2386: {
2387: longueur++;
2388: l_element_courant = (*l_element_courant).suivant;
2389: }
2390:
2391: if (longueur == 0)
2392: {
2393: if ((s_objet_resultat = allocation(s_etat_processus, LST))
2394: == NULL)
2395: {
2396: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2397: return;
2398: }
2399:
2400: (*s_objet_resultat).objet = NULL;
2401: }
2402: else
2403: {
2404: if ((s_objet_resultat = copie_objet(s_etat_processus,
2405: s_objet_argument, 'N')) == NULL)
2406: {
2407: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2408: return;
2409: }
2410:
2411: l_element_courant = (*s_objet_resultat).objet;
2412:
2413: (*s_objet_resultat).objet = (*((struct_liste_chainee *)
2414: (*s_objet_resultat).objet)).suivant;
2415:
2416: liberation(s_etat_processus, (*l_element_courant).donnee);
2417: free(l_element_courant);
2418: }
2419: }
2420: else
2421: {
2422: liberation(s_etat_processus, s_objet_argument);
2423:
2424: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2425: return;
2426: }
2427:
2428: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2429: s_objet_resultat) == d_erreur)
2430: {
2431: return;
2432: }
2433:
2434: liberation(s_etat_processus, s_objet_argument);
2435:
2436: return;
2437: }
2438:
2439: // vim: ts=4