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