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