File:
[local] /
rpl /
src /
formateur_fichiers.c
Revision
1.34:
download - view:
text,
annotated -
select for diffs -
revision graph
Tue Nov 15 07:01:37 2011 UTC (13 years, 5 months ago) by
bertrand
Branches:
MAIN
CVS tags:
HEAD
Correction des fuites de mémoire à l'ouverture de sqlite (lorsque la base est censée exister mais qu'elle n'existe pas)
Correction des makefiles pour qu'ils soient moins verbeux.
Ajout de l'écriture des fichiers binaires (listes, entiers, réels, complexes).
1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.4
4: Copyright (C) 1989-2011 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: Routine de formation des données pour l'écriture dans les fichiers
29: ================================================================================
30: Entrées : structure sur l'état du processus et objet à afficher
31: Longueur est la précision requise et longueur_champ, le nombre maximal
32: de caractères de la chaîne résultat (-1 signifiant une absence de contrainte)
33: Type = 'F/U' (formaté, non formaté)
34: --------------------------------------------------------------------------------
35: Sorties : chaine de caractères et longueur du tableau de caractères
36: --------------------------------------------------------------------------------
37: Effets de bord : néant
38: ================================================================================
39: */
40:
41: unsigned char *
42: formateur_fichier(struct_processus *s_etat_processus, struct_objet *s_objet,
43: struct_objet *s_format, long longueur, long longueur_champ,
44: unsigned char format_sortie, unsigned char type,
45: long *longueur_effective, long *recursivite)
46: {
47: /*
48: * Traitement du format des fichiers formatés :
49: *
50: * { "standard*(*)" (format classique sans limitation)
51: * "standard*(Y)" (format classique limité à Y caractères)
52: * "fixed*X(*)" (format virgule fixe avec une partie
53: * fractionnaire composée de X chiffres,
54: * mais dont la longueur est limité par
55: * la précision de la représentation interne)
56: * "fixed*X(Y)" (idem, mais longueur totale inférieure ou égale à
57: * Y caractères)
58: * "scientific*X(*)"
59: * "scientific*X(Y)"
60: * "engineer*X(*)"
61: * "engineer*X(Y)"
62: * "binary*X(*)"
63: * "binary*X(Y)" (X est la base : 2, 8, 10, 16)
64: * "character*(*)"
65: * "character*(Y)" }
66: *
67: * Traitement du format des fichiers non formatés :
68: *
69: * { "integer*1", "integer*2", "integer*4", "integer*8",
70: * "real*4", "real*8", ["real*16",]
71: * "complex*8", "complex*16", ["complex*32",]
72: * "logical*1", "logical*2", "logical*4", logical*8",
73: * "character" }
74: */
75:
76: logical1 autorisation_parenthese;
77: logical1 format_degenere;
78: logical1 longueur_3bits;
79: logical1 longueur_6bits;
80: logical1 presence_signe;
81:
82: struct_liste_chainee *l_atome;
83: struct_liste_chainee *l_element_courant;
84: struct_liste_chainee *l_element_courant_format;
85: struct_liste_chainee *l_liste1;
86: struct_liste_chainee *l_liste2;
87:
88: struct_objet *s_sous_objet;
89: struct_objet *s_sous_objet_1;
90: struct_objet *s_sous_objet_2;
91: struct_objet *s_sous_objet_3;
92:
93: unsigned char base[1 + 1];
94: unsigned char *chaine;
95: unsigned char *chaine_fonction;
96: unsigned char *chaine_formatee;
97: unsigned char *chaine_tampon;
98: unsigned char *chaine_sauvegarde;
99: unsigned char *format_chaine;
100: unsigned char longueur_optimale;
101: unsigned char parametre_longueur;
102: unsigned char *ptre;
103: unsigned char *ptrl;
104: unsigned char tampon[64 + 1];
105:
106: unsigned long i;
107: unsigned long j;
108: unsigned long longueur_binaire;
109: unsigned long longueur_champ_final;
110: unsigned long nombre_arguments;
111: unsigned long nombre_arguments_fonction;
112: unsigned long nombre_colonnes;
113: unsigned long nombre_elements;
114: unsigned long nombre_lignes;
115:
116: integer8 longueur_liste;
117: integer8 longueur_entete;
118: integer8 longueur_objet;
119: integer8 longueur_totale;
120: integer8 masque_binaire;
121: integer8 position_1;
122: integer8 position_2;
123: integer8 position_3;
124:
125: long offset;
126:
127: (*recursivite)++;
128:
129: if (type == 'F')
130: {
131: /*
132: * Fichiers formatés
133: */
134:
135: chaine = NULL;
136: chaine_formatee = NULL;
137: chaine_sauvegarde = NULL;
138:
139: strcpy(base, " ");
140:
141: longueur_binaire = 0;
142: masque_binaire = 0;
143:
144: if ((*s_objet).type == ALG)
145: {
146:
147: /*
148: --------------------------------------------------------------------------------
149: Expression algébrique
150: --------------------------------------------------------------------------------
151: */
152:
153: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
154:
155: while(l_element_courant != NULL)
156: {
157: if ((*(*l_element_courant).donnee).type == FCT)
158: {
159: if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
160: .donnee).objet)).nom_fonction, "<<") != 0) &&
161: (strcmp((*((struct_fonction *)
162: (*(*l_element_courant)
163: .donnee).objet)).nom_fonction, ">>") != 0))
164: {
165: if ((strcmp((*((struct_fonction *)
166: (*(*l_element_courant)
167: .donnee).objet)).nom_fonction, "+") == 0) ||
168: (strcmp((*((struct_fonction *)
169: (*(*l_element_courant).donnee).objet))
170: .nom_fonction, "-") == 0) || (strcmp(
171: (*((struct_fonction *) (*(*l_element_courant)
172: .donnee).objet)).nom_fonction, "*") == 0) ||
173: (strcmp((*((struct_fonction *)
174: (*(*l_element_courant).donnee).objet))
175: .nom_fonction,
176: "/") == 0) || (strcmp((*((struct_fonction *)
177: (*(*l_element_courant).donnee).objet))
178: .nom_fonction,
179: "^") == 0) || (strcmp((*((struct_fonction *)
180: (*(*l_element_courant).donnee).objet))
181: .nom_fonction,
182: "<") == 0) || (strcmp((*((struct_fonction *)
183: (*(*l_element_courant).donnee).objet))
184: .nom_fonction,
185: ">") == 0) || (strcmp((*((struct_fonction *)
186: (*(*l_element_courant).donnee).objet))
187: .nom_fonction,
188: "==") == 0) || (strcmp((*((struct_fonction *)
189: (*(*l_element_courant).donnee).objet))
190: .nom_fonction,
191: "<>") == 0) || (strcmp((*((struct_fonction *)
192: (*(*l_element_courant).donnee).objet))
193: .nom_fonction,
194: "<=") == 0) || (strcmp((*((struct_fonction *)
195: (*(*l_element_courant).donnee).objet))
196: .nom_fonction,
197: "=<") == 0) || (strcmp((*((struct_fonction *)
198: (*(*l_element_courant).donnee).objet))
199: .nom_fonction,
200: ">=") == 0) || (strcmp((*((struct_fonction *)
201: (*(*l_element_courant).donnee).objet))
202: .nom_fonction,
203: "=>") == 0))
204: {
205: if (depilement(s_etat_processus,
206: &((*s_etat_processus)
207: .l_base_pile), &s_sous_objet_2) == d_erreur)
208: {
209: return(NULL);
210: }
211:
212: chaine_sauvegarde = (*s_etat_processus)
213: .instruction_courante;
214:
215: if (((*s_etat_processus).instruction_courante =
216: (unsigned char *) malloc((strlen(
217: (unsigned char *) (*s_sous_objet_2).objet)
218: + 2 + 1) * sizeof(unsigned char))) == NULL)
219: {
220: (*s_etat_processus).instruction_courante =
221: chaine_sauvegarde;
222: (*s_etat_processus).erreur_systeme =
223: d_es_allocation_memoire;
224: return(NULL);
225: }
226:
227: sprintf((*s_etat_processus).instruction_courante,
228: "'%s'", (unsigned char *)
229: (*s_sous_objet_2).objet);
230:
231: presence_signe = (((*s_etat_processus)
232: .instruction_courante[1] == '+')
233: || ((*s_etat_processus)
234: .instruction_courante[1]
235: == '-')) ? d_vrai : d_faux;
236:
237: recherche_type(s_etat_processus);
238:
239: if ((*s_etat_processus).erreur_execution != d_ex)
240: {
241: // Aucune erreur ne peut être renvoyée.
242:
243: return(NULL);
244: }
245:
246: if (depilement(s_etat_processus,
247: &((*s_etat_processus)
248: .l_base_pile), &s_sous_objet_3) == d_erreur)
249: {
250: return(NULL);
251: }
252:
253: free((*s_etat_processus).instruction_courante);
254:
255: (*s_etat_processus).instruction_courante =
256: chaine_sauvegarde;
257:
258: autorisation_parenthese = d_faux;
259:
260: if ((*s_sous_objet_3).type == ALG)
261: {
262: l_atome = (struct_liste_chainee *)
263: (*s_sous_objet_3).objet;
264: chaine_fonction = "";
265: nombre_arguments_fonction = 0;
266:
267: while(l_atome != NULL)
268: {
269: if ((*(*l_atome).donnee).type == FCT)
270: {
271: if (strcmp((*((struct_fonction *)
272: (*(*l_atome).donnee).objet))
273: .nom_fonction, ">>") != 0)
274: {
275: chaine_fonction =
276: (*((struct_fonction *)
277: (*(*l_atome).donnee).objet))
278: .nom_fonction;
279: nombre_arguments_fonction =
280: (*((struct_fonction *)
281: (*(*l_atome).donnee).objet))
282: .nombre_arguments;
283: }
284: }
285:
286: l_atome = (*l_atome).suivant;
287: }
288:
289: if (strcmp((*((struct_fonction *)
290: (*(*l_element_courant).donnee).objet))
291: .nom_fonction, "+") == 0)
292: {
293: if ((strcmp(chaine_fonction, "AND") == 0) ||
294: (strcmp(chaine_fonction, "XOR") ==
295: 0) || (strcmp(chaine_fonction, "OR")
296: == 0))
297: {
298: autorisation_parenthese = d_vrai;
299: }
300: }
301: else if (strcmp((*((struct_fonction *)
302: (*(*l_element_courant).donnee).objet))
303: .nom_fonction, "-") == 0)
304: {
305: if (nombre_arguments_fonction != 0)
306: {
307: autorisation_parenthese = d_faux;
308: }
309: else
310: {
311: autorisation_parenthese = d_vrai;
312: }
313: }
314: else if (strcmp((*((struct_fonction *)
315: (*(*l_element_courant).donnee).objet))
316: .nom_fonction, "*") == 0)
317: {
318: if ((strcmp(chaine_fonction, "+") == 0) ||
319: (strcmp(chaine_fonction, "-") == 0)
320: || (strcmp(chaine_fonction, "AND")
321: == 0) || (strcmp(chaine_fonction,
322: "XOR") == 0) || (strcmp(
323: chaine_fonction, "OR") == 0))
324: {
325: autorisation_parenthese = d_vrai;
326: }
327: }
328: else if (strcmp((*((struct_fonction *)
329: (*(*l_element_courant).donnee).objet))
330: .nom_fonction, "/") == 0)
331: {
332: if (nombre_arguments_fonction != 0)
333: {
334: autorisation_parenthese = d_faux;
335: }
336: else
337: {
338: autorisation_parenthese = d_vrai;
339: }
340: }
341: else if ((strcmp((*((struct_fonction *)
342: (*(*l_element_courant).donnee).objet))
343: .nom_fonction, "^") == 0))
344: {
345: if (nombre_arguments_fonction != 0)
346: {
347: autorisation_parenthese = d_faux;
348: }
349: else
350: {
351: autorisation_parenthese = d_vrai;
352: }
353: }
354: }
355:
356: if ((autorisation_parenthese == d_vrai) ||
357: (presence_signe == d_vrai))
358: {
359: chaine_sauvegarde = (unsigned char *)
360: (*s_sous_objet_2).objet;
361:
362: if (((*s_sous_objet_2).objet = (void *)
363: malloc((strlen(chaine_sauvegarde) + 2
364: + 1) * sizeof(unsigned char))) == NULL)
365: {
366: (*s_etat_processus).erreur_systeme =
367: d_es_allocation_memoire;
368: return(NULL);
369: }
370:
371: sprintf((unsigned char *) (*s_sous_objet_2)
372: .objet, "(%s)", chaine_sauvegarde);
373: free(chaine_sauvegarde);
374: }
375:
376: liberation(s_etat_processus, s_sous_objet_3);
377:
378: if (depilement(s_etat_processus,
379: &((*s_etat_processus)
380: .l_base_pile), &s_sous_objet_1) == d_erreur)
381: {
382: return(NULL);
383: }
384:
385: chaine_sauvegarde = (*s_etat_processus)
386: .instruction_courante;
387:
388: if (((*s_etat_processus).instruction_courante =
389: (unsigned char *) malloc((strlen(
390: (unsigned char *) (*s_sous_objet_1).objet)
391: + 2 + 1) * sizeof(unsigned char))) == NULL)
392: {
393: (*s_etat_processus).instruction_courante =
394: chaine_sauvegarde;
395: (*s_etat_processus).erreur_systeme =
396: d_es_allocation_memoire;
397: return(NULL);
398: }
399:
400: sprintf((*s_etat_processus).instruction_courante,
401: "'%s'", (unsigned char *)
402: (*s_sous_objet_1).objet);
403:
404: recherche_type(s_etat_processus);
405:
406: if ((*s_etat_processus).erreur_execution != d_ex)
407: {
408: // Aucune erreur ne peut être renvoyée.
409:
410: return(NULL);
411: }
412:
413: if (depilement(s_etat_processus,
414: &((*s_etat_processus)
415: .l_base_pile), &s_sous_objet_3) == d_erreur)
416: {
417: return(NULL);
418: }
419:
420: free((*s_etat_processus).instruction_courante);
421:
422: (*s_etat_processus).instruction_courante =
423: chaine_sauvegarde;
424:
425: autorisation_parenthese = d_faux;
426:
427: if ((*s_sous_objet_3).type == ALG)
428: {
429: l_atome = (struct_liste_chainee *)
430: (*s_sous_objet_3).objet;
431: chaine_fonction = "";
432:
433: while(l_atome != NULL)
434: {
435: if ((*(*l_atome).donnee).type == FCT)
436: {
437: if (strcmp((*((struct_fonction *)
438: (*(*l_atome).donnee).objet))
439: .nom_fonction, ">>") != 0)
440: {
441: chaine_fonction =
442: (*((struct_fonction *)
443: (*(*l_atome).donnee).objet))
444: .nom_fonction;
445: }
446: }
447:
448: l_atome = (*l_atome).suivant;
449: }
450:
451: if ((strcmp((*((struct_fonction *)
452: (*(*l_element_courant).donnee).objet))
453: .nom_fonction, "+") == 0) ||
454: (strcmp((*((struct_fonction *)
455: (*(*l_element_courant).donnee).objet))
456: .nom_fonction, "-") == 0))
457: {
458: if ((strcmp(chaine_fonction, "AND") == 0) ||
459: (strcmp(chaine_fonction, "XOR") ==
460: 0) || (strcmp(chaine_fonction, "OR")
461: == 0))
462: {
463: autorisation_parenthese = d_vrai;
464: }
465: }
466: else if ((strcmp((*((struct_fonction *)
467: (*(*l_element_courant).donnee).objet))
468: .nom_fonction, "*") == 0) ||
469: (strcmp((*((struct_fonction *)
470: (*(*l_element_courant).donnee).objet))
471: .nom_fonction, "/") == 0))
472: {
473: if ((strcmp(chaine_fonction, "+") == 0) ||
474: (strcmp(chaine_fonction, "-") == 0)
475: || (strcmp(chaine_fonction, "AND")
476: == 0) || (strcmp(chaine_fonction,
477: "XOR") == 0) || (strcmp(
478: chaine_fonction, "OR") == 0))
479: {
480: autorisation_parenthese = d_vrai;
481: }
482: }
483: else if ((strcmp((*((struct_fonction *)
484: (*(*l_element_courant).donnee).objet))
485: .nom_fonction, "^") == 0))
486: {
487: autorisation_parenthese = d_vrai;
488: }
489: }
490:
491: if (autorisation_parenthese == d_vrai)
492: {
493: chaine_sauvegarde = (unsigned char *)
494: (*s_sous_objet_1).objet;
495:
496: if (((*s_sous_objet_1).objet = (void *)
497: malloc((strlen(chaine_sauvegarde) + 2
498: + 1) * sizeof(unsigned char))) == NULL)
499: {
500: (*s_etat_processus).erreur_systeme =
501: d_es_allocation_memoire;
502: return(NULL);
503: }
504:
505: sprintf((unsigned char *) (*s_sous_objet_1)
506: .objet, "(%s)", chaine_sauvegarde);
507: free(chaine_sauvegarde);
508: }
509:
510: liberation(s_etat_processus, s_sous_objet_3);
511:
512: if ((s_sous_objet = allocation(s_etat_processus,
513: CHN)) == NULL)
514: {
515: (*s_etat_processus).erreur_systeme =
516: d_es_allocation_memoire;
517: return(NULL);
518: }
519:
520: if (((*s_sous_objet).objet = (void *)
521: malloc((strlen(
522: (unsigned char *) (*s_sous_objet_1).objet) +
523: strlen((*((struct_fonction *)
524: (*(*l_element_courant).donnee).objet))
525: .nom_fonction) + strlen((unsigned char *)
526: (*s_sous_objet_2).objet) + 1) *
527: sizeof(unsigned char))) == NULL)
528: {
529: (*s_etat_processus).erreur_systeme =
530: d_es_allocation_memoire;
531: return(NULL);
532: }
533:
534: sprintf((unsigned char *) (*s_sous_objet).objet,
535: "%s%s%s", (unsigned char *)
536: (*s_sous_objet_1)
537: .objet, (*((struct_fonction *)
538: (*(*l_element_courant).donnee).objet))
539: .nom_fonction, (unsigned char *)
540: (*s_sous_objet_2).objet);
541:
542: liberation(s_etat_processus, s_sous_objet_1);
543: liberation(s_etat_processus, s_sous_objet_2);
544:
545: if (empilement(s_etat_processus,
546: &((*s_etat_processus)
547: .l_base_pile), s_sous_objet) == d_erreur)
548: {
549: return(NULL);
550: }
551: }
552: else if (strcmp((*((struct_fonction *)
553: (*(*l_element_courant).donnee).objet))
554: .nom_fonction, "=") == 0)
555: {
556: if (depilement(s_etat_processus,
557: &((*s_etat_processus).l_base_pile),
558: &s_sous_objet_2) == d_erreur)
559: {
560: return(NULL);
561: }
562:
563: if (depilement(s_etat_processus,
564: &((*s_etat_processus).l_base_pile),
565: &s_sous_objet_1) == d_erreur)
566: {
567: return(NULL);
568: }
569:
570: if ((s_sous_objet = allocation(s_etat_processus,
571: CHN)) == NULL)
572: {
573: (*s_etat_processus).erreur_systeme =
574: d_es_allocation_memoire;
575: return(NULL);
576: }
577:
578: autorisation_parenthese = d_vrai;
579: l_atome = l_element_courant;
580:
581: if (l_atome != NULL)
582: {
583: if ((*l_atome).suivant != NULL)
584: {
585: l_atome = (*l_atome).suivant;
586:
587: if ((*(*l_atome).donnee).type == FCT)
588: {
589: if (strcmp((*((struct_fonction *)
590: (*(*l_atome).donnee).objet))
591: .nom_fonction, ">>") == 0)
592: {
593: if ((*l_atome).suivant == NULL)
594: {
595: autorisation_parenthese =
596: d_faux;
597: }
598: }
599: }
600: }
601: }
602:
603: if (autorisation_parenthese == d_vrai)
604: {
605: if (((*s_sous_objet).objet =
606: (void *) malloc((strlen(
607: (unsigned char *) (*s_sous_objet_1)
608: .objet) + strlen((*((struct_fonction *)
609: (*(*l_element_courant).donnee).objet))
610: .nom_fonction) +
611: strlen((unsigned char *)
612: (*s_sous_objet_2).objet) + 2 + 1) *
613: sizeof(unsigned char))) == NULL)
614: {
615: (*s_etat_processus).erreur_systeme =
616: d_es_allocation_memoire;
617: return(NULL);
618: }
619:
620: sprintf((unsigned char *) (*s_sous_objet).objet,
621: "(%s%s%s)", (unsigned char *)
622: (*s_sous_objet_1)
623: .objet, (*((struct_fonction *)
624: (*(*l_element_courant).donnee).objet))
625: .nom_fonction, (unsigned char *)
626: (*s_sous_objet_2).objet);
627: }
628: else
629: {
630: if (((*s_sous_objet).objet =
631: (void *) malloc((strlen(
632: (unsigned char *) (*s_sous_objet_1)
633: .objet) + strlen((*((struct_fonction *)
634: (*(*l_element_courant).donnee).objet))
635: .nom_fonction) + strlen(
636: (unsigned char *) (*s_sous_objet_2)
637: .objet) + 1) * sizeof(unsigned char)))
638: == NULL)
639: {
640: (*s_etat_processus).erreur_systeme =
641: d_es_allocation_memoire;
642: return(NULL);
643: }
644:
645: sprintf((unsigned char *) (*s_sous_objet).objet,
646: "%s%s%s", (unsigned char *)
647: (*s_sous_objet_1)
648: .objet, (*((struct_fonction *)
649: (*(*l_element_courant).donnee).objet))
650: .nom_fonction, (unsigned char *)
651: (*s_sous_objet_2).objet);
652: }
653:
654: liberation(s_etat_processus, s_sous_objet_1);
655: liberation(s_etat_processus, s_sous_objet_2);
656:
657: if (empilement(s_etat_processus,
658: &((*s_etat_processus).l_base_pile),
659: s_sous_objet) == d_erreur)
660: {
661: return(NULL);
662: }
663: }
664: else if (strcmp((*((struct_fonction *)
665: (*(*l_element_courant).donnee).objet))
666: .nom_fonction,
667: "NOT") == 0)
668: {
669: if (depilement(s_etat_processus,
670: &((*s_etat_processus)
671: .l_base_pile), &s_sous_objet_1) == d_erreur)
672: {
673: return(NULL);
674: }
675:
676: if ((s_sous_objet = allocation(s_etat_processus,
677: CHN)) == NULL)
678: {
679: (*s_etat_processus).erreur_systeme =
680: d_es_allocation_memoire;
681: return(NULL);
682: }
683:
684: if (((*s_sous_objet).objet = (unsigned char *)
685: malloc(
686: (strlen((unsigned char *) (*s_sous_objet_1)
687: .objet) + 4 + 1) * sizeof(unsigned char)))
688: == NULL)
689: {
690: (*s_etat_processus).erreur_systeme =
691: d_es_allocation_memoire;
692: return(NULL);
693: }
694:
695: sprintf((unsigned char *) (*s_sous_objet).objet,
696: "%s %s", (*((struct_fonction *)
697: (*(*l_element_courant).donnee).objet))
698: .nom_fonction, (unsigned char *)
699: (*s_sous_objet_1).objet );
700:
701: liberation(s_etat_processus, s_sous_objet_1);
702:
703: if (empilement(s_etat_processus,
704: &((*s_etat_processus)
705: .l_base_pile), s_sous_objet) == d_erreur)
706: {
707: return(NULL);
708: }
709: }
710: else if ((strcmp((*((struct_fonction *)
711: (*(*l_element_courant).donnee).objet))
712: .nom_fonction,
713: "OR") == 0) || (strcmp((*((struct_fonction *)
714: (*(*l_element_courant).donnee).objet))
715: .nom_fonction,
716: "XOR") == 0) || (strcmp((*((struct_fonction *)
717: (*(*l_element_courant).donnee).objet))
718: .nom_fonction,
719: "AND") == 0))
720: {
721: if (depilement(s_etat_processus,
722: &((*s_etat_processus)
723: .l_base_pile), &s_sous_objet_2) == d_erreur)
724: {
725: return(NULL);
726: }
727:
728: if (depilement(s_etat_processus,
729: &((*s_etat_processus)
730: .l_base_pile), &s_sous_objet_1) == d_erreur)
731: {
732: return(NULL);
733: }
734:
735: if ((s_sous_objet = allocation(s_etat_processus,
736: CHN)) == NULL)
737: {
738: (*s_etat_processus).erreur_systeme =
739: d_es_allocation_memoire;
740: return(NULL);
741: }
742:
743: if (((*s_sous_objet).objet = (void *)
744: malloc((strlen(
745: (unsigned char *) (*s_sous_objet_1).objet) +
746: strlen((*((struct_fonction *)
747: (*(*l_element_courant).donnee).objet))
748: .nom_fonction) + strlen((unsigned char *)
749: (*s_sous_objet_2).objet) + 2 + 1) *
750: sizeof(unsigned char))) == NULL)
751: {
752: (*s_etat_processus).erreur_systeme =
753: d_es_allocation_memoire;
754: return(NULL);
755: }
756:
757: sprintf((unsigned char *) (*s_sous_objet).objet,
758: "%s %s %s", (unsigned char *)
759: (*s_sous_objet_1)
760: .objet, (*((struct_fonction *)
761: (*(*l_element_courant).donnee).objet))
762: .nom_fonction, (unsigned char *)
763: (*s_sous_objet_2).objet);
764:
765: liberation(s_etat_processus, s_sous_objet_1);
766: liberation(s_etat_processus, s_sous_objet_2);
767:
768: if (empilement(s_etat_processus,
769: &((*s_etat_processus)
770: .l_base_pile), s_sous_objet) == d_erreur)
771: {
772: return(NULL);
773: }
774: }
775: else
776: {
777: nombre_arguments = (*((struct_fonction *)
778: (*(*l_element_courant).donnee).objet))
779: .nombre_arguments;
780:
781: if ((chaine = (unsigned char *)
782: malloc(sizeof(unsigned char))) == NULL)
783: {
784: (*s_etat_processus).erreur_systeme =
785: d_es_allocation_memoire;
786: return(NULL);
787: }
788:
789: chaine[0] = d_code_fin_chaine;
790:
791: for(i = 0; i < nombre_arguments; i++)
792: {
793: if ((nombre_arguments - i) > 1)
794: {
795: l_liste1 = (*s_etat_processus).l_base_pile;
796:
797: for(j = 2; j < (nombre_arguments - i); j++)
798: {
799: l_liste1 = (*l_liste1).suivant;
800: }
801:
802: l_liste2 = (*l_liste1).suivant;
803: (*l_liste1).suivant = (*l_liste2).suivant;
804: (*l_liste2).suivant = (*s_etat_processus)
805: .l_base_pile;
806: (*s_etat_processus).l_base_pile = l_liste2;
807: }
808:
809: if (depilement(s_etat_processus,
810: &((*s_etat_processus).l_base_pile),
811: &s_sous_objet) == d_erreur)
812: {
813: return(NULL);
814: }
815:
816: chaine_sauvegarde = chaine;
817:
818: if (strlen(chaine_sauvegarde) == 0)
819: {
820: if ((chaine = (unsigned char *)
821: malloc((strlen((unsigned char *)
822: (*s_sous_objet).objet) + 1) *
823: sizeof(unsigned char))) == NULL)
824: {
825: (*s_etat_processus).erreur_systeme =
826: d_es_allocation_memoire;
827: return(NULL);
828: }
829:
830: sprintf(chaine, "%s", (unsigned char *)
831: (*s_sous_objet).objet);
832: }
833: else
834: {
835: if ((chaine = (unsigned char *)
836: malloc((strlen(chaine_sauvegarde)
837: + 1 + strlen((unsigned char *)
838: (*s_sous_objet).objet) + 1) *
839: sizeof(unsigned char))) == NULL)
840: {
841: (*s_etat_processus).erreur_systeme =
842: d_es_allocation_memoire;
843: return(NULL);
844: }
845:
846: sprintf(chaine, "%s,%s", chaine_sauvegarde,
847: (unsigned char *) (*s_sous_objet)
848: .objet);
849: }
850:
851: free(chaine_sauvegarde);
852: liberation(s_etat_processus, s_sous_objet);
853: }
854:
855: chaine_sauvegarde = chaine;
856:
857: if ((chaine = (unsigned char *) malloc((strlen(
858: (*((struct_fonction *)
859: (*(*l_element_courant)
860: .donnee).objet)).nom_fonction) + 2 +
861: strlen(chaine_sauvegarde) + 1) *
862: sizeof(unsigned char))) == NULL)
863: {
864: (*s_etat_processus).erreur_systeme =
865: d_es_allocation_memoire;
866: return(NULL);
867: }
868:
869: sprintf(chaine, "%s(%s)", (*((struct_fonction *)
870: (*(*l_element_courant).donnee).objet))
871: .nom_fonction, chaine_sauvegarde);
872: free(chaine_sauvegarde);
873:
874: if ((s_sous_objet = allocation(s_etat_processus,
875: CHN)) == NULL)
876: {
877: (*s_etat_processus).erreur_systeme =
878: d_es_allocation_memoire;
879: return(NULL);
880: }
881:
882: (*s_sous_objet).objet = (void *) chaine;
883:
884: if (empilement(s_etat_processus,
885: &((*s_etat_processus)
886: .l_base_pile), s_sous_objet) == d_erreur)
887: {
888: return(NULL);
889: }
890: }
891: }
892: }
893: else
894: {
895: if ((s_sous_objet = allocation(s_etat_processus, CHN))
896: == NULL)
897: {
898: (*s_etat_processus).erreur_systeme =
899: d_es_allocation_memoire;
900: return(NULL);
901: }
902:
903: if (((*s_sous_objet).objet = (void *) formateur_fichier(
904: s_etat_processus, (*l_element_courant).donnee,
905: s_format, longueur, longueur_champ, format_sortie,
906: type, longueur_effective, recursivite)) == NULL)
907: {
908: (*s_etat_processus).erreur_systeme =
909: d_es_allocation_memoire;
910: return(NULL);
911: }
912:
913: if (((*(*l_element_courant).donnee).type == ALG)
914: || ((*(*l_element_courant).donnee).type == NOM))
915: {
916: chaine_sauvegarde = (unsigned char *)
917: (*s_sous_objet).objet;
918:
919: if (((*s_sous_objet).objet = malloc((strlen(
920: chaine_sauvegarde) - 1) *
921: sizeof(unsigned char))) == NULL)
922: {
923: (*s_etat_processus).erreur_systeme =
924: d_es_allocation_memoire;
925: return(NULL);
926: }
927:
928: ptrl = chaine_sauvegarde;
929: ptre = (unsigned char *) (*s_sous_objet).objet;
930:
931: for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;
932: i--, *ptre++ = *ptrl++);
933:
934: (*ptre) = d_code_fin_chaine;
935:
936: free(chaine_sauvegarde);
937: }
938: else if ((*(*l_element_courant).donnee).type == CHN)
939: {
940: chaine_sauvegarde = (unsigned char *)
941: (*s_sous_objet).objet;
942:
943: if (((*s_sous_objet).objet = malloc((strlen(
944: chaine_sauvegarde) + 3) *
945: sizeof(unsigned char))) == NULL)
946: {
947: (*s_etat_processus).erreur_systeme =
948: d_es_allocation_memoire;
949: return(NULL);
950: }
951:
952: sprintf((unsigned char *) (*s_sous_objet).objet,
953: "\"%s\"", chaine_sauvegarde);
954:
955: free(chaine_sauvegarde);
956: }
957:
958: if (empilement(s_etat_processus, &((*s_etat_processus)
959: .l_base_pile), s_sous_objet) == d_erreur)
960: {
961: return(NULL);
962: }
963: }
964:
965: l_element_courant = (*l_element_courant).suivant;
966: }
967:
968: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
969: &s_sous_objet) == d_erreur)
970: {
971: return(NULL);
972: }
973:
974: if ((chaine = (unsigned char *) malloc((strlen((unsigned char *)
975: (*s_sous_objet).objet) + 2 + 1) * sizeof(unsigned char)))
976: == NULL)
977: {
978: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
979: return(NULL);
980: }
981:
982: sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet);
983: liberation(s_etat_processus, s_sous_objet);
984: }
985: else if ((*s_objet).type == BIN)
986: {
987:
988: /*
989: --------------------------------------------------------------------------------
990: Entier binaire en base 2, 8, 10 ou 16
991: --------------------------------------------------------------------------------
992: */
993:
994: if (format_sortie != 'B')
995: {
996: (*s_etat_processus).erreur_execution =
997: d_ex_erreur_format_fichier;
998: return(NULL);
999: }
1000:
1001: longueur_binaire = longueur_entiers_binaires(s_etat_processus);
1002: masque_binaire = masque_entiers_binaires(s_etat_processus);
1003:
1004: if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
1005: (test_cfsf(s_etat_processus, 44) == d_faux))
1006: {
1007:
1008: /*
1009: -- Base décimale ---------------------------------------------------------------
1010: */
1011:
1012: sprintf(tampon, "%llu", (*((logical8 *)
1013: ((*s_objet).objet))) & masque_binaire);
1014: strcpy(base, "d");
1015: }
1016: else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&
1017: (test_cfsf(s_etat_processus, 44) == d_faux))
1018: {
1019:
1020: /*
1021: -- Base octale -----------------------------------------------------------------
1022: */
1023:
1024: sprintf(tampon, "%llo", (*((logical8 *)
1025: ((*s_objet).objet))) & masque_binaire);
1026: strcpy(base, "o");
1027: }
1028: else if (test_cfsf(s_etat_processus, 44) == d_vrai)
1029: {
1030:
1031: /*
1032: -- Bases hexadécimale et binaire -----------------------------------------------
1033: */
1034:
1035: sprintf(tampon, "%llX", (*((logical8 *)
1036: ((*s_objet).objet))) & masque_binaire);
1037:
1038: if (test_cfsf(s_etat_processus, 43) == d_vrai)
1039: {
1040: strcpy(base, "h");
1041: }
1042: else
1043: {
1044: chaine = (unsigned char *) malloc((strlen(tampon) + 1)
1045: * sizeof(unsigned char));
1046:
1047: if (chaine == NULL)
1048: {
1049: (*s_etat_processus).erreur_systeme =
1050: d_es_allocation_memoire;
1051: return(NULL);
1052: }
1053:
1054: strcpy(chaine, tampon);
1055: tampon[0] = 0;
1056:
1057: for(i = 0; i < strlen(chaine); i++)
1058: {
1059: switch(chaine[i])
1060: {
1061: case '0' :
1062: {
1063: strcat(tampon, (i != 0) ? "0000" : "0");
1064: break;
1065: }
1066: case '1' :
1067: {
1068: strcat(tampon, (i != 0) ? "0001" : "1");
1069: break;
1070: }
1071: case '2' :
1072: {
1073: strcat(tampon, (i != 0) ? "0010" : "10");
1074: break;
1075: }
1076: case '3' :
1077: {
1078: strcat(tampon, (i != 0) ? "0011" : "11");
1079: break;
1080: }
1081: case '4' :
1082: {
1083: strcat(tampon, (i != 0) ? "0100" : "100");
1084: break;
1085: }
1086: case '5' :
1087: {
1088: strcat(tampon, (i != 0) ? "0101" : "101");
1089: break;
1090: }
1091: case '6' :
1092: {
1093: strcat(tampon, (i != 0) ? "0110" : "110");
1094: break;
1095: }
1096: case '7' :
1097: {
1098: strcat(tampon, (i != 0) ? "0111" : "111");
1099: break;
1100: }
1101: case '8' :
1102: {
1103: strcat(tampon, "1000");
1104: break;
1105: }
1106: case '9' :
1107: {
1108: strcat(tampon, "1001");
1109: break;
1110: }
1111: case 'A' :
1112: {
1113: strcat(tampon, "1010");
1114: break;
1115: }
1116: case 'B' :
1117: {
1118: strcat(tampon, "1011");
1119: break;
1120: }
1121: case 'C' :
1122: {
1123: strcat(tampon, "1100");
1124: break;
1125: }
1126: case 'D' :
1127: {
1128: strcat(tampon, "1101");
1129: break;
1130: }
1131: case 'E' :
1132: {
1133: strcat(tampon, "1110");
1134: break;
1135: }
1136: case 'F' :
1137: {
1138: strcat(tampon, "1111");
1139: break;
1140: }
1141: }
1142: }
1143:
1144: free(chaine);
1145: strcpy(base, "b");
1146: }
1147: }
1148:
1149: chaine = (unsigned char *) malloc((strlen(tampon) + 4)
1150: * sizeof(unsigned char));
1151:
1152: if (chaine == NULL)
1153: {
1154: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1155: return(NULL);
1156: }
1157:
1158: strcpy(chaine, "# ");
1159:
1160: strcat(chaine, tampon);
1161: strcat(chaine, base);
1162: }
1163: else if ((*s_objet).type == CHN)
1164: {
1165:
1166: /*
1167: --------------------------------------------------------------------------------
1168: Chaîne de caractères
1169: --------------------------------------------------------------------------------
1170: */
1171:
1172: if (format_sortie != 'C')
1173: {
1174: (*s_etat_processus).erreur_execution =
1175: d_ex_erreur_format_fichier;
1176: return(NULL);
1177: }
1178:
1179: if ((longueur_champ == -1) || (((long) strlen((unsigned char *)
1180: (*s_objet).objet)) < longueur_champ))
1181: {
1182: chaine = (unsigned char *) malloc((strlen((unsigned char *)
1183: ((*s_objet).objet)) + 1) * sizeof(unsigned char));
1184:
1185: if (chaine == NULL)
1186: {
1187: (*s_etat_processus).erreur_systeme =
1188: d_es_allocation_memoire;
1189: return(NULL);
1190: }
1191:
1192: strcpy(chaine, (unsigned char *) ((*s_objet).objet));
1193: }
1194: else
1195: {
1196: chaine = (unsigned char *) malloc((longueur_champ + 1)
1197: * sizeof(unsigned char));
1198:
1199: if (chaine == NULL)
1200: {
1201: (*s_etat_processus).erreur_systeme =
1202: d_es_allocation_memoire;
1203: return(NULL);
1204: }
1205:
1206: strncpy(chaine, (unsigned char *) ((*s_objet).objet),
1207: longueur_champ);
1208: chaine[longueur_champ] = d_code_fin_chaine;
1209: }
1210: }
1211: else if ((*s_objet).type == CPL)
1212: {
1213:
1214: /*
1215: --------------------------------------------------------------------------------
1216: Complexe
1217: --------------------------------------------------------------------------------
1218: */
1219:
1220: if ((format_sortie != 'S') && (format_sortie != 'F') &&
1221: (format_sortie != 'I') && (format_sortie != 'E'))
1222: {
1223: (*s_etat_processus).erreur_execution =
1224: d_ex_erreur_format_fichier;
1225: return(NULL);
1226: }
1227:
1228: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
1229: (void *) ((struct_complexe16 *) ((*s_objet).objet)), 'C',
1230: longueur, longueur_champ, format_sortie)) == NULL)
1231: {
1232: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1233: return(NULL);
1234: }
1235:
1236: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
1237: + 1) * sizeof(unsigned char));
1238:
1239: if (chaine == NULL)
1240: {
1241: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1242: return(NULL);
1243: }
1244:
1245: strcpy(chaine, chaine_formatee);
1246: free(chaine_formatee);
1247: }
1248: else if ((*s_objet).type == RPN)
1249: {
1250:
1251: /*
1252: --------------------------------------------------------------------------------
1253: Définition
1254: --------------------------------------------------------------------------------
1255: */
1256:
1257: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
1258: chaine_sauvegarde = chaine;
1259:
1260: while(l_element_courant != NULL)
1261: {
1262: if ((chaine_formatee = formateur_fichier(s_etat_processus,
1263: (*l_element_courant).donnee, s_format,
1264: longueur, longueur_champ, format_sortie, type,
1265: longueur_effective, recursivite)) == NULL)
1266: {
1267: return(NULL);
1268: }
1269:
1270: if ((*(*l_element_courant).donnee).type == CHN)
1271: {
1272: chaine_tampon = chaine_formatee;
1273:
1274: if ((chaine_formatee = (unsigned char *) malloc((strlen(
1275: chaine_tampon) + 3) * sizeof(unsigned char)))
1276: == NULL)
1277: {
1278: (*s_etat_processus).erreur_systeme =
1279: d_es_allocation_memoire;
1280: return(NULL);
1281: }
1282:
1283: sprintf(chaine_formatee, "\"%s\"", chaine_tampon);
1284: free(chaine_tampon);
1285: }
1286:
1287: l_element_courant = (*l_element_courant).suivant;
1288:
1289: if (chaine != NULL)
1290: {
1291: chaine_sauvegarde = chaine;
1292:
1293: if ((chaine = (unsigned char *) malloc((strlen(
1294: chaine_sauvegarde) + strlen(chaine_formatee) + 2) *
1295: sizeof(unsigned char))) == NULL)
1296: {
1297: (*s_etat_processus).erreur_systeme =
1298: d_es_allocation_memoire;
1299: return(NULL);
1300: }
1301:
1302: strcpy(chaine, chaine_sauvegarde);
1303: free(chaine_sauvegarde);
1304: strcat(chaine, " ");
1305: strcat(chaine, chaine_formatee);
1306: free(chaine_formatee);
1307: }
1308: else
1309: {
1310: chaine = chaine_formatee;
1311: }
1312: }
1313:
1314: chaine_sauvegarde = chaine;
1315: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) *
1316: sizeof(unsigned char));
1317:
1318: if (chaine == NULL)
1319: {
1320: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1321: free(chaine_sauvegarde);
1322: return(NULL);
1323: }
1324:
1325: chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine;
1326: strcpy(chaine, chaine_sauvegarde);
1327: free(chaine_sauvegarde);
1328: }
1329: else if ((*s_objet).type == INT)
1330: {
1331:
1332: /*
1333: --------------------------------------------------------------------------------
1334: Entier
1335: --------------------------------------------------------------------------------
1336: */
1337:
1338: if ((format_sortie != 'S') && (format_sortie != 'F') &&
1339: (format_sortie != 'I') && (format_sortie != 'E'))
1340: {
1341: (*s_etat_processus).erreur_execution =
1342: d_ex_erreur_format_fichier;
1343: return(NULL);
1344: }
1345:
1346: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
1347: (void *) ((integer8 *) ((*s_objet).objet)), 'I',
1348: longueur, longueur_champ, format_sortie)) == NULL)
1349: {
1350: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1351: return(NULL);
1352: }
1353:
1354: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1)
1355: * sizeof(unsigned char));
1356:
1357: if (chaine == NULL)
1358: {
1359: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1360: return(NULL);
1361: }
1362:
1363: strcpy(chaine, chaine_formatee);
1364: free(chaine_formatee);
1365: }
1366: else if ((*s_objet).type == FCT)
1367: {
1368:
1369: /*
1370: --------------------------------------------------------------------------------
1371: Fonction
1372: --------------------------------------------------------------------------------
1373: */
1374:
1375: chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
1376: ((*s_objet).objet))).nom_fonction) + 1) *
1377: sizeof(unsigned char));
1378:
1379: if (chaine == NULL)
1380: {
1381: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1382: return(NULL);
1383: }
1384:
1385: strcpy(chaine, (unsigned char *) (*((struct_fonction *)
1386: ((*s_objet).objet))).nom_fonction);
1387: }
1388: else if ((*s_objet).type == LST)
1389: {
1390:
1391: /*
1392: --------------------------------------------------------------------------------
1393: Liste
1394: --------------------------------------------------------------------------------
1395: */
1396:
1397: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
1398:
1399: if (chaine == NULL)
1400: {
1401: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1402: return(NULL);
1403: }
1404:
1405: strcpy(chaine, "{");
1406:
1407: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1408: l_element_courant_format = (struct_liste_chainee *)
1409: (*s_format).objet;
1410: nombre_elements = 0;
1411:
1412: while((l_element_courant != NULL) &&
1413: (l_element_courant_format != NULL))
1414: {
1415: if ((((*(*l_element_courant_format).donnee).type == LST)
1416: && ((*(*l_element_courant).donnee).type == LST)) ||
1417: (((*(*l_element_courant_format).donnee).type == TBL)
1418: && ((*(*l_element_courant).donnee).type == TBL)))
1419: {
1420: chaine_sauvegarde = chaine;
1421:
1422: if ((chaine_formatee = formateur_fichier(s_etat_processus,
1423: (*l_element_courant).donnee,
1424: (*l_element_courant_format).donnee,
1425: 0, 0, ' ', 'F', longueur_effective, recursivite))
1426: == NULL)
1427: {
1428: return(NULL);
1429: }
1430:
1431: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
1432: + strlen(chaine_sauvegarde) + 2)
1433: * sizeof(unsigned char));
1434:
1435: if (chaine == NULL)
1436: {
1437: (*s_etat_processus).erreur_systeme =
1438: d_es_allocation_memoire;
1439: return(NULL);
1440: }
1441:
1442: strcpy(chaine, chaine_sauvegarde);
1443: free(chaine_sauvegarde);
1444: strcat(chaine, " ");
1445: strcat(chaine, chaine_formatee);
1446: free(chaine_formatee);
1447: }
1448: else if ((*(*l_element_courant_format).donnee).type != CHN)
1449: {
1450: free(chaine);
1451:
1452: (*s_etat_processus).erreur_execution =
1453: d_ex_erreur_format_fichier;
1454: return(NULL);
1455: }
1456: else
1457: {
1458: if ((format_chaine = conversion_majuscule((unsigned char *)
1459: (*(*l_element_courant_format).donnee).objet))
1460: == NULL)
1461: {
1462: (*s_etat_processus).erreur_systeme =
1463: d_es_allocation_memoire;
1464: return(NULL);
1465: }
1466:
1467: format_degenere = d_faux;
1468:
1469: if (strncmp("STANDARD*", format_chaine, 9) == 0)
1470: {
1471: format_sortie = 'S';
1472: position_1 = 9;
1473: format_degenere = d_vrai;
1474: }
1475: else if (strncmp("BINARY*", format_chaine, 7) == 0)
1476: {
1477: format_sortie = 'B';
1478: position_1 = 7;
1479: }
1480: else if (strncmp("FIXED*", format_chaine, 6) == 0)
1481: {
1482: format_sortie = 'F';
1483: position_1 = 6;
1484: }
1485: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
1486: {
1487: format_sortie = 'I';
1488: position_1 = 11;
1489: }
1490: else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
1491: {
1492: format_sortie = 'E';
1493: position_1 = 9;
1494: }
1495: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
1496: {
1497: format_sortie = 'C';
1498: position_1 = 10;
1499: format_degenere = d_vrai;
1500: }
1501: else
1502: {
1503: free(chaine);
1504: free(format_chaine);
1505:
1506: (*s_etat_processus).erreur_execution =
1507: d_ex_erreur_format_fichier;
1508: return(NULL);
1509: }
1510:
1511: position_3 = strlen(format_chaine);
1512: format_chaine[--position_3] = d_code_fin_chaine;
1513:
1514: position_2 = position_1;
1515:
1516: while(format_chaine[position_2] != '(')
1517: {
1518: if (format_chaine[position_2] == d_code_fin_chaine)
1519: {
1520: free(chaine);
1521: free(format_chaine);
1522:
1523: (*s_etat_processus).erreur_execution =
1524: d_ex_erreur_format_fichier;
1525: return(NULL);
1526: }
1527:
1528: position_2++;
1529: }
1530:
1531: format_chaine[position_2++] = d_code_fin_chaine;
1532:
1533: if (format_degenere == d_faux)
1534: {
1535: if (sscanf(&(format_chaine[position_1]), "%ld",
1536: &longueur) != 1)
1537: {
1538: free(chaine);
1539: free(format_chaine);
1540:
1541: (*s_etat_processus).erreur_execution =
1542: d_ex_erreur_format_fichier;
1543: return(NULL);
1544: }
1545: }
1546: else
1547: {
1548: longueur = -1;
1549: }
1550:
1551: if (strcmp(&(format_chaine[position_2]), "*") != 0)
1552: {
1553: if (sscanf(&(format_chaine[position_2]), "%ld",
1554: &longueur_champ) != 1)
1555: {
1556: free(chaine);
1557: free(format_chaine);
1558:
1559: (*s_etat_processus).erreur_execution =
1560: d_ex_erreur_format_fichier;
1561: return(NULL);
1562: }
1563: }
1564: else
1565: {
1566: longueur_champ = -1;
1567: }
1568:
1569: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
1570: longueur_champ))
1571: {
1572: free(chaine);
1573: free(format_chaine);
1574:
1575: (*s_etat_processus).erreur_execution =
1576: d_ex_erreur_format_fichier;
1577: return(NULL);
1578: }
1579:
1580: free(format_chaine);
1581:
1582: chaine_sauvegarde = chaine;
1583:
1584: if ((chaine_formatee = formateur_fichier(s_etat_processus,
1585: (*l_element_courant).donnee, s_format,
1586: longueur, longueur_champ, format_sortie, type,
1587: longueur_effective, recursivite)) == NULL)
1588: {
1589: free(chaine);
1590: return(NULL);
1591: }
1592:
1593: if ((*(*l_element_courant).donnee).type == CHN)
1594: {
1595: chaine = (unsigned char *)
1596: malloc((strlen(chaine_formatee)
1597: + strlen(chaine_sauvegarde) + 4)
1598: * sizeof(unsigned char));
1599:
1600: if (chaine == NULL)
1601: {
1602: (*s_etat_processus).erreur_systeme =
1603: d_es_allocation_memoire;
1604: return(NULL);
1605: }
1606:
1607: strcpy(chaine, chaine_sauvegarde);
1608: free(chaine_sauvegarde);
1609: strcat(chaine, " \"");
1610: strcat(chaine, chaine_formatee);
1611: free(chaine_formatee);
1612: strcat(chaine, "\"");
1613: }
1614: else if ((*(*l_element_courant).donnee).type == NOM)
1615: {
1616: chaine = (unsigned char *)
1617: malloc((strlen(chaine_formatee)
1618: + strlen(chaine_sauvegarde) + 2)
1619: * sizeof(unsigned char));
1620:
1621: if (chaine == NULL)
1622: {
1623: (*s_etat_processus).erreur_systeme =
1624: d_es_allocation_memoire;
1625: return(NULL);
1626: }
1627:
1628: sprintf(chaine, "%s %s", chaine_sauvegarde,
1629: chaine_formatee);
1630: free(chaine_formatee);
1631: }
1632: else
1633: {
1634: chaine = (unsigned char *)
1635: malloc((strlen(chaine_formatee)
1636: + strlen(chaine_sauvegarde) + 2)
1637: * sizeof(unsigned char));
1638:
1639: if (chaine == NULL)
1640: {
1641: (*s_etat_processus).erreur_systeme =
1642: d_es_allocation_memoire;
1643: return(NULL);
1644: }
1645:
1646: strcpy(chaine, chaine_sauvegarde);
1647: free(chaine_sauvegarde);
1648: strcat(chaine, " ");
1649: strcat(chaine, chaine_formatee);
1650: free(chaine_formatee);
1651: }
1652: }
1653:
1654: nombre_elements++;
1655: l_element_courant = (*l_element_courant).suivant;
1656: l_element_courant_format = (*l_element_courant_format).suivant;
1657: }
1658:
1659: if ((l_element_courant != NULL) ||
1660: (l_element_courant_format != NULL))
1661: {
1662: free(chaine);
1663:
1664: (*s_etat_processus).erreur_execution =
1665: d_ex_erreur_format_fichier;
1666: return(NULL);
1667: }
1668:
1669: chaine_sauvegarde = chaine;
1670: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3)
1671: * sizeof(unsigned char));
1672:
1673: if (chaine == NULL)
1674: {
1675: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1676: return(NULL);
1677: }
1678:
1679: strcpy(chaine, chaine_sauvegarde);
1680: free(chaine_sauvegarde);
1681: strcat(chaine, " }");
1682: }
1683: else if ((*s_objet).type == TBL)
1684: {
1685:
1686: /*
1687: --------------------------------------------------------------------------------
1688: Table
1689: --------------------------------------------------------------------------------
1690: */
1691:
1692: if ((*s_format).type != TBL)
1693: {
1694: (*s_etat_processus).erreur_execution =
1695: d_ex_erreur_format_fichier;
1696: return(NULL);
1697: }
1698:
1699: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1700: l_element_courant_format = (struct_liste_chainee *)
1701: (*s_format).objet;
1702:
1703: if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
1704: (*((struct_tableau *) (*s_format).objet)).nombre_elements)
1705: {
1706: (*s_etat_processus).erreur_execution =
1707: d_ex_erreur_format_fichier;
1708: return(NULL);
1709: }
1710:
1711: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
1712:
1713: if (chaine == NULL)
1714: {
1715: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1716: return(NULL);
1717: }
1718:
1719: strcpy(chaine, "<[");
1720:
1721: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
1722: .nombre_elements; i++)
1723: {
1724: if ((((*(*((struct_tableau *) (*s_format).objet))
1725: .elements[i]).type == LST) &&
1726: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
1727: .type == LST)) ||
1728: (((*(*((struct_tableau *) (*s_format).objet))
1729: .elements[i]).type == TBL) &&
1730: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
1731: .type == TBL)))
1732: {
1733: chaine_sauvegarde = chaine;
1734:
1735: if ((chaine_formatee = formateur_fichier(s_etat_processus,
1736: (*l_element_courant).donnee,
1737: (*l_element_courant_format).donnee,
1738: 0, 0, ' ', 'F', longueur_effective, recursivite))
1739: == NULL)
1740: {
1741: return(NULL);
1742: }
1743:
1744: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
1745: + strlen(chaine_sauvegarde) + 2)
1746: * sizeof(unsigned char));
1747:
1748: if (chaine == NULL)
1749: {
1750: (*s_etat_processus).erreur_systeme =
1751: d_es_allocation_memoire;
1752: return(NULL);
1753: }
1754:
1755: strcpy(chaine, chaine_sauvegarde);
1756: free(chaine_sauvegarde);
1757: strcat(chaine, " ");
1758: strcat(chaine, chaine_formatee);
1759: free(chaine_formatee);
1760: }
1761: else if ((*(*((struct_tableau *) (*s_format).objet))
1762: .elements[i]).type != CHN)
1763: {
1764: free(chaine);
1765:
1766: (*s_etat_processus).erreur_execution =
1767: d_ex_erreur_format_fichier;
1768: return(NULL);
1769: }
1770: else
1771: {
1772: if ((format_chaine = conversion_majuscule((unsigned char *)
1773: (*(*((struct_tableau *) (*s_format).objet))
1774: .elements[i]).objet)) == NULL)
1775: {
1776: (*s_etat_processus).erreur_systeme =
1777: d_es_allocation_memoire;
1778: return(NULL);
1779: }
1780:
1781: format_degenere = d_faux;
1782:
1783: if (strncmp("STANDARD*", format_chaine, 9) == 0)
1784: {
1785: format_sortie = 'S';
1786: position_1 = 9;
1787: format_degenere = d_vrai;
1788: }
1789: else if (strncmp("BINARY*", format_chaine, 7) == 0)
1790: {
1791: format_sortie = 'B';
1792: position_1 = 7;
1793: }
1794: else if (strncmp("FIXED*", format_chaine, 6) == 0)
1795: {
1796: format_sortie = 'F';
1797: position_1 = 6;
1798: }
1799: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
1800: {
1801: format_sortie = 'I';
1802: position_1 = 11;
1803: }
1804: else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
1805: {
1806: format_sortie = 'E';
1807: position_1 = 9;
1808: }
1809: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
1810: {
1811: format_sortie = 'C';
1812: position_1 = 10;
1813: format_degenere = d_vrai;
1814: }
1815: else
1816: {
1817: free(chaine);
1818: free(format_chaine);
1819:
1820: (*s_etat_processus).erreur_execution =
1821: d_ex_erreur_format_fichier;
1822: return(NULL);
1823: }
1824:
1825: position_3 = strlen(format_chaine);
1826: format_chaine[--position_3] = d_code_fin_chaine;
1827:
1828: position_2 = position_1;
1829:
1830: while(format_chaine[position_2] != '(')
1831: {
1832: if (format_chaine[position_2] == d_code_fin_chaine)
1833: {
1834: free(chaine);
1835: free(format_chaine);
1836:
1837: (*s_etat_processus).erreur_execution =
1838: d_ex_erreur_format_fichier;
1839: return(NULL);
1840: }
1841:
1842: position_2++;
1843: }
1844:
1845: format_chaine[position_2++] = d_code_fin_chaine;
1846:
1847: if (format_degenere == d_faux)
1848: {
1849: if (sscanf(&(format_chaine[position_1]), "%ld",
1850: &longueur) != 1)
1851: {
1852: free(chaine);
1853: free(format_chaine);
1854:
1855: (*s_etat_processus).erreur_execution =
1856: d_ex_erreur_format_fichier;
1857: return(NULL);
1858: }
1859: }
1860: else
1861: {
1862: longueur = -1;
1863: }
1864:
1865: if (strcmp(&(format_chaine[position_2]), "*") != 0)
1866: {
1867: if (sscanf(&(format_chaine[position_2]), "%ld",
1868: &longueur_champ) != 1)
1869: {
1870: free(chaine);
1871: free(format_chaine);
1872:
1873: (*s_etat_processus).erreur_execution =
1874: d_ex_erreur_format_fichier;
1875: return(NULL);
1876: }
1877: }
1878: else
1879: {
1880: longueur_champ = -1;
1881: }
1882:
1883: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
1884: longueur_champ))
1885: {
1886: free(chaine);
1887: free(format_chaine);
1888:
1889: (*s_etat_processus).erreur_execution =
1890: d_ex_erreur_format_fichier;
1891: return(NULL);
1892: }
1893:
1894: free(format_chaine);
1895:
1896: chaine_sauvegarde = chaine;
1897:
1898: if ((chaine_formatee = formateur_fichier(s_etat_processus,
1899: (*((struct_tableau *) (*s_objet).objet))
1900: .elements[i], s_format,
1901: longueur, longueur_champ, format_sortie, type,
1902: longueur_effective, recursivite)) == NULL)
1903: {
1904: return(NULL);
1905: }
1906:
1907: if ((*(*((struct_tableau *) (*s_objet).objet))
1908: .elements[i]).type == CHN)
1909: {
1910: chaine = (unsigned char *)
1911: malloc((strlen(chaine_formatee)
1912: + strlen(chaine_sauvegarde) + 4)
1913: * sizeof(unsigned char));
1914:
1915: if (chaine == NULL)
1916: {
1917: (*s_etat_processus).erreur_systeme =
1918: d_es_allocation_memoire;
1919: return(NULL);
1920: }
1921:
1922: strcpy(chaine, chaine_sauvegarde);
1923: free(chaine_sauvegarde);
1924: strcat(chaine, " \"");
1925: strcat(chaine, chaine_formatee);
1926: free(chaine_formatee);
1927: strcat(chaine, "\"");
1928: }
1929: else if ((*(*((struct_tableau *) (*s_objet).objet))
1930: .elements[i]).type == NOM)
1931: {
1932: chaine = (unsigned char *)
1933: malloc((strlen(chaine_formatee)
1934: + strlen(chaine_sauvegarde) + 2)
1935: * sizeof(unsigned char));
1936:
1937: if (chaine == NULL)
1938: {
1939: (*s_etat_processus).erreur_systeme =
1940: d_es_allocation_memoire;
1941: return(NULL);
1942: }
1943:
1944: sprintf(chaine, "%s %s", chaine_sauvegarde,
1945: chaine_formatee);
1946: free(chaine_formatee);
1947: }
1948: else
1949: {
1950: chaine = (unsigned char *)
1951: malloc((strlen(chaine_formatee)
1952: + strlen(chaine_sauvegarde) + 2)
1953: * sizeof(unsigned char));
1954:
1955: if (chaine == NULL)
1956: {
1957: (*s_etat_processus).erreur_systeme =
1958: d_es_allocation_memoire;
1959: return(NULL);
1960: }
1961:
1962: strcpy(chaine, chaine_sauvegarde);
1963: free(chaine_sauvegarde);
1964: strcat(chaine, " ");
1965: strcat(chaine, chaine_formatee);
1966: free(chaine_formatee);
1967: }
1968: }
1969: }
1970:
1971: chaine_sauvegarde = chaine;
1972: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4)
1973: * sizeof(unsigned char));
1974:
1975: if (chaine == NULL)
1976: {
1977: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1978: return(NULL);
1979: }
1980:
1981: strcpy(chaine, chaine_sauvegarde);
1982: free(chaine_sauvegarde);
1983: strcat(chaine, " ]>");
1984: }
1985: else if ((*s_objet).type == MCX)
1986: {
1987:
1988: /*
1989: --------------------------------------------------------------------------------
1990: Matrice complexe
1991: --------------------------------------------------------------------------------
1992: */
1993:
1994: if ((format_sortie != 'S') && (format_sortie != 'F') &&
1995: (format_sortie != 'I') && (format_sortie != 'E'))
1996: {
1997: (*s_etat_processus).erreur_execution =
1998: d_ex_erreur_format_fichier;
1999: return(NULL);
2000: }
2001:
2002: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
2003: .nombre_lignes;
2004: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
2005: .nombre_colonnes;
2006:
2007: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2008:
2009: if (chaine != NULL)
2010: {
2011: strcpy(chaine, "[[");
2012:
2013: for(i = 0; i < nombre_lignes; i++)
2014: {
2015: for(j = 0; j < nombre_colonnes; j++)
2016: {
2017: if ((chaine_formatee =
2018: formateur_fichier_nombre(s_etat_processus,
2019: (void *) &(((struct_complexe16 **)
2020: ((*((struct_matrice *)
2021: ((*s_objet).objet))).tableau))[i][j]), 'C',
2022: longueur, longueur_champ, format_sortie))
2023: == NULL)
2024: {
2025: (*s_etat_processus).erreur_systeme =
2026: d_es_allocation_memoire;
2027: return(NULL);
2028: }
2029:
2030: chaine_sauvegarde = chaine;
2031: chaine = (unsigned char *) malloc(
2032: (strlen(chaine_sauvegarde) +
2033: strlen(chaine_formatee) + 2)
2034: * sizeof(unsigned char));
2035:
2036: if (chaine == NULL)
2037: {
2038: (*s_etat_processus).erreur_systeme =
2039: d_es_allocation_memoire;
2040: return(NULL);
2041: }
2042:
2043: strcpy(chaine, chaine_sauvegarde);
2044: free(chaine_sauvegarde);
2045: strcat(chaine, " ");
2046: strcat(chaine, chaine_formatee);
2047: free(chaine_formatee);
2048: }
2049:
2050: chaine_sauvegarde = chaine;
2051: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2052: {
2053: chaine = (unsigned char *) malloc(
2054: (strlen(chaine_sauvegarde) + 6)
2055: * sizeof(unsigned char));
2056:
2057: if (chaine == NULL)
2058: {
2059: (*s_etat_processus).erreur_systeme =
2060: d_es_allocation_memoire;
2061: return(NULL);
2062: }
2063:
2064: strcpy(chaine, chaine_sauvegarde);
2065: free(chaine_sauvegarde);
2066: strcat(chaine, " ]\n [");
2067: }
2068: else
2069: {
2070: chaine = (unsigned char *) malloc(
2071: (strlen(chaine_sauvegarde) + 4)
2072: * sizeof(unsigned char));
2073:
2074: if (chaine == NULL)
2075: {
2076: (*s_etat_processus).erreur_systeme =
2077: d_es_allocation_memoire;
2078: return(NULL);
2079: }
2080:
2081: strcpy(chaine, chaine_sauvegarde);
2082: free(chaine_sauvegarde);
2083: strcat(chaine, " ][");
2084: }
2085: }
2086:
2087: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2088: {
2089: chaine[strlen(chaine) - 3] = ']';
2090: chaine[strlen(chaine) - 2] = 0;
2091:
2092: chaine_sauvegarde = chaine;
2093: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2094: + 1) * sizeof(unsigned char));
2095:
2096: if (chaine == NULL)
2097: {
2098: (*s_etat_processus).erreur_systeme =
2099: d_es_allocation_memoire;
2100: return(NULL);
2101: }
2102:
2103: strcpy(chaine, chaine_sauvegarde);
2104: free(chaine_sauvegarde);
2105: }
2106: else
2107: {
2108: chaine[strlen(chaine) - 2] = ']';
2109: chaine[strlen(chaine) - 1] = 0;
2110:
2111: chaine_sauvegarde = chaine;
2112: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2113: + 2) * sizeof(unsigned char));
2114:
2115: if (chaine == NULL)
2116: {
2117: (*s_etat_processus).erreur_systeme =
2118: d_es_allocation_memoire;
2119: return(NULL);
2120: }
2121:
2122: strcpy(chaine, chaine_sauvegarde);
2123: free(chaine_sauvegarde);
2124: strcat(chaine, "]");
2125: }
2126: }
2127: }
2128: else if ((*s_objet).type == MIN)
2129: {
2130:
2131: /*
2132: --------------------------------------------------------------------------------
2133: Matrice entière
2134: --------------------------------------------------------------------------------
2135: */
2136:
2137: if ((format_sortie != 'S') && (format_sortie != 'F') &&
2138: (format_sortie != 'I') && (format_sortie != 'E'))
2139: {
2140: (*s_etat_processus).erreur_execution =
2141: d_ex_erreur_format_fichier;
2142: return(NULL);
2143: }
2144:
2145: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
2146: .nombre_lignes;
2147: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
2148: .nombre_colonnes;
2149:
2150: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2151:
2152: if (chaine != NULL)
2153: {
2154: strcpy(chaine, "[[");
2155:
2156: for(i = 0; i < nombre_lignes; i++)
2157: {
2158: for(j = 0; j < nombre_colonnes; j++)
2159: {
2160: if ((chaine_formatee =
2161: formateur_fichier_nombre(s_etat_processus,
2162: (void *) &(((integer8 **) ((*((struct_matrice *)
2163: ((*s_objet).objet))).tableau))[i][j]), 'I',
2164: longueur, longueur_champ, format_sortie))
2165: == NULL)
2166: {
2167: (*s_etat_processus).erreur_systeme =
2168: d_es_allocation_memoire;
2169: return(NULL);
2170: }
2171:
2172: chaine_sauvegarde = chaine;
2173: chaine = (unsigned char *) malloc(
2174: (strlen(chaine_sauvegarde) +
2175: strlen(chaine_formatee) + 2)
2176: * sizeof(unsigned char));
2177:
2178: if (chaine == NULL)
2179: {
2180: (*s_etat_processus).erreur_systeme =
2181: d_es_allocation_memoire;
2182: return(NULL);
2183: }
2184:
2185: strcpy(chaine, chaine_sauvegarde);
2186: free(chaine_sauvegarde);
2187: strcat(chaine, " ");
2188: strcat(chaine, chaine_formatee);
2189: free(chaine_formatee);
2190: }
2191:
2192: chaine_sauvegarde = chaine;
2193: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2194: {
2195: chaine = (unsigned char *) malloc(
2196: (strlen(chaine_sauvegarde) + 6)
2197: * sizeof(unsigned char));
2198:
2199: if (chaine == NULL)
2200: {
2201: (*s_etat_processus).erreur_systeme =
2202: d_es_allocation_memoire;
2203: return(NULL);
2204: }
2205:
2206: strcpy(chaine, chaine_sauvegarde);
2207: free(chaine_sauvegarde);
2208: strcat(chaine, " ]\n [");
2209: }
2210: else
2211: {
2212: chaine = (unsigned char *) malloc(
2213: (strlen(chaine_sauvegarde) + 4)
2214: * sizeof(unsigned char));
2215:
2216: if (chaine == NULL)
2217: {
2218: (*s_etat_processus).erreur_systeme =
2219: d_es_allocation_memoire;
2220: return(NULL);
2221: }
2222:
2223: strcpy(chaine, chaine_sauvegarde);
2224: free(chaine_sauvegarde);
2225: strcat(chaine, " ][");
2226: }
2227: }
2228:
2229: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2230: {
2231: chaine[strlen(chaine) - 3] = ']';
2232: chaine[strlen(chaine) - 2] = 0;
2233:
2234: chaine_sauvegarde = chaine;
2235: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2236: + 1) * sizeof(unsigned char));
2237:
2238: if (chaine == NULL)
2239: {
2240: (*s_etat_processus).erreur_systeme =
2241: d_es_allocation_memoire;
2242: return(NULL);
2243: }
2244:
2245: strcpy(chaine, chaine_sauvegarde);
2246: free(chaine_sauvegarde);
2247: }
2248: else
2249: {
2250: chaine[strlen(chaine) - 2] = ']';
2251: chaine[strlen(chaine) - 1] = 0;
2252:
2253: chaine_sauvegarde = chaine;
2254: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2255: + 2) * sizeof(unsigned char));
2256:
2257: if (chaine == NULL)
2258: {
2259: (*s_etat_processus).erreur_systeme =
2260: d_es_allocation_memoire;
2261: return(NULL);
2262: }
2263:
2264: strcpy(chaine, chaine_sauvegarde);
2265: free(chaine_sauvegarde);
2266: strcat(chaine, "]");
2267: }
2268: }
2269: }
2270: else if ((*s_objet).type == MRL)
2271: {
2272:
2273: /*
2274: --------------------------------------------------------------------------------
2275: Matrice réelle
2276: --------------------------------------------------------------------------------
2277: */
2278:
2279: if ((format_sortie != 'S') && (format_sortie != 'F') &&
2280: (format_sortie != 'I') && (format_sortie != 'E'))
2281: {
2282: (*s_etat_processus).erreur_execution =
2283: d_ex_erreur_format_fichier;
2284: return(NULL);
2285: }
2286:
2287: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
2288: .nombre_lignes;
2289: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
2290: .nombre_colonnes;
2291:
2292: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2293:
2294: if (chaine != NULL)
2295: {
2296: strcpy(chaine, "[[");
2297:
2298: for(i = 0; i < nombre_lignes; i++)
2299: {
2300: for(j = 0; j < nombre_colonnes; j++)
2301: {
2302: if ((chaine_formatee =
2303: formateur_fichier_nombre(s_etat_processus,
2304: (void *) &(((real8 **) ((*((struct_matrice *)
2305: ((*s_objet).objet))).tableau))[i][j]), 'R',
2306: longueur, longueur_champ, format_sortie))
2307: == NULL)
2308: {
2309: (*s_etat_processus).erreur_systeme =
2310: d_es_allocation_memoire;
2311: return(NULL);
2312: }
2313:
2314: chaine_sauvegarde = chaine;
2315: chaine = (unsigned char *) malloc(
2316: (strlen(chaine_sauvegarde) +
2317: strlen(chaine_formatee) + 2)
2318: * sizeof(unsigned char));
2319:
2320: if (chaine == NULL)
2321: {
2322: (*s_etat_processus).erreur_systeme =
2323: d_es_allocation_memoire;
2324: return(NULL);
2325: }
2326:
2327: strcpy(chaine, chaine_sauvegarde);
2328: free(chaine_sauvegarde);
2329: strcat(chaine, " ");
2330: strcat(chaine, chaine_formatee);
2331: free(chaine_formatee);
2332: }
2333:
2334: chaine_sauvegarde = chaine;
2335: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2336: {
2337: chaine = (unsigned char *) malloc(
2338: (strlen(chaine_sauvegarde) + 6)
2339: * sizeof(unsigned char));
2340:
2341: if (chaine == NULL)
2342: {
2343: (*s_etat_processus).erreur_systeme =
2344: d_es_allocation_memoire;
2345: return(NULL);
2346: }
2347:
2348: strcpy(chaine, chaine_sauvegarde);
2349: free(chaine_sauvegarde);
2350: strcat(chaine, " ]\n [");
2351: }
2352: else
2353: {
2354: chaine = (unsigned char *) malloc(
2355: (strlen(chaine_sauvegarde) + 4)
2356: * sizeof(unsigned char));
2357:
2358: if (chaine == NULL)
2359: {
2360: (*s_etat_processus).erreur_systeme =
2361: d_es_allocation_memoire;
2362: return(NULL);
2363: }
2364:
2365: strcpy(chaine, chaine_sauvegarde);
2366: free(chaine_sauvegarde);
2367: strcat(chaine, " ][");
2368: }
2369: }
2370:
2371: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2372: {
2373: chaine[strlen(chaine) - 3] = ']';
2374: chaine[strlen(chaine) - 2] = 0;
2375:
2376: chaine_sauvegarde = chaine;
2377: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2378: + 1) * sizeof(unsigned char));
2379:
2380: if (chaine == NULL)
2381: {
2382: (*s_etat_processus).erreur_systeme =
2383: d_es_allocation_memoire;
2384: return(NULL);
2385: }
2386:
2387: strcpy(chaine, chaine_sauvegarde);
2388: free(chaine_sauvegarde);
2389: }
2390: else
2391: {
2392: chaine[strlen(chaine) - 2] = ']';
2393: chaine[strlen(chaine) - 1] = 0;
2394:
2395: chaine_sauvegarde = chaine;
2396: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2397: + 2) * sizeof(unsigned char));
2398:
2399: if (chaine == NULL)
2400: {
2401: (*s_etat_processus).erreur_systeme =
2402: d_es_allocation_memoire;
2403: return(NULL);
2404: }
2405:
2406: strcpy(chaine, chaine_sauvegarde);
2407: free(chaine_sauvegarde);
2408: strcat(chaine, "]");
2409: }
2410: }
2411: }
2412: else if ((*s_objet).type == NOM)
2413: {
2414:
2415: /*
2416: --------------------------------------------------------------------------------
2417: Nom
2418: --------------------------------------------------------------------------------
2419: */
2420:
2421: chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
2422: (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
2423:
2424: if (chaine == NULL)
2425: {
2426: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2427: return(NULL);
2428: }
2429:
2430: sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom);
2431: }
2432: else if ((*s_objet).type == REL)
2433: {
2434:
2435: /*
2436: --------------------------------------------------------------------------------
2437: Réel
2438: --------------------------------------------------------------------------------
2439: */
2440:
2441: if ((format_sortie != 'S') && (format_sortie != 'F') &&
2442: (format_sortie != 'I') && (format_sortie != 'E'))
2443: {
2444: (*s_etat_processus).erreur_execution =
2445: d_ex_erreur_format_fichier;
2446: return(NULL);
2447: }
2448:
2449: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
2450: (void *) ((real8 *) ((*s_objet).objet)), 'R',
2451: longueur, longueur_champ, format_sortie)) == NULL)
2452: {
2453: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2454: return(NULL);
2455: }
2456:
2457: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1)
2458: * sizeof(unsigned char));
2459:
2460: if (chaine == NULL)
2461: {
2462: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2463: return(NULL);
2464: }
2465:
2466: strcpy(chaine, chaine_formatee);
2467: free(chaine_formatee);
2468: }
2469: else if ((*s_objet).type == VCX)
2470: {
2471:
2472: /*
2473: --------------------------------------------------------------------------------
2474: Vecteur complexe
2475: --------------------------------------------------------------------------------
2476: */
2477:
2478: if ((format_sortie != 'S') && (format_sortie != 'F') &&
2479: (format_sortie != 'I') && (format_sortie != 'E'))
2480: {
2481: (*s_etat_processus).erreur_execution =
2482: d_ex_erreur_format_fichier;
2483: return(NULL);
2484: }
2485:
2486: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
2487: .taille;
2488:
2489: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
2490:
2491: if (chaine != NULL)
2492: {
2493: strcpy(chaine, "[");
2494:
2495: for(i = 0; i < nombre_colonnes; i++)
2496: {
2497: if ((chaine_formatee =
2498: formateur_fichier_nombre(s_etat_processus,
2499: (void *) &(((struct_complexe16 *)
2500: ((*((struct_vecteur *)
2501: ((*s_objet).objet))).tableau))[i]), 'C',
2502: longueur, longueur_champ, format_sortie)) == NULL)
2503: {
2504: (*s_etat_processus).erreur_systeme =
2505: d_es_allocation_memoire;
2506: return(NULL);
2507: }
2508:
2509: chaine_sauvegarde = chaine;
2510: chaine = (unsigned char *) malloc(
2511: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
2512: + 2) * sizeof(unsigned char));
2513:
2514: if (chaine == NULL)
2515: {
2516: (*s_etat_processus).erreur_systeme =
2517: d_es_allocation_memoire;
2518: return(NULL);
2519: }
2520:
2521: strcpy(chaine, chaine_sauvegarde);
2522: free(chaine_sauvegarde);
2523: strcat(chaine, " ");
2524: strcat(chaine, chaine_formatee);
2525: free(chaine_formatee);
2526: }
2527:
2528: chaine_sauvegarde = chaine;
2529: chaine = (unsigned char *) malloc(
2530: (strlen(chaine_sauvegarde) + 3)
2531: * sizeof(unsigned char));
2532:
2533: if (chaine == NULL)
2534: {
2535: (*s_etat_processus).erreur_systeme =
2536: d_es_allocation_memoire;
2537: return(NULL);
2538: }
2539:
2540: strcpy(chaine, chaine_sauvegarde);
2541: free(chaine_sauvegarde);
2542: strcat(chaine, " ]");
2543: }
2544: }
2545: else if ((*s_objet).type == VIN)
2546: {
2547:
2548: /*
2549: --------------------------------------------------------------------------------
2550: Vecteur entier
2551: --------------------------------------------------------------------------------
2552: */
2553:
2554: if ((format_sortie != 'S') && (format_sortie != 'F') &&
2555: (format_sortie != 'I') && (format_sortie != 'E'))
2556: {
2557: (*s_etat_processus).erreur_execution =
2558: d_ex_erreur_format_fichier;
2559: return(NULL);
2560: }
2561:
2562: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
2563: .taille;
2564:
2565: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
2566:
2567: if (chaine != NULL)
2568: {
2569: strcpy(chaine, "[");
2570:
2571: for(i = 0; i < nombre_colonnes; i++)
2572: {
2573: if ((chaine_formatee =
2574: formateur_fichier_nombre(s_etat_processus,
2575: (void *) &(((integer8 *) ((*((struct_vecteur *)
2576: ((*s_objet).objet))).tableau))[i]), 'I',
2577: longueur, longueur_champ, format_sortie)) == NULL)
2578: {
2579: (*s_etat_processus).erreur_systeme =
2580: d_es_allocation_memoire;
2581: return(NULL);
2582: }
2583:
2584: chaine_sauvegarde = chaine;
2585: chaine = (unsigned char *) malloc(
2586: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
2587: + 2) * sizeof(unsigned char));
2588:
2589: if (chaine == NULL)
2590: {
2591: (*s_etat_processus).erreur_systeme =
2592: d_es_allocation_memoire;
2593: return(NULL);
2594: }
2595:
2596: strcpy(chaine, chaine_sauvegarde);
2597: free(chaine_sauvegarde);
2598: strcat(chaine, " ");
2599: strcat(chaine, chaine_formatee);
2600: free(chaine_formatee);
2601: }
2602:
2603: chaine_sauvegarde = chaine;
2604: chaine = (unsigned char *) malloc(
2605: (strlen(chaine_sauvegarde) + 3)
2606: * sizeof(unsigned char));
2607:
2608: if (chaine == NULL)
2609: {
2610: (*s_etat_processus).erreur_systeme =
2611: d_es_allocation_memoire;
2612: return(NULL);
2613: }
2614:
2615: strcpy(chaine, chaine_sauvegarde);
2616: free(chaine_sauvegarde);
2617: strcat(chaine, " ]");
2618: }
2619: }
2620: else if ((*s_objet).type == VRL)
2621: {
2622:
2623: /*
2624: --------------------------------------------------------------------------------
2625: Vecteur réel
2626: --------------------------------------------------------------------------------
2627: */
2628:
2629: if ((format_sortie != 'S') && (format_sortie != 'F') &&
2630: (format_sortie != 'I') && (format_sortie != 'E'))
2631: {
2632: (*s_etat_processus).erreur_execution =
2633: d_ex_erreur_format_fichier;
2634: return(NULL);
2635: }
2636:
2637: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
2638: .taille;
2639:
2640: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
2641:
2642: if (chaine != NULL)
2643: {
2644: strcpy(chaine, "[");
2645:
2646: for(i = 0; i < nombre_colonnes; i++)
2647: {
2648: if ((chaine_formatee =
2649: formateur_fichier_nombre(s_etat_processus,
2650: (void *) &(((real8 *) ((*((struct_vecteur *)
2651: ((*s_objet).objet))).tableau))[i]), 'R',
2652: longueur, longueur_champ, format_sortie)) == NULL)
2653: {
2654: (*s_etat_processus).erreur_systeme =
2655: d_es_allocation_memoire;
2656: return(NULL);
2657: }
2658:
2659: chaine_sauvegarde = chaine;
2660: chaine = (unsigned char *) malloc(
2661: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
2662: + 2) * sizeof(unsigned char));
2663:
2664: if (chaine == NULL)
2665: {
2666: (*s_etat_processus).erreur_systeme =
2667: d_es_allocation_memoire;
2668: return(NULL);
2669: }
2670:
2671: strcpy(chaine, chaine_sauvegarde);
2672: free(chaine_sauvegarde);
2673: strcat(chaine, " ");
2674: strcat(chaine, chaine_formatee);
2675: free(chaine_formatee);
2676: }
2677:
2678: chaine_sauvegarde = chaine;
2679: chaine = (unsigned char *) malloc(
2680: (strlen(chaine_sauvegarde) + 3)
2681: * sizeof(unsigned char));
2682:
2683: if (chaine == NULL)
2684: {
2685: (*s_etat_processus).erreur_systeme =
2686: d_es_allocation_memoire;
2687: return(NULL);
2688: }
2689:
2690: strcpy(chaine, chaine_sauvegarde);
2691: free(chaine_sauvegarde);
2692: strcat(chaine, " ]");
2693: }
2694: }
2695: else
2696: {
2697: // Type non exportable
2698:
2699: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
2700: free(chaine);
2701:
2702: return(NULL);
2703: }
2704:
2705: (*longueur_effective) = strlen(chaine) + 1;
2706: }
2707: else
2708: {
2709: /*
2710: * Fichiers non formatés
2711: */
2712:
2713: #define __zone() \
2714: do { int _i; \
2715: for(_i = 0; _i < longueur_totale; _i++) \
2716: printf("%02X ", chaine[_i]); printf("\b\n"); } while(0)
2717:
2718: /*
2719: * Chaque enregistrement est composé d'une donnée (une liste)
2720: * suivie de sa longueur en octets et d'un champ binaire indiquant
2721: * le format (integer*1,2,4 ou 8) d'écriture de cette longueur.
2722: * Les données contenues dans ces fichiers sont associées à un
2723: * descripteur de type.
2724: *
2725: * Attention : les fichiers non formatés ne sont pas portables
2726: * d'une architecture à l'autre.
2727: *
2728: * Structure d'un enregistrement :
2729: * [en-tête][.........données..........][longueur + type de longueur]
2730: *
2731: * Longueur : (pour l'instruction backspace)
2732: *
2733: * 00 XXXXXX longueur sur 6 bits
2734: * 01 XXXXXX longueur sur 16 bits
2735: * 10 XXXXXX longueur sur 32 bits
2736: * 11 XXXXXX longueur sur 64 bits
2737: *
2738: * Exemples :
2739: * [00 XXXXXX]
2740: * [01 ----XX][XXXXXXXX][01 XXXXXX]
2741: * [10 ----XX][XXXXXXXX][XXXXXXXX][XXXXXXXX][10 XXXXXX]
2742: * [11 ----XX][XXXXXXXX][XXXXXXXX][XXXXXXXX][XXXXXXXX][XXXXXXXX]
2743: * [XXXXXXXX][XXXXXXXX][11 XXXXXX]
2744: *
2745: * Structures des enregistrements :
2746: * chaque type de donnée est associé à une en-tête binaire comprenant
2747: * le type de données ainsi que toutes autres informations utiles.
2748: *
2749: * Représentation binaire :
2750: *
2751: * 1/ scalaires
2752: * 0000 XXXX Binaire sur XXXX octets
2753: *
2754: * TYPE
2755: * 0001 00 00 integer*1
2756: * 0001 00 01 integer*2
2757: * 0001 00 10 integer*4
2758: * 0001 00 11 integer*8
2759: *
2760: * 0001 01 00 real*4
2761: * 0001 01 01 real*8
2762: *
2763: * 0001 10 00 complex*8
2764: * 0001 10 01 complex*16
2765: *
2766: * 0010 00 00 vecteur integer*1 (dimensions integer*1)
2767: * 0010 01 00 vecteur integer*1 (dimensions integer*2)
2768: * 0010 10 00 vecteur integer*1 (dimensions integer*4)
2769: * 0010 11 00 vecteur integer*1 (dimensions integer*8)
2770: * 0010 00 01 vecteur integer*2 (dimensions integer*1)
2771: * 0010 01 01 vecteur integer*2 (dimensions integer*2)
2772: * 0010 10 01 vecteur integer*2 (dimensions integer*4)
2773: * 0010 11 01 vecteur integer*2 (dimensions integer*8)
2774: * 0010 00 10 vecteur integer*4 (dimensions integer*1)
2775: * 0010 01 10 vecteur integer*4 (dimensions integer*2)
2776: * 0010 10 10 vecteur integer*4 (dimensions integer*4)
2777: * 0010 11 10 vecteur integer*4 (dimensions integer*8)
2778: * 0010 00 11 vecteur integer*8 (dimensions integer*1)
2779: * 0010 01 11 vecteur integer*8 (dimensions integer*2)
2780: * 0010 10 11 vecteur integer*8 (dimensions integer*4)
2781: * 0010 11 11 vecteur integer*8 (dimensions integer*8)
2782: *
2783: * 0011 00 00 matrice integer*1 (dimensions integer*1)
2784: * 0011 01 00 matrice integer*1 (dimensions integer*2)
2785: * 0011 10 00 matrice integer*1 (dimensions integer*4)
2786: * 0011 11 00 matrice integer*1 (dimensions integer*8)
2787: * 0011 00 01 matrice integer*2 (dimensions integer*1)
2788: * 0011 01 01 matrice integer*2 (dimensions integer*2)
2789: * 0011 10 01 matrice integer*2 (dimensions integer*4)
2790: * 0011 11 01 matrice integer*2 (dimensions integer*8)
2791: * 0011 00 10 matrice integer*4 (dimensions integer*1)
2792: * 0011 01 10 matrice integer*4 (dimensions integer*2)
2793: * 0011 10 10 matrice integer*4 (dimensions integer*4)
2794: * 0011 11 10 matrice integer*4 (dimensions integer*8)
2795: * 0011 00 11 matrice integer*8 (dimensions integer*1)
2796: * 0011 01 11 matrice integer*8 (dimensions integer*2)
2797: * 0011 10 11 matrice integer*8 (dimensions integer*4)
2798: * 0011 11 11 matrice integer*8 (dimensions integer*8)
2799: *
2800: * 0100 0 XXX liste de longueur XXX
2801: * 0100 10 00 liste de longueur integer*1
2802: * 0100 10 01 liste de longueur integer*2
2803: * 0100 10 10 liste de longueur integer*4
2804: * 0100 10 11 liste de longueur integer*8
2805: *
2806: * 0101 0 XXX nom de longueur XXX
2807: * 0101 10 LL nom de longueur integer*LL
2808: *
2809: * 0110 0 XXX expression RPN
2810: * 0110 10 LL
2811: *
2812: * 0111 0 XXX expression algébrique
2813: * 0111 10 LL
2814: *
2815: * 1000 0 XXX chaîne de caractères
2816: * 1000 10 LL
2817: *
2818: * 1001 0 XXX table de longueur XXX
2819: * 1001 10 00 table de longueur integer*1
2820: * 1001 10 01 table de longueur integer*2
2821: * 1001 10 10 table de longueur integer*4
2822: * 1001 10 11 table de longueur integer*8
2823: *
2824: * 1010 00 10 vecteur real*4 (dimensions integer*1)
2825: * 1010 01 10 vecteur real*4 (dimensions integer*2)
2826: * 1010 10 10 vecteur real*4 (dimensions integer*4)
2827: * 1010 11 10 vecteur real*4 (dimensions integer*8)
2828: * 1010 00 11 vecteur real*8 (dimensions integer*1)
2829: * 1010 01 11 vecteur real*8 (dimensions integer*2)
2830: * 1010 10 11 vecteur real*8 (dimensions integer*4)
2831: * 1010 11 11 vecteur real*8 (dimensions integer*8)
2832: * 1011 00 10 vecteur complex*8 (dimensions integer*1)
2833: * 1011 01 10 vecteur complex*8 (dimensions integer*2)
2834: * 1011 10 10 vecteur complex*8 (dimensions integer*4)
2835: * 1011 11 10 vecteur complex*8 (dimensions integer*8)
2836: * 1011 00 11 vecteur complex*16 (dimensions integer*1)
2837: * 1011 01 11 vecteur complex*16 (dimensions integer*2)
2838: * 1011 10 11 vecteur complex*16 (dimensions integer*4)
2839: * 1011 11 11 vecteur complex*16 (dimensions integer*8)
2840: *
2841: * 1100 00 10 matrice real*4 (dimensions integer*1)
2842: * 1100 01 10 matrice real*4 (dimensions integer*2)
2843: * 1100 10 10 matrice real*4 (dimensions integer*4)
2844: * 1100 11 10 matrice real*4 (dimensions integer*8)
2845: * 1100 00 11 matrice real*8 (dimensions integer*1)
2846: * 1100 01 11 matrice real*8 (dimensions integer*2)
2847: * 1100 10 11 matrice real*8 (dimensions integer*4)
2848: * 1100 11 11 matrice real*8 (dimensions integer*8)
2849: * 1101 00 10 matrice complex*8 (dimensions integer*1)
2850: * 1101 01 10 matrice complex*8 (dimensions integer*2)
2851: * 1101 10 10 matrice complex*8 (dimensions integer*4)
2852: * 1101 11 10 matrice complex*8 (dimensions integer*8)
2853: * 1101 00 11 matrice complex*16 (dimensions integer*1)
2854: * 1101 01 11 matrice complex*16 (dimensions integer*2)
2855: * 1101 10 11 matrice complex*16 (dimensions integer*4)
2856: * 1101 11 11 matrice complex*16 (dimensions integer*8)
2857: *
2858: * Les longueurs indiquées par le champ LL suivent l'en-tête :
2859: * 00 : integer*1
2860: * 01 : integer*2
2861: * 10 : integer*4
2862: * 11 : integer*8
2863: *
2864: * [En-tête][longueur_1][longueur_2][données]
2865: * le nombre de champs longueur dépendant des types d'enregistrement.
2866: *
2867: * Toutes les autres combinaisons sont invalides.
2868: */
2869:
2870: chaine = NULL;
2871: chaine_formatee = NULL;
2872: chaine_sauvegarde = NULL;
2873:
2874: strcpy(base, " ");
2875:
2876: longueur_binaire = 0;
2877: masque_binaire = 0;
2878:
2879: if ((*s_objet).type == ALG)
2880: {
2881:
2882: /*
2883: --------------------------------------------------------------------------------
2884: Expression algébrique
2885: --------------------------------------------------------------------------------
2886: */
2887:
2888: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
2889:
2890: while(l_element_courant != NULL)
2891: {
2892: if ((*(*l_element_courant).donnee).type == FCT)
2893: {
2894: if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
2895: .donnee).objet)).nom_fonction, "<<") != 0) &&
2896: (strcmp((*((struct_fonction *)
2897: (*(*l_element_courant)
2898: .donnee).objet)).nom_fonction, ">>") != 0))
2899: {
2900: if ((strcmp((*((struct_fonction *)
2901: (*(*l_element_courant)
2902: .donnee).objet)).nom_fonction, "+") == 0) ||
2903: (strcmp((*((struct_fonction *)
2904: (*(*l_element_courant).donnee).objet))
2905: .nom_fonction, "-") == 0) || (strcmp(
2906: (*((struct_fonction *) (*(*l_element_courant)
2907: .donnee).objet)).nom_fonction, "*") == 0) ||
2908: (strcmp((*((struct_fonction *)
2909: (*(*l_element_courant).donnee).objet))
2910: .nom_fonction,
2911: "/") == 0) || (strcmp((*((struct_fonction *)
2912: (*(*l_element_courant).donnee).objet))
2913: .nom_fonction,
2914: "^") == 0) || (strcmp((*((struct_fonction *)
2915: (*(*l_element_courant).donnee).objet))
2916: .nom_fonction,
2917: "<") == 0) || (strcmp((*((struct_fonction *)
2918: (*(*l_element_courant).donnee).objet))
2919: .nom_fonction,
2920: ">") == 0) || (strcmp((*((struct_fonction *)
2921: (*(*l_element_courant).donnee).objet))
2922: .nom_fonction,
2923: "==") == 0) || (strcmp((*((struct_fonction *)
2924: (*(*l_element_courant).donnee).objet))
2925: .nom_fonction,
2926: "<>") == 0) || (strcmp((*((struct_fonction *)
2927: (*(*l_element_courant).donnee).objet))
2928: .nom_fonction,
2929: "<=") == 0) || (strcmp((*((struct_fonction *)
2930: (*(*l_element_courant).donnee).objet))
2931: .nom_fonction,
2932: "=<") == 0) || (strcmp((*((struct_fonction *)
2933: (*(*l_element_courant).donnee).objet))
2934: .nom_fonction,
2935: ">=") == 0) || (strcmp((*((struct_fonction *)
2936: (*(*l_element_courant).donnee).objet))
2937: .nom_fonction,
2938: "=>") == 0))
2939: {
2940: if (depilement(s_etat_processus,
2941: &((*s_etat_processus)
2942: .l_base_pile), &s_sous_objet_2) == d_erreur)
2943: {
2944: return(NULL);
2945: }
2946:
2947: chaine_sauvegarde = (*s_etat_processus)
2948: .instruction_courante;
2949:
2950: if (((*s_etat_processus).instruction_courante =
2951: (unsigned char *) malloc((strlen(
2952: (unsigned char *) (*s_sous_objet_2).objet)
2953: + 2 + 1) * sizeof(unsigned char))) == NULL)
2954: {
2955: (*s_etat_processus).instruction_courante =
2956: chaine_sauvegarde;
2957: (*s_etat_processus).erreur_systeme =
2958: d_es_allocation_memoire;
2959: return(NULL);
2960: }
2961:
2962: sprintf((*s_etat_processus).instruction_courante,
2963: "'%s'", (unsigned char *)
2964: (*s_sous_objet_2).objet);
2965:
2966: presence_signe = (((*s_etat_processus)
2967: .instruction_courante[1] == '+')
2968: || ((*s_etat_processus)
2969: .instruction_courante[1]
2970: == '-')) ? d_vrai : d_faux;
2971:
2972: recherche_type(s_etat_processus);
2973:
2974: if ((*s_etat_processus).erreur_execution != d_ex)
2975: {
2976: // Aucune erreur ne peut être renvoyée.
2977:
2978: return(NULL);
2979: }
2980:
2981: if (depilement(s_etat_processus,
2982: &((*s_etat_processus)
2983: .l_base_pile), &s_sous_objet_3) == d_erreur)
2984: {
2985: return(NULL);
2986: }
2987:
2988: free((*s_etat_processus).instruction_courante);
2989:
2990: (*s_etat_processus).instruction_courante =
2991: chaine_sauvegarde;
2992:
2993: autorisation_parenthese = d_faux;
2994:
2995: if ((*s_sous_objet_3).type == ALG)
2996: {
2997: l_atome = (struct_liste_chainee *)
2998: (*s_sous_objet_3).objet;
2999: chaine_fonction = "";
3000: nombre_arguments_fonction = 0;
3001:
3002: while(l_atome != NULL)
3003: {
3004: if ((*(*l_atome).donnee).type == FCT)
3005: {
3006: if (strcmp((*((struct_fonction *)
3007: (*(*l_atome).donnee).objet))
3008: .nom_fonction, ">>") != 0)
3009: {
3010: chaine_fonction =
3011: (*((struct_fonction *)
3012: (*(*l_atome).donnee).objet))
3013: .nom_fonction;
3014: nombre_arguments_fonction =
3015: (*((struct_fonction *)
3016: (*(*l_atome).donnee).objet))
3017: .nombre_arguments;
3018: }
3019: }
3020:
3021: l_atome = (*l_atome).suivant;
3022: }
3023:
3024: if (strcmp((*((struct_fonction *)
3025: (*(*l_element_courant).donnee).objet))
3026: .nom_fonction, "+") == 0)
3027: {
3028: if ((strcmp(chaine_fonction, "AND") == 0) ||
3029: (strcmp(chaine_fonction, "XOR") ==
3030: 0) || (strcmp(chaine_fonction, "OR")
3031: == 0))
3032: {
3033: autorisation_parenthese = d_vrai;
3034: }
3035: }
3036: else if (strcmp((*((struct_fonction *)
3037: (*(*l_element_courant).donnee).objet))
3038: .nom_fonction, "-") == 0)
3039: {
3040: if (nombre_arguments_fonction != 0)
3041: {
3042: autorisation_parenthese = d_faux;
3043: }
3044: else
3045: {
3046: autorisation_parenthese = d_vrai;
3047: }
3048: }
3049: else if (strcmp((*((struct_fonction *)
3050: (*(*l_element_courant).donnee).objet))
3051: .nom_fonction, "*") == 0)
3052: {
3053: if ((strcmp(chaine_fonction, "+") == 0) ||
3054: (strcmp(chaine_fonction, "-") == 0)
3055: || (strcmp(chaine_fonction, "AND")
3056: == 0) || (strcmp(chaine_fonction,
3057: "XOR") == 0) || (strcmp(
3058: chaine_fonction, "OR") == 0))
3059: {
3060: autorisation_parenthese = d_vrai;
3061: }
3062: }
3063: else if (strcmp((*((struct_fonction *)
3064: (*(*l_element_courant).donnee).objet))
3065: .nom_fonction, "/") == 0)
3066: {
3067: if (nombre_arguments_fonction != 0)
3068: {
3069: autorisation_parenthese = d_faux;
3070: }
3071: else
3072: {
3073: autorisation_parenthese = d_vrai;
3074: }
3075: }
3076: else if ((strcmp((*((struct_fonction *)
3077: (*(*l_element_courant).donnee).objet))
3078: .nom_fonction, "^") == 0))
3079: {
3080: if (nombre_arguments_fonction != 0)
3081: {
3082: autorisation_parenthese = d_faux;
3083: }
3084: else
3085: {
3086: autorisation_parenthese = d_vrai;
3087: }
3088: }
3089: }
3090:
3091: if ((autorisation_parenthese == d_vrai) ||
3092: (presence_signe == d_vrai))
3093: {
3094: chaine_sauvegarde = (unsigned char *)
3095: (*s_sous_objet_2).objet;
3096:
3097: if (((*s_sous_objet_2).objet = (void *)
3098: malloc((strlen(chaine_sauvegarde) + 2
3099: + 1) * sizeof(unsigned char))) == NULL)
3100: {
3101: (*s_etat_processus).erreur_systeme =
3102: d_es_allocation_memoire;
3103: return(NULL);
3104: }
3105:
3106: sprintf((unsigned char *) (*s_sous_objet_2)
3107: .objet, "(%s)", chaine_sauvegarde);
3108: free(chaine_sauvegarde);
3109: }
3110:
3111: liberation(s_etat_processus, s_sous_objet_3);
3112:
3113: if (depilement(s_etat_processus,
3114: &((*s_etat_processus)
3115: .l_base_pile), &s_sous_objet_1) == d_erreur)
3116: {
3117: return(NULL);
3118: }
3119:
3120: chaine_sauvegarde = (*s_etat_processus)
3121: .instruction_courante;
3122:
3123: if (((*s_etat_processus).instruction_courante =
3124: (unsigned char *) malloc((strlen(
3125: (unsigned char *) (*s_sous_objet_1).objet)
3126: + 2 + 1) * sizeof(unsigned char))) == NULL)
3127: {
3128: (*s_etat_processus).instruction_courante =
3129: chaine_sauvegarde;
3130: (*s_etat_processus).erreur_systeme =
3131: d_es_allocation_memoire;
3132: return(NULL);
3133: }
3134:
3135: sprintf((*s_etat_processus).instruction_courante,
3136: "'%s'", (unsigned char *)
3137: (*s_sous_objet_1).objet);
3138:
3139: recherche_type(s_etat_processus);
3140:
3141: if ((*s_etat_processus).erreur_execution != d_ex)
3142: {
3143: // Aucune erreur ne peut être renvoyée.
3144:
3145: return(NULL);
3146: }
3147:
3148: if (depilement(s_etat_processus,
3149: &((*s_etat_processus)
3150: .l_base_pile), &s_sous_objet_3) == d_erreur)
3151: {
3152: return(NULL);
3153: }
3154:
3155: free((*s_etat_processus).instruction_courante);
3156:
3157: (*s_etat_processus).instruction_courante =
3158: chaine_sauvegarde;
3159:
3160: autorisation_parenthese = d_faux;
3161:
3162: if ((*s_sous_objet_3).type == ALG)
3163: {
3164: l_atome = (struct_liste_chainee *)
3165: (*s_sous_objet_3).objet;
3166: chaine_fonction = "";
3167:
3168: while(l_atome != NULL)
3169: {
3170: if ((*(*l_atome).donnee).type == FCT)
3171: {
3172: if (strcmp((*((struct_fonction *)
3173: (*(*l_atome).donnee).objet))
3174: .nom_fonction, ">>") != 0)
3175: {
3176: chaine_fonction =
3177: (*((struct_fonction *)
3178: (*(*l_atome).donnee).objet))
3179: .nom_fonction;
3180: }
3181: }
3182:
3183: l_atome = (*l_atome).suivant;
3184: }
3185:
3186: if ((strcmp((*((struct_fonction *)
3187: (*(*l_element_courant).donnee).objet))
3188: .nom_fonction, "+") == 0) ||
3189: (strcmp((*((struct_fonction *)
3190: (*(*l_element_courant).donnee).objet))
3191: .nom_fonction, "-") == 0))
3192: {
3193: if ((strcmp(chaine_fonction, "AND") == 0) ||
3194: (strcmp(chaine_fonction, "XOR") ==
3195: 0) || (strcmp(chaine_fonction, "OR")
3196: == 0))
3197: {
3198: autorisation_parenthese = d_vrai;
3199: }
3200: }
3201: else if ((strcmp((*((struct_fonction *)
3202: (*(*l_element_courant).donnee).objet))
3203: .nom_fonction, "*") == 0) ||
3204: (strcmp((*((struct_fonction *)
3205: (*(*l_element_courant).donnee).objet))
3206: .nom_fonction, "/") == 0))
3207: {
3208: if ((strcmp(chaine_fonction, "+") == 0) ||
3209: (strcmp(chaine_fonction, "-") == 0)
3210: || (strcmp(chaine_fonction, "AND")
3211: == 0) || (strcmp(chaine_fonction,
3212: "XOR") == 0) || (strcmp(
3213: chaine_fonction, "OR") == 0))
3214: {
3215: autorisation_parenthese = d_vrai;
3216: }
3217: }
3218: else if ((strcmp((*((struct_fonction *)
3219: (*(*l_element_courant).donnee).objet))
3220: .nom_fonction, "^") == 0))
3221: {
3222: autorisation_parenthese = d_vrai;
3223: }
3224: }
3225:
3226: if (autorisation_parenthese == d_vrai)
3227: {
3228: chaine_sauvegarde = (unsigned char *)
3229: (*s_sous_objet_1).objet;
3230:
3231: if (((*s_sous_objet_1).objet = (void *)
3232: malloc((strlen(chaine_sauvegarde) + 2
3233: + 1) * sizeof(unsigned char))) == NULL)
3234: {
3235: (*s_etat_processus).erreur_systeme =
3236: d_es_allocation_memoire;
3237: return(NULL);
3238: }
3239:
3240: sprintf((unsigned char *) (*s_sous_objet_1)
3241: .objet, "(%s)", chaine_sauvegarde);
3242: free(chaine_sauvegarde);
3243: }
3244:
3245: liberation(s_etat_processus, s_sous_objet_3);
3246:
3247: if ((s_sous_objet = allocation(s_etat_processus,
3248: CHN)) == NULL)
3249: {
3250: (*s_etat_processus).erreur_systeme =
3251: d_es_allocation_memoire;
3252: return(NULL);
3253: }
3254:
3255: if (((*s_sous_objet).objet = (void *)
3256: malloc((strlen(
3257: (unsigned char *) (*s_sous_objet_1).objet) +
3258: strlen((*((struct_fonction *)
3259: (*(*l_element_courant).donnee).objet))
3260: .nom_fonction) + strlen((unsigned char *)
3261: (*s_sous_objet_2).objet) + 1) *
3262: sizeof(unsigned char))) == NULL)
3263: {
3264: (*s_etat_processus).erreur_systeme =
3265: d_es_allocation_memoire;
3266: return(NULL);
3267: }
3268:
3269: sprintf((unsigned char *) (*s_sous_objet).objet,
3270: "%s%s%s", (unsigned char *)
3271: (*s_sous_objet_1)
3272: .objet, (*((struct_fonction *)
3273: (*(*l_element_courant).donnee).objet))
3274: .nom_fonction, (unsigned char *)
3275: (*s_sous_objet_2).objet);
3276:
3277: liberation(s_etat_processus, s_sous_objet_1);
3278: liberation(s_etat_processus, s_sous_objet_2);
3279:
3280: if (empilement(s_etat_processus,
3281: &((*s_etat_processus)
3282: .l_base_pile), s_sous_objet) == d_erreur)
3283: {
3284: return(NULL);
3285: }
3286: }
3287: else if (strcmp((*((struct_fonction *)
3288: (*(*l_element_courant).donnee).objet))
3289: .nom_fonction, "=") == 0)
3290: {
3291: if (depilement(s_etat_processus,
3292: &((*s_etat_processus).l_base_pile),
3293: &s_sous_objet_2) == d_erreur)
3294: {
3295: return(NULL);
3296: }
3297:
3298: if (depilement(s_etat_processus,
3299: &((*s_etat_processus).l_base_pile),
3300: &s_sous_objet_1) == d_erreur)
3301: {
3302: return(NULL);
3303: }
3304:
3305: if ((s_sous_objet = allocation(s_etat_processus,
3306: CHN)) == NULL)
3307: {
3308: (*s_etat_processus).erreur_systeme =
3309: d_es_allocation_memoire;
3310: return(NULL);
3311: }
3312:
3313: autorisation_parenthese = d_vrai;
3314: l_atome = l_element_courant;
3315:
3316: if (l_atome != NULL)
3317: {
3318: if ((*l_atome).suivant != NULL)
3319: {
3320: l_atome = (*l_atome).suivant;
3321:
3322: if ((*(*l_atome).donnee).type == FCT)
3323: {
3324: if (strcmp((*((struct_fonction *)
3325: (*(*l_atome).donnee).objet))
3326: .nom_fonction, ">>") == 0)
3327: {
3328: if ((*l_atome).suivant == NULL)
3329: {
3330: autorisation_parenthese =
3331: d_faux;
3332: }
3333: }
3334: }
3335: }
3336: }
3337:
3338: if (autorisation_parenthese == d_vrai)
3339: {
3340: if (((*s_sous_objet).objet =
3341: (void *) malloc((strlen(
3342: (unsigned char *) (*s_sous_objet_1)
3343: .objet) + strlen((*((struct_fonction *)
3344: (*(*l_element_courant).donnee).objet))
3345: .nom_fonction) +
3346: strlen((unsigned char *)
3347: (*s_sous_objet_2).objet) + 2 + 1) *
3348: sizeof(unsigned char))) == NULL)
3349: {
3350: (*s_etat_processus).erreur_systeme =
3351: d_es_allocation_memoire;
3352: return(NULL);
3353: }
3354:
3355: sprintf((unsigned char *) (*s_sous_objet).objet,
3356: "(%s%s%s)", (unsigned char *)
3357: (*s_sous_objet_1)
3358: .objet, (*((struct_fonction *)
3359: (*(*l_element_courant).donnee).objet))
3360: .nom_fonction, (unsigned char *)
3361: (*s_sous_objet_2).objet);
3362: }
3363: else
3364: {
3365: if (((*s_sous_objet).objet =
3366: (void *) malloc((strlen(
3367: (unsigned char *) (*s_sous_objet_1)
3368: .objet) + strlen((*((struct_fonction *)
3369: (*(*l_element_courant).donnee).objet))
3370: .nom_fonction) + strlen(
3371: (unsigned char *) (*s_sous_objet_2)
3372: .objet) + 1) * sizeof(unsigned char)))
3373: == NULL)
3374: {
3375: (*s_etat_processus).erreur_systeme =
3376: d_es_allocation_memoire;
3377: return(NULL);
3378: }
3379:
3380: sprintf((unsigned char *) (*s_sous_objet).objet,
3381: "%s%s%s", (unsigned char *)
3382: (*s_sous_objet_1)
3383: .objet, (*((struct_fonction *)
3384: (*(*l_element_courant).donnee).objet))
3385: .nom_fonction, (unsigned char *)
3386: (*s_sous_objet_2).objet);
3387: }
3388:
3389: liberation(s_etat_processus, s_sous_objet_1);
3390: liberation(s_etat_processus, s_sous_objet_2);
3391:
3392: if (empilement(s_etat_processus,
3393: &((*s_etat_processus).l_base_pile),
3394: s_sous_objet) == d_erreur)
3395: {
3396: return(NULL);
3397: }
3398: }
3399: else if (strcmp((*((struct_fonction *)
3400: (*(*l_element_courant).donnee).objet))
3401: .nom_fonction,
3402: "NOT") == 0)
3403: {
3404: if (depilement(s_etat_processus,
3405: &((*s_etat_processus)
3406: .l_base_pile), &s_sous_objet_1) == d_erreur)
3407: {
3408: return(NULL);
3409: }
3410:
3411: if ((s_sous_objet = allocation(s_etat_processus,
3412: CHN)) == NULL)
3413: {
3414: (*s_etat_processus).erreur_systeme =
3415: d_es_allocation_memoire;
3416: return(NULL);
3417: }
3418:
3419: if (((*s_sous_objet).objet = (unsigned char *)
3420: malloc(
3421: (strlen((unsigned char *) (*s_sous_objet_1)
3422: .objet) + 4 + 1) * sizeof(unsigned char)))
3423: == NULL)
3424: {
3425: (*s_etat_processus).erreur_systeme =
3426: d_es_allocation_memoire;
3427: return(NULL);
3428: }
3429:
3430: sprintf((unsigned char *) (*s_sous_objet).objet,
3431: "%s %s", (*((struct_fonction *)
3432: (*(*l_element_courant).donnee).objet))
3433: .nom_fonction, (unsigned char *)
3434: (*s_sous_objet_1).objet );
3435:
3436: liberation(s_etat_processus, s_sous_objet_1);
3437:
3438: if (empilement(s_etat_processus,
3439: &((*s_etat_processus)
3440: .l_base_pile), s_sous_objet) == d_erreur)
3441: {
3442: return(NULL);
3443: }
3444: }
3445: else if ((strcmp((*((struct_fonction *)
3446: (*(*l_element_courant).donnee).objet))
3447: .nom_fonction,
3448: "OR") == 0) || (strcmp((*((struct_fonction *)
3449: (*(*l_element_courant).donnee).objet))
3450: .nom_fonction,
3451: "XOR") == 0) || (strcmp((*((struct_fonction *)
3452: (*(*l_element_courant).donnee).objet))
3453: .nom_fonction,
3454: "AND") == 0))
3455: {
3456: if (depilement(s_etat_processus,
3457: &((*s_etat_processus)
3458: .l_base_pile), &s_sous_objet_2) == d_erreur)
3459: {
3460: return(NULL);
3461: }
3462:
3463: if (depilement(s_etat_processus,
3464: &((*s_etat_processus)
3465: .l_base_pile), &s_sous_objet_1) == d_erreur)
3466: {
3467: return(NULL);
3468: }
3469:
3470: if ((s_sous_objet = allocation(s_etat_processus,
3471: CHN)) == NULL)
3472: {
3473: (*s_etat_processus).erreur_systeme =
3474: d_es_allocation_memoire;
3475: return(NULL);
3476: }
3477:
3478: if (((*s_sous_objet).objet = (void *)
3479: malloc((strlen(
3480: (unsigned char *) (*s_sous_objet_1).objet) +
3481: strlen((*((struct_fonction *)
3482: (*(*l_element_courant).donnee).objet))
3483: .nom_fonction) + strlen((unsigned char *)
3484: (*s_sous_objet_2).objet) + 2 + 1) *
3485: sizeof(unsigned char))) == NULL)
3486: {
3487: (*s_etat_processus).erreur_systeme =
3488: d_es_allocation_memoire;
3489: return(NULL);
3490: }
3491:
3492: sprintf((unsigned char *) (*s_sous_objet).objet,
3493: "%s %s %s", (unsigned char *)
3494: (*s_sous_objet_1)
3495: .objet, (*((struct_fonction *)
3496: (*(*l_element_courant).donnee).objet))
3497: .nom_fonction, (unsigned char *)
3498: (*s_sous_objet_2).objet);
3499:
3500: liberation(s_etat_processus, s_sous_objet_1);
3501: liberation(s_etat_processus, s_sous_objet_2);
3502:
3503: if (empilement(s_etat_processus,
3504: &((*s_etat_processus)
3505: .l_base_pile), s_sous_objet) == d_erreur)
3506: {
3507: return(NULL);
3508: }
3509: }
3510: else
3511: {
3512: nombre_arguments = (*((struct_fonction *)
3513: (*(*l_element_courant).donnee).objet))
3514: .nombre_arguments;
3515:
3516: if ((chaine = (unsigned char *)
3517: malloc(sizeof(unsigned char))) == NULL)
3518: {
3519: (*s_etat_processus).erreur_systeme =
3520: d_es_allocation_memoire;
3521: return(NULL);
3522: }
3523:
3524: chaine[0] = d_code_fin_chaine;
3525:
3526: for(i = 0; i < nombre_arguments; i++)
3527: {
3528: if ((nombre_arguments - i) > 1)
3529: {
3530: l_liste1 = (*s_etat_processus).l_base_pile;
3531:
3532: for(j = 2; j < (nombre_arguments - i); j++)
3533: {
3534: l_liste1 = (*l_liste1).suivant;
3535: }
3536:
3537: l_liste2 = (*l_liste1).suivant;
3538: (*l_liste1).suivant = (*l_liste2).suivant;
3539: (*l_liste2).suivant = (*s_etat_processus)
3540: .l_base_pile;
3541: (*s_etat_processus).l_base_pile = l_liste2;
3542: }
3543:
3544: if (depilement(s_etat_processus,
3545: &((*s_etat_processus).l_base_pile),
3546: &s_sous_objet) == d_erreur)
3547: {
3548: return(NULL);
3549: }
3550:
3551: chaine_sauvegarde = chaine;
3552:
3553: if (strlen(chaine_sauvegarde) == 0)
3554: {
3555: if ((chaine = (unsigned char *)
3556: malloc((strlen((unsigned char *)
3557: (*s_sous_objet).objet) + 1) *
3558: sizeof(unsigned char))) == NULL)
3559: {
3560: (*s_etat_processus).erreur_systeme =
3561: d_es_allocation_memoire;
3562: return(NULL);
3563: }
3564:
3565: sprintf(chaine, "%s", (unsigned char *)
3566: (*s_sous_objet).objet);
3567: }
3568: else
3569: {
3570: if ((chaine = (unsigned char *)
3571: malloc((strlen(chaine_sauvegarde)
3572: + 1 + strlen((unsigned char *)
3573: (*s_sous_objet).objet) + 1) *
3574: sizeof(unsigned char))) == NULL)
3575: {
3576: (*s_etat_processus).erreur_systeme =
3577: d_es_allocation_memoire;
3578: return(NULL);
3579: }
3580:
3581: sprintf(chaine, "%s,%s", chaine_sauvegarde,
3582: (unsigned char *) (*s_sous_objet)
3583: .objet);
3584: }
3585:
3586: free(chaine_sauvegarde);
3587: liberation(s_etat_processus, s_sous_objet);
3588: }
3589:
3590: chaine_sauvegarde = chaine;
3591:
3592: if ((chaine = (unsigned char *) malloc((strlen(
3593: (*((struct_fonction *)
3594: (*(*l_element_courant)
3595: .donnee).objet)).nom_fonction) + 2 +
3596: strlen(chaine_sauvegarde) + 1) *
3597: sizeof(unsigned char))) == NULL)
3598: {
3599: (*s_etat_processus).erreur_systeme =
3600: d_es_allocation_memoire;
3601: return(NULL);
3602: }
3603:
3604: sprintf(chaine, "%s(%s)", (*((struct_fonction *)
3605: (*(*l_element_courant).donnee).objet))
3606: .nom_fonction, chaine_sauvegarde);
3607: free(chaine_sauvegarde);
3608:
3609: if ((s_sous_objet = allocation(s_etat_processus,
3610: CHN)) == NULL)
3611: {
3612: (*s_etat_processus).erreur_systeme =
3613: d_es_allocation_memoire;
3614: return(NULL);
3615: }
3616:
3617: (*s_sous_objet).objet = (void *) chaine;
3618:
3619: if (empilement(s_etat_processus,
3620: &((*s_etat_processus)
3621: .l_base_pile), s_sous_objet) == d_erreur)
3622: {
3623: return(NULL);
3624: }
3625: }
3626: }
3627: }
3628: else
3629: {
3630: if ((s_sous_objet = allocation(s_etat_processus, CHN))
3631: == NULL)
3632: {
3633: (*s_etat_processus).erreur_systeme =
3634: d_es_allocation_memoire;
3635: return(NULL);
3636: }
3637:
3638: if (((*s_sous_objet).objet = (void *) formateur_fichier(
3639: s_etat_processus, (*l_element_courant).donnee,
3640: s_format, longueur, longueur_champ, format_sortie,
3641: type, longueur_effective, recursivite)) == NULL)
3642: {
3643: (*s_etat_processus).erreur_systeme =
3644: d_es_allocation_memoire;
3645: return(NULL);
3646: }
3647:
3648: if (((*(*l_element_courant).donnee).type == ALG)
3649: || ((*(*l_element_courant).donnee).type == NOM))
3650: {
3651: chaine_sauvegarde = (unsigned char *)
3652: (*s_sous_objet).objet;
3653:
3654: if (((*s_sous_objet).objet = malloc((strlen(
3655: chaine_sauvegarde) - 1) *
3656: sizeof(unsigned char))) == NULL)
3657: {
3658: (*s_etat_processus).erreur_systeme =
3659: d_es_allocation_memoire;
3660: return(NULL);
3661: }
3662:
3663: ptrl = chaine_sauvegarde;
3664: ptre = (unsigned char *) (*s_sous_objet).objet;
3665:
3666: for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;
3667: i--, *ptre++ = *ptrl++);
3668:
3669: (*ptre) = d_code_fin_chaine;
3670:
3671: free(chaine_sauvegarde);
3672: }
3673: else if ((*(*l_element_courant).donnee).type == CHN)
3674: {
3675: chaine_sauvegarde = (unsigned char *)
3676: (*s_sous_objet).objet;
3677:
3678: if (((*s_sous_objet).objet = malloc((strlen(
3679: chaine_sauvegarde) + 3) *
3680: sizeof(unsigned char))) == NULL)
3681: {
3682: (*s_etat_processus).erreur_systeme =
3683: d_es_allocation_memoire;
3684: return(NULL);
3685: }
3686:
3687: sprintf((unsigned char *) (*s_sous_objet).objet,
3688: "\"%s\"", chaine_sauvegarde);
3689:
3690: free(chaine_sauvegarde);
3691: }
3692:
3693: if (empilement(s_etat_processus, &((*s_etat_processus)
3694: .l_base_pile), s_sous_objet) == d_erreur)
3695: {
3696: return(NULL);
3697: }
3698: }
3699:
3700: l_element_courant = (*l_element_courant).suivant;
3701: }
3702:
3703: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3704: &s_sous_objet) == d_erreur)
3705: {
3706: return(NULL);
3707: }
3708:
3709: if ((chaine = (unsigned char *) malloc((strlen((unsigned char *)
3710: (*s_sous_objet).objet) + 2 + 1) * sizeof(unsigned char)))
3711: == NULL)
3712: {
3713: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3714: return(NULL);
3715: }
3716:
3717: sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet);
3718: liberation(s_etat_processus, s_sous_objet);
3719: }
3720: else if ((*s_objet).type == BIN)
3721: {
3722:
3723: /*
3724: --------------------------------------------------------------------------------
3725: Entier binaire en base 2, 8, 10 ou 16
3726: --------------------------------------------------------------------------------
3727: */
3728:
3729: if (format_sortie != 'B')
3730: {
3731: (*s_etat_processus).erreur_execution =
3732: d_ex_erreur_format_fichier;
3733: return(NULL);
3734: }
3735:
3736: longueur_binaire = longueur_entiers_binaires(s_etat_processus);
3737: masque_binaire = masque_entiers_binaires(s_etat_processus);
3738:
3739: if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
3740: (test_cfsf(s_etat_processus, 44) == d_faux))
3741: {
3742:
3743: /*
3744: -- Base décimale ---------------------------------------------------------------
3745: */
3746:
3747: sprintf(tampon, "%llu", (*((logical8 *)
3748: ((*s_objet).objet))) & masque_binaire);
3749: strcpy(base, "d");
3750: }
3751: else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&
3752: (test_cfsf(s_etat_processus, 44) == d_faux))
3753: {
3754:
3755: /*
3756: -- Base octale -----------------------------------------------------------------
3757: */
3758:
3759: sprintf(tampon, "%llo", (*((logical8 *)
3760: ((*s_objet).objet))) & masque_binaire);
3761: strcpy(base, "o");
3762: }
3763: else if (test_cfsf(s_etat_processus, 44) == d_vrai)
3764: {
3765:
3766: /*
3767: -- Bases hexadécimale et binaire -----------------------------------------------
3768: */
3769:
3770: sprintf(tampon, "%llX", (*((logical8 *)
3771: ((*s_objet).objet))) & masque_binaire);
3772:
3773: if (test_cfsf(s_etat_processus, 43) == d_vrai)
3774: {
3775: strcpy(base, "h");
3776: }
3777: else
3778: {
3779: chaine = (unsigned char *) malloc((strlen(tampon) + 1)
3780: * sizeof(unsigned char));
3781:
3782: if (chaine == NULL)
3783: {
3784: (*s_etat_processus).erreur_systeme =
3785: d_es_allocation_memoire;
3786: return(NULL);
3787: }
3788:
3789: strcpy(chaine, tampon);
3790: tampon[0] = 0;
3791:
3792: for(i = 0; i < strlen(chaine); i++)
3793: {
3794: switch(chaine[i])
3795: {
3796: case '0' :
3797: {
3798: strcat(tampon, (i != 0) ? "0000" : "0");
3799: break;
3800: }
3801: case '1' :
3802: {
3803: strcat(tampon, (i != 0) ? "0001" : "1");
3804: break;
3805: }
3806: case '2' :
3807: {
3808: strcat(tampon, (i != 0) ? "0010" : "10");
3809: break;
3810: }
3811: case '3' :
3812: {
3813: strcat(tampon, (i != 0) ? "0011" : "11");
3814: break;
3815: }
3816: case '4' :
3817: {
3818: strcat(tampon, (i != 0) ? "0100" : "100");
3819: break;
3820: }
3821: case '5' :
3822: {
3823: strcat(tampon, (i != 0) ? "0101" : "101");
3824: break;
3825: }
3826: case '6' :
3827: {
3828: strcat(tampon, (i != 0) ? "0110" : "110");
3829: break;
3830: }
3831: case '7' :
3832: {
3833: strcat(tampon, (i != 0) ? "0111" : "111");
3834: break;
3835: }
3836: case '8' :
3837: {
3838: strcat(tampon, "1000");
3839: break;
3840: }
3841: case '9' :
3842: {
3843: strcat(tampon, "1001");
3844: break;
3845: }
3846: case 'A' :
3847: {
3848: strcat(tampon, "1010");
3849: break;
3850: }
3851: case 'B' :
3852: {
3853: strcat(tampon, "1011");
3854: break;
3855: }
3856: case 'C' :
3857: {
3858: strcat(tampon, "1100");
3859: break;
3860: }
3861: case 'D' :
3862: {
3863: strcat(tampon, "1101");
3864: break;
3865: }
3866: case 'E' :
3867: {
3868: strcat(tampon, "1110");
3869: break;
3870: }
3871: case 'F' :
3872: {
3873: strcat(tampon, "1111");
3874: break;
3875: }
3876: }
3877: }
3878:
3879: free(chaine);
3880: strcpy(base, "b");
3881: }
3882: }
3883:
3884: chaine = (unsigned char *) malloc((strlen(tampon) + 4)
3885: * sizeof(unsigned char));
3886:
3887: if (chaine == NULL)
3888: {
3889: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3890: return(NULL);
3891: }
3892:
3893: strcpy(chaine, "# ");
3894:
3895: strcat(chaine, tampon);
3896: strcat(chaine, base);
3897: }
3898: else if ((*s_objet).type == CHN)
3899: {
3900:
3901: /*
3902: --------------------------------------------------------------------------------
3903: Chaîne de caractères
3904: --------------------------------------------------------------------------------
3905: */
3906:
3907: if (format_sortie != 'C')
3908: {
3909: (*s_etat_processus).erreur_execution =
3910: d_ex_erreur_format_fichier;
3911: return(NULL);
3912: }
3913:
3914: chaine = (unsigned char *) malloc((strlen((unsigned char *)
3915: ((*s_objet).objet)) + 1) * sizeof(unsigned char));
3916:
3917: if (chaine == NULL)
3918: {
3919: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3920: return(NULL);
3921: }
3922:
3923: strcpy(chaine, (unsigned char *) ((*s_objet).objet));
3924: }
3925: else if ((*s_objet).type == CPL)
3926: {
3927:
3928: /*
3929: --------------------------------------------------------------------------------
3930: Complexe
3931: --------------------------------------------------------------------------------
3932: */
3933:
3934: if (format_sortie != 'C')
3935: {
3936: (*s_etat_processus).erreur_execution =
3937: d_ex_erreur_format_fichier;
3938: return(NULL);
3939: }
3940:
3941: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
3942: (*s_objet).objet, 'C', longueur, longueur_effective))
3943: == NULL)
3944: {
3945: return(NULL);
3946: }
3947: }
3948: else if ((*s_objet).type == RPN)
3949: {
3950:
3951: /*
3952: --------------------------------------------------------------------------------
3953: Définition
3954: --------------------------------------------------------------------------------
3955: */
3956:
3957: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
3958: chaine_sauvegarde = chaine;
3959:
3960: while(l_element_courant != NULL)
3961: {
3962: if ((chaine_formatee = formateur_fichier(s_etat_processus,
3963: (*l_element_courant).donnee, s_format,
3964: longueur, longueur_champ, format_sortie, type,
3965: longueur_effective, recursivite)) == NULL)
3966: {
3967: return(NULL);
3968: }
3969:
3970: if ((*(*l_element_courant).donnee).type == CHN)
3971: {
3972: chaine_tampon = chaine_formatee;
3973:
3974: if ((chaine_formatee = (unsigned char *) malloc((strlen(
3975: chaine_tampon) + 3) * sizeof(unsigned char)))
3976: == NULL)
3977: {
3978: (*s_etat_processus).erreur_systeme =
3979: d_es_allocation_memoire;
3980: return(NULL);
3981: }
3982:
3983: sprintf(chaine_formatee, "\"%s\"", chaine_tampon);
3984: free(chaine_tampon);
3985: }
3986:
3987: l_element_courant = (*l_element_courant).suivant;
3988:
3989: if (chaine != NULL)
3990: {
3991: chaine_sauvegarde = chaine;
3992:
3993: if ((chaine = (unsigned char *) malloc((strlen(
3994: chaine_sauvegarde) + strlen(chaine_formatee) + 2) *
3995: sizeof(unsigned char))) == NULL)
3996: {
3997: (*s_etat_processus).erreur_systeme =
3998: d_es_allocation_memoire;
3999: return(NULL);
4000: }
4001:
4002: strcpy(chaine, chaine_sauvegarde);
4003: free(chaine_sauvegarde);
4004: strcat(chaine, " ");
4005: strcat(chaine, chaine_formatee);
4006: free(chaine_formatee);
4007: }
4008: else
4009: {
4010: chaine = chaine_formatee;
4011: }
4012: }
4013:
4014: chaine_sauvegarde = chaine;
4015: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) *
4016: sizeof(unsigned char));
4017:
4018: if (chaine == NULL)
4019: {
4020: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4021: free(chaine_sauvegarde);
4022: return(NULL);
4023: }
4024:
4025: chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine;
4026: strcpy(chaine, chaine_sauvegarde);
4027: free(chaine_sauvegarde);
4028: }
4029: else if ((*s_objet).type == INT)
4030: {
4031:
4032: /*
4033: --------------------------------------------------------------------------------
4034: Entier
4035: --------------------------------------------------------------------------------
4036: */
4037:
4038: if (format_sortie != 'I')
4039: {
4040: (*s_etat_processus).erreur_execution =
4041: d_ex_erreur_format_fichier;
4042: return(NULL);
4043: }
4044:
4045: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
4046: (*s_objet).objet, 'I', longueur, longueur_effective))
4047: == NULL)
4048: {
4049: return(NULL);
4050: }
4051: }
4052: else if ((*s_objet).type == FCT)
4053: {
4054:
4055: /*
4056: --------------------------------------------------------------------------------
4057: Fonction
4058: --------------------------------------------------------------------------------
4059: */
4060:
4061: chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
4062: ((*s_objet).objet))).nom_fonction) + 1) *
4063: sizeof(unsigned char));
4064:
4065: if (chaine == NULL)
4066: {
4067: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4068: return(NULL);
4069: }
4070:
4071: strcpy(chaine, (unsigned char *) (*((struct_fonction *)
4072: ((*s_objet).objet))).nom_fonction);
4073: }
4074: else if ((*s_objet).type == LST)
4075: {
4076:
4077: /*
4078: --------------------------------------------------------------------------------
4079: Liste
4080: Poids fort 0100
4081: --------------------------------------------------------------------------------
4082: */
4083:
4084: chaine = malloc(sizeof(unsigned char));
4085:
4086: if (chaine == NULL)
4087: {
4088: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4089: return(NULL);
4090: }
4091:
4092: // Calcul de la longueur de la liste.
4093:
4094: longueur_liste = 0;
4095: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
4096:
4097: while(l_element_courant != NULL)
4098: {
4099: l_element_courant = (*l_element_courant).suivant;
4100: longueur_liste++;
4101: }
4102:
4103: if (longueur_liste < (1LL << 3))
4104: {
4105: chaine[0] = 0x40 | (longueur_liste & 0x7);
4106: }
4107: else if (longueur_liste < (1LL << 8))
4108: {
4109: chaine[0] = 0x48;
4110: }
4111: else if (longueur_liste < (1LL << 16))
4112: {
4113: chaine[0] = 0x49;
4114: }
4115: else if (longueur_liste < (1LL << 32))
4116: {
4117: chaine[0] = 0x4A;
4118: }
4119: else
4120: {
4121: chaine[0] = 0x4B;
4122: }
4123:
4124: longueur_totale = 1;
4125:
4126: if ((chaine[0] & 0x8) != 0)
4127: {
4128: switch(chaine[0] & 0x03)
4129: {
4130: case 0x00 :
4131: {
4132: longueur_totale += 1;
4133:
4134: if ((chaine = realloc(chaine, longueur_totale *
4135: sizeof(unsigned char))) == NULL)
4136: {
4137: (*s_etat_processus).erreur_systeme =
4138: d_es_allocation_memoire;
4139: return(NULL);
4140: }
4141:
4142: chaine[longueur_totale - 1] =
4143: (unsigned char) (longueur_liste & 0xFF);
4144: break;
4145: }
4146:
4147: case 0x01 :
4148: {
4149: longueur_totale += 2;
4150:
4151: if ((chaine = realloc(chaine, longueur_totale *
4152: sizeof(unsigned char))) == NULL)
4153: {
4154: (*s_etat_processus).erreur_systeme =
4155: d_es_allocation_memoire;
4156: return(NULL);
4157: }
4158:
4159: chaine[longueur_totale - 2] =
4160: (unsigned char) ((longueur_liste >> 8) & 0xFF);
4161: chaine[longueur_totale - 1] =
4162: (unsigned char) (longueur_liste & 0xFF);
4163: break;
4164: }
4165:
4166: case 0x02 :
4167: {
4168: longueur_totale += 4;
4169:
4170: if ((chaine = realloc(chaine, longueur_totale *
4171: sizeof(unsigned char))) == NULL)
4172: {
4173: (*s_etat_processus).erreur_systeme =
4174: d_es_allocation_memoire;
4175: return(NULL);
4176: }
4177:
4178: chaine[longueur_totale - 4] =
4179: (unsigned char) ((longueur_liste >> 24) & 0xFF);
4180: chaine[longueur_totale - 3] =
4181: (unsigned char) ((longueur_liste >> 16) & 0xFF);
4182: chaine[longueur_totale - 2] =
4183: (unsigned char) ((longueur_liste >> 8) & 0xFF);
4184: chaine[longueur_totale - 1] =
4185: (unsigned char) (longueur_liste & 0xFF);
4186: break;
4187: }
4188:
4189: case 0x03 :
4190: {
4191: longueur_totale += 8;
4192:
4193: if ((chaine = realloc(chaine, longueur_totale *
4194: sizeof(unsigned char))) == NULL)
4195: {
4196: (*s_etat_processus).erreur_systeme =
4197: d_es_allocation_memoire;
4198: return(NULL);
4199: }
4200:
4201: chaine[longueur_totale - 8] =
4202: (unsigned char) ((longueur_liste >> 56) & 0xFF);
4203: chaine[longueur_totale - 7] =
4204: (unsigned char) ((longueur_liste >> 48) & 0xFF);
4205: chaine[longueur_totale - 6] =
4206: (unsigned char) ((longueur_liste >> 40) & 0xFF);
4207: chaine[longueur_totale - 5] =
4208: (unsigned char) ((longueur_liste >> 32) & 0xFF);
4209: chaine[longueur_totale - 4] =
4210: (unsigned char) ((longueur_liste >> 24) & 0xFF);
4211: chaine[longueur_totale - 3] =
4212: (unsigned char) ((longueur_liste >> 16) & 0xFF);
4213: chaine[longueur_totale - 2] =
4214: (unsigned char) ((longueur_liste >> 8) & 0xFF);
4215: chaine[longueur_totale - 1] =
4216: (unsigned char) (longueur_liste & 0xFF);
4217: break;
4218: }
4219:
4220: default :
4221: {
4222: BUG(1, printf("Internal format error\n"));
4223: }
4224: }
4225: }
4226:
4227: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
4228: l_element_courant_format = (struct_liste_chainee *)
4229: (*s_format).objet;
4230: nombre_elements = 0;
4231:
4232: while((l_element_courant != NULL) &&
4233: (l_element_courant_format != NULL))
4234: {
4235: if ((((*(*l_element_courant_format).donnee).type == LST)
4236: && ((*(*l_element_courant).donnee).type == LST)) ||
4237: (((*(*l_element_courant_format).donnee).type == TBL)
4238: && ((*(*l_element_courant).donnee).type == TBL)))
4239: {
4240: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4241: (*l_element_courant).donnee,
4242: (*l_element_courant_format).donnee,
4243: 0, 0, ' ', 'U', longueur_effective, recursivite))
4244: == NULL)
4245: {
4246: return(NULL);
4247: }
4248:
4249: if ((chaine = realloc(chaine, (longueur_totale +
4250: (*longueur_effective)) * sizeof(unsigned char)))
4251: == NULL)
4252: {
4253: (*s_etat_processus).erreur_systeme =
4254: d_es_allocation_memoire;
4255: return(NULL);
4256: }
4257:
4258: memcpy(&(chaine[longueur_totale]), chaine_formatee,
4259: (*longueur_effective));
4260: longueur_totale += (*longueur_effective);
4261: free(chaine_formatee);
4262: }
4263: else if ((*(*l_element_courant_format).donnee).type != CHN)
4264: {
4265: free(chaine);
4266:
4267: (*s_etat_processus).erreur_execution =
4268: d_ex_erreur_format_fichier;
4269: return(NULL);
4270: }
4271: else
4272: {
4273: if ((format_chaine = conversion_majuscule((unsigned char *)
4274: (*(*l_element_courant_format).donnee).objet))
4275: == NULL)
4276: {
4277: (*s_etat_processus).erreur_systeme =
4278: d_es_allocation_memoire;
4279: return(NULL);
4280: }
4281:
4282: format_degenere = d_faux;
4283:
4284: if (strncmp("INTEGER*", format_chaine, 8) == 0)
4285: {
4286: format_sortie = 'I';
4287: position_1 = 8;
4288: }
4289: else if (strncmp("LOGICAL*", format_chaine, 8) == 0)
4290: {
4291: format_sortie = 'L';
4292: position_1 = 8;
4293: }
4294: else if (strncmp("REAL*", format_chaine, 5) == 0)
4295: {
4296: format_sortie = 'R';
4297: position_1 = 5;
4298: }
4299: else if (strncmp("COMPLEX*", format_chaine, 8) == 0)
4300: {
4301: format_sortie = 'C';
4302: position_1 = 8;
4303: }
4304: else if (strcmp("CHARACTER", format_chaine) == 0)
4305: {
4306: format_sortie = 'S';
4307: position_1 = 10;
4308: format_degenere = d_vrai;
4309: }
4310: else
4311: {
4312: free(chaine);
4313: free(format_chaine);
4314:
4315: (*s_etat_processus).erreur_execution =
4316: d_ex_erreur_format_fichier;
4317: return(NULL);
4318: }
4319:
4320: if (format_degenere == d_faux)
4321: {
4322: if (format_chaine[position_1] == d_code_fin_chaine)
4323: {
4324: free(chaine);
4325: free(format_chaine);
4326:
4327: (*s_etat_processus).erreur_execution =
4328: d_ex_erreur_format_fichier;
4329: return(NULL);
4330: }
4331:
4332: if (sscanf(&(format_chaine[position_1]), "%ld",
4333: &longueur) != 1)
4334: {
4335: free(chaine);
4336: free(format_chaine);
4337:
4338: (*s_etat_processus).erreur_execution =
4339: d_ex_erreur_format_fichier;
4340: return(NULL);
4341: }
4342: }
4343: else
4344: {
4345: longueur = -1;
4346: }
4347:
4348: free(format_chaine);
4349:
4350: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4351: (*l_element_courant).donnee, s_format,
4352: longueur, longueur_champ, format_sortie, type,
4353: longueur_effective, recursivite)) == NULL)
4354: {
4355: free(chaine);
4356: return(NULL);
4357: }
4358:
4359: if ((chaine = realloc(chaine,
4360: (longueur_totale + (*longueur_effective))
4361: * sizeof(unsigned char))) == NULL)
4362: {
4363: (*s_etat_processus).erreur_systeme =
4364: d_es_allocation_memoire;
4365: return(NULL);
4366: }
4367:
4368: memcpy(&(chaine[longueur_totale]), chaine_formatee,
4369: (*longueur_effective));
4370: longueur_totale += (*longueur_effective);
4371: free(chaine_formatee);
4372: }
4373:
4374: nombre_elements++;
4375: l_element_courant = (*l_element_courant).suivant;
4376: l_element_courant_format = (*l_element_courant_format).suivant;
4377: }
4378:
4379: if ((l_element_courant != NULL) ||
4380: (l_element_courant_format != NULL))
4381: {
4382: free(chaine);
4383:
4384: (*s_etat_processus).erreur_execution =
4385: d_ex_erreur_format_fichier;
4386: return(NULL);
4387: }
4388:
4389: if ((*recursivite) == 1)
4390: {
4391: // Ajout de la longueur totale en fin d'enregistrement.
4392:
4393: if (longueur_totale < (((integer8) 1) << 6))
4394: {
4395: tampon[0] = longueur_totale + 1;
4396:
4397: if ((chaine = realloc(chaine, (longueur_totale + 1)
4398: * sizeof(unsigned char))) == NULL)
4399: {
4400: (*s_etat_processus).erreur_systeme =
4401: d_es_allocation_memoire;
4402: return(NULL);
4403: }
4404:
4405: memcpy(&(chaine[longueur_totale]), tampon, 1);
4406: longueur_totale += 1;
4407: }
4408: else if (longueur_totale < (((integer8) 1) << 16))
4409: {
4410: tampon[2] = 0x40;
4411: tampon[1] = (longueur_totale + 1) & 0xFF;
4412: tampon[0] = ((longueur_totale + 1) >> 8) & 0xFF;
4413:
4414: if ((chaine = realloc(chaine, (longueur_totale + 3)
4415: * sizeof(unsigned char))) == NULL)
4416: {
4417: (*s_etat_processus).erreur_systeme =
4418: d_es_allocation_memoire;
4419: return(NULL);
4420: }
4421:
4422: memcpy(&(chaine[longueur_totale]), tampon, 3);
4423: longueur_totale += 3;
4424: }
4425: else if (longueur_totale < (((integer8) 1) << 32))
4426: {
4427: tampon[4] = 0x80;
4428: tampon[3] = (longueur_totale + 1) & 0xFF;
4429: tampon[2] = ((longueur_totale + 1) >> 8) & 0xFF;
4430: tampon[1] = ((longueur_totale + 1) >> 16) & 0xFF;
4431: tampon[0] = ((longueur_totale + 1) >> 24) & 0xFF;
4432:
4433: if ((chaine = realloc(chaine, (longueur_totale + 5)
4434: * sizeof(unsigned char))) == NULL)
4435: {
4436: (*s_etat_processus).erreur_systeme =
4437: d_es_allocation_memoire;
4438: return(NULL);
4439: }
4440:
4441: memcpy(&(chaine[longueur_totale]), tampon, 5);
4442: longueur_totale += 5;
4443: }
4444: else
4445: {
4446: tampon[8] = 0xC0;
4447: tampon[7] = (longueur_totale + 1) & 0xFF;
4448: tampon[6] = ((longueur_totale + 1) >> 8) & 0xFF;
4449: tampon[5] = ((longueur_totale + 1) >> 16) & 0xFF;
4450: tampon[4] = ((longueur_totale + 1) >> 24) & 0xFF;
4451: tampon[3] = ((longueur_totale + 1) >> 32) & 0xFF;
4452: tampon[2] = ((longueur_totale + 1) >> 40) & 0xFF;
4453: tampon[1] = ((longueur_totale + 1) >> 48) & 0xFF;
4454: tampon[0] = ((longueur_totale + 1) >> 56) & 0xFF;
4455:
4456: if ((chaine = realloc(chaine, (longueur_totale + 9)
4457: * sizeof(unsigned char))) == NULL)
4458: {
4459: (*s_etat_processus).erreur_systeme =
4460: d_es_allocation_memoire;
4461: return(NULL);
4462: }
4463:
4464: memcpy(&(chaine[longueur_totale]), tampon, 9);
4465: longueur_totale += 9;
4466: }
4467:
4468: __zone();
4469: }
4470:
4471: (*longueur_effective) = longueur_totale;
4472: }
4473: else if ((*s_objet).type == TBL)
4474: {
4475:
4476: /*
4477: --------------------------------------------------------------------------------
4478: Table
4479: --------------------------------------------------------------------------------
4480: */
4481:
4482: if ((*s_format).type != TBL)
4483: {
4484: (*s_etat_processus).erreur_execution =
4485: d_ex_erreur_format_fichier;
4486: return(NULL);
4487: }
4488:
4489: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
4490: l_element_courant_format = (struct_liste_chainee *)
4491: (*s_format).objet;
4492:
4493: if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
4494: (*((struct_tableau *) (*s_format).objet)).nombre_elements)
4495: {
4496: (*s_etat_processus).erreur_execution =
4497: d_ex_erreur_format_fichier;
4498: return(NULL);
4499: }
4500:
4501: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
4502:
4503: if (chaine == NULL)
4504: {
4505: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4506: return(NULL);
4507: }
4508:
4509: strcpy(chaine, "<[");
4510:
4511: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
4512: .nombre_elements; i++)
4513: {
4514: if ((((*(*((struct_tableau *) (*s_format).objet))
4515: .elements[i]).type == LST) &&
4516: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
4517: .type == LST)) ||
4518: (((*(*((struct_tableau *) (*s_format).objet))
4519: .elements[i]).type == TBL) &&
4520: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
4521: .type == TBL)))
4522: {
4523: chaine_sauvegarde = chaine;
4524:
4525: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4526: (*l_element_courant).donnee,
4527: (*l_element_courant_format).donnee,
4528: 0, 0, ' ', 'F', longueur_effective, recursivite))
4529: == NULL)
4530: {
4531: return(NULL);
4532: }
4533:
4534: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
4535: + strlen(chaine_sauvegarde) + 2)
4536: * sizeof(unsigned char));
4537:
4538: if (chaine == NULL)
4539: {
4540: (*s_etat_processus).erreur_systeme =
4541: d_es_allocation_memoire;
4542: return(NULL);
4543: }
4544:
4545: strcpy(chaine, chaine_sauvegarde);
4546: free(chaine_sauvegarde);
4547: strcat(chaine, " ");
4548: strcat(chaine, chaine_formatee);
4549: free(chaine_formatee);
4550: }
4551: else if ((*(*((struct_tableau *) (*s_format).objet))
4552: .elements[i]).type != CHN)
4553: {
4554: free(chaine);
4555:
4556: (*s_etat_processus).erreur_execution =
4557: d_ex_erreur_format_fichier;
4558: return(NULL);
4559: }
4560: else
4561: {
4562: if ((format_chaine = conversion_majuscule((unsigned char *)
4563: (*(*((struct_tableau *) (*s_format).objet))
4564: .elements[i]).objet)) == NULL)
4565: {
4566: (*s_etat_processus).erreur_systeme =
4567: d_es_allocation_memoire;
4568: return(NULL);
4569: }
4570:
4571: format_degenere = d_faux;
4572:
4573: if (strncmp("STANDARD*", format_chaine, 9) == 0)
4574: {
4575: format_sortie = 'S';
4576: position_1 = 9;
4577: format_degenere = d_vrai;
4578: }
4579: else if (strncmp("BINARY*", format_chaine, 7) == 0)
4580: {
4581: format_sortie = 'B';
4582: position_1 = 7;
4583: }
4584: else if (strncmp("FIXED*", format_chaine, 6) == 0)
4585: {
4586: format_sortie = 'F';
4587: position_1 = 6;
4588: }
4589: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
4590: {
4591: format_sortie = 'I';
4592: position_1 = 11;
4593: }
4594: else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
4595: {
4596: format_sortie = 'E';
4597: position_1 = 9;
4598: }
4599: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
4600: {
4601: format_sortie = 'C';
4602: position_1 = 10;
4603: format_degenere = d_vrai;
4604: }
4605: else
4606: {
4607: free(chaine);
4608: free(format_chaine);
4609:
4610: (*s_etat_processus).erreur_execution =
4611: d_ex_erreur_format_fichier;
4612: return(NULL);
4613: }
4614:
4615: position_3 = strlen(format_chaine);
4616: format_chaine[--position_3] = d_code_fin_chaine;
4617:
4618: position_2 = position_1;
4619:
4620: while(format_chaine[position_2] != '(')
4621: {
4622: if (format_chaine[position_2] == d_code_fin_chaine)
4623: {
4624: free(chaine);
4625: free(format_chaine);
4626:
4627: (*s_etat_processus).erreur_execution =
4628: d_ex_erreur_format_fichier;
4629: return(NULL);
4630: }
4631:
4632: position_2++;
4633: }
4634:
4635: format_chaine[position_2++] = d_code_fin_chaine;
4636:
4637: if (format_degenere == d_faux)
4638: {
4639: if (sscanf(&(format_chaine[position_1]), "%ld",
4640: &longueur) != 1)
4641: {
4642: free(chaine);
4643: free(format_chaine);
4644:
4645: (*s_etat_processus).erreur_execution =
4646: d_ex_erreur_format_fichier;
4647: return(NULL);
4648: }
4649: }
4650: else
4651: {
4652: longueur = -1;
4653: }
4654:
4655: if (strcmp(&(format_chaine[position_2]), "*") != 0)
4656: {
4657: if (sscanf(&(format_chaine[position_2]), "%ld",
4658: &longueur_champ) != 1)
4659: {
4660: free(chaine);
4661: free(format_chaine);
4662:
4663: (*s_etat_processus).erreur_execution =
4664: d_ex_erreur_format_fichier;
4665: return(NULL);
4666: }
4667: }
4668: else
4669: {
4670: longueur_champ = -1;
4671: }
4672:
4673: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
4674: longueur_champ))
4675: {
4676: free(chaine);
4677: free(format_chaine);
4678:
4679: (*s_etat_processus).erreur_execution =
4680: d_ex_erreur_format_fichier;
4681: return(NULL);
4682: }
4683:
4684: free(format_chaine);
4685:
4686: chaine_sauvegarde = chaine;
4687:
4688: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4689: (*((struct_tableau *) (*s_objet).objet))
4690: .elements[i], s_format,
4691: longueur, longueur_champ, format_sortie, type,
4692: longueur_effective, recursivite)) == NULL)
4693: {
4694: return(NULL);
4695: }
4696:
4697: if ((*(*((struct_tableau *) (*s_objet).objet))
4698: .elements[i]).type == CHN)
4699: {
4700: chaine = (unsigned char *)
4701: malloc((strlen(chaine_formatee)
4702: + strlen(chaine_sauvegarde) + 4)
4703: * sizeof(unsigned char));
4704:
4705: if (chaine == NULL)
4706: {
4707: (*s_etat_processus).erreur_systeme =
4708: d_es_allocation_memoire;
4709: return(NULL);
4710: }
4711:
4712: strcpy(chaine, chaine_sauvegarde);
4713: free(chaine_sauvegarde);
4714: strcat(chaine, " \"");
4715: strcat(chaine, chaine_formatee);
4716: free(chaine_formatee);
4717: strcat(chaine, "\"");
4718: }
4719: else if ((*(*((struct_tableau *) (*s_objet).objet))
4720: .elements[i]).type == NOM)
4721: {
4722: chaine = (unsigned char *)
4723: malloc((strlen(chaine_formatee)
4724: + strlen(chaine_sauvegarde) + 2)
4725: * sizeof(unsigned char));
4726:
4727: if (chaine == NULL)
4728: {
4729: (*s_etat_processus).erreur_systeme =
4730: d_es_allocation_memoire;
4731: return(NULL);
4732: }
4733:
4734: sprintf(chaine, "%s %s", chaine_sauvegarde,
4735: chaine_formatee);
4736: free(chaine_formatee);
4737: }
4738: else
4739: {
4740: chaine = (unsigned char *)
4741: malloc((strlen(chaine_formatee)
4742: + strlen(chaine_sauvegarde) + 2)
4743: * sizeof(unsigned char));
4744:
4745: if (chaine == NULL)
4746: {
4747: (*s_etat_processus).erreur_systeme =
4748: d_es_allocation_memoire;
4749: return(NULL);
4750: }
4751:
4752: strcpy(chaine, chaine_sauvegarde);
4753: free(chaine_sauvegarde);
4754: strcat(chaine, " ");
4755: strcat(chaine, chaine_formatee);
4756: free(chaine_formatee);
4757: }
4758: }
4759: }
4760:
4761: chaine_sauvegarde = chaine;
4762: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4)
4763: * sizeof(unsigned char));
4764:
4765: if (chaine == NULL)
4766: {
4767: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4768: return(NULL);
4769: }
4770:
4771: strcpy(chaine, chaine_sauvegarde);
4772: free(chaine_sauvegarde);
4773: strcat(chaine, " ]>");
4774: }
4775: else if ((*s_objet).type == MCX)
4776: {
4777:
4778: /*
4779: --------------------------------------------------------------------------------
4780: Matrice complexe
4781: --------------------------------------------------------------------------------
4782: */
4783:
4784: if ((format_sortie != 'S') && (format_sortie != 'F') &&
4785: (format_sortie != 'I') && (format_sortie != 'E'))
4786: {
4787: (*s_etat_processus).erreur_execution =
4788: d_ex_erreur_format_fichier;
4789: return(NULL);
4790: }
4791:
4792: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
4793: .nombre_lignes;
4794: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
4795: .nombre_colonnes;
4796:
4797: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
4798:
4799: if (chaine != NULL)
4800: {
4801: strcpy(chaine, "[[");
4802:
4803: for(i = 0; i < nombre_lignes; i++)
4804: {
4805: for(j = 0; j < nombre_colonnes; j++)
4806: {
4807: if ((chaine_formatee =
4808: formateur_fichier_nombre(s_etat_processus,
4809: (void *) &(((struct_complexe16 **)
4810: ((*((struct_matrice *)
4811: ((*s_objet).objet))).tableau))[i][j]), 'C',
4812: longueur, longueur_champ, format_sortie))
4813: == NULL)
4814: {
4815: (*s_etat_processus).erreur_systeme =
4816: d_es_allocation_memoire;
4817: return(NULL);
4818: }
4819:
4820: chaine_sauvegarde = chaine;
4821: chaine = (unsigned char *) malloc(
4822: (strlen(chaine_sauvegarde) +
4823: strlen(chaine_formatee) + 2)
4824: * sizeof(unsigned char));
4825:
4826: if (chaine == NULL)
4827: {
4828: (*s_etat_processus).erreur_systeme =
4829: d_es_allocation_memoire;
4830: return(NULL);
4831: }
4832:
4833: strcpy(chaine, chaine_sauvegarde);
4834: free(chaine_sauvegarde);
4835: strcat(chaine, " ");
4836: strcat(chaine, chaine_formatee);
4837: free(chaine_formatee);
4838: }
4839:
4840: chaine_sauvegarde = chaine;
4841: if (test_cfsf(s_etat_processus, 45) == d_vrai)
4842: {
4843: chaine = (unsigned char *) malloc(
4844: (strlen(chaine_sauvegarde) + 6)
4845: * sizeof(unsigned char));
4846:
4847: if (chaine == NULL)
4848: {
4849: (*s_etat_processus).erreur_systeme =
4850: d_es_allocation_memoire;
4851: return(NULL);
4852: }
4853:
4854: strcpy(chaine, chaine_sauvegarde);
4855: free(chaine_sauvegarde);
4856: strcat(chaine, " ]\n [");
4857: }
4858: else
4859: {
4860: chaine = (unsigned char *) malloc(
4861: (strlen(chaine_sauvegarde) + 4)
4862: * sizeof(unsigned char));
4863:
4864: if (chaine == NULL)
4865: {
4866: (*s_etat_processus).erreur_systeme =
4867: d_es_allocation_memoire;
4868: return(NULL);
4869: }
4870:
4871: strcpy(chaine, chaine_sauvegarde);
4872: free(chaine_sauvegarde);
4873: strcat(chaine, " ][");
4874: }
4875: }
4876:
4877: if (test_cfsf(s_etat_processus, 45) == d_vrai)
4878: {
4879: chaine[strlen(chaine) - 3] = ']';
4880: chaine[strlen(chaine) - 2] = 0;
4881:
4882: chaine_sauvegarde = chaine;
4883: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
4884: + 1) * sizeof(unsigned char));
4885:
4886: if (chaine == NULL)
4887: {
4888: (*s_etat_processus).erreur_systeme =
4889: d_es_allocation_memoire;
4890: return(NULL);
4891: }
4892:
4893: strcpy(chaine, chaine_sauvegarde);
4894: free(chaine_sauvegarde);
4895: }
4896: else
4897: {
4898: chaine[strlen(chaine) - 2] = ']';
4899: chaine[strlen(chaine) - 1] = 0;
4900:
4901: chaine_sauvegarde = chaine;
4902: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
4903: + 2) * sizeof(unsigned char));
4904:
4905: if (chaine == NULL)
4906: {
4907: (*s_etat_processus).erreur_systeme =
4908: d_es_allocation_memoire;
4909: return(NULL);
4910: }
4911:
4912: strcpy(chaine, chaine_sauvegarde);
4913: free(chaine_sauvegarde);
4914: strcat(chaine, "]");
4915: }
4916: }
4917: }
4918: else if ((*s_objet).type == MIN)
4919: {
4920:
4921: /*
4922: --------------------------------------------------------------------------------
4923: Matrice entière
4924: --------------------------------------------------------------------------------
4925: */
4926:
4927: if ((format_sortie != 'S') && (format_sortie != 'F') &&
4928: (format_sortie != 'I') && (format_sortie != 'E'))
4929: {
4930: (*s_etat_processus).erreur_execution =
4931: d_ex_erreur_format_fichier;
4932: return(NULL);
4933: }
4934:
4935: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
4936: .nombre_lignes;
4937: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
4938: .nombre_colonnes;
4939:
4940: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
4941:
4942: if (chaine != NULL)
4943: {
4944: strcpy(chaine, "[[");
4945:
4946: for(i = 0; i < nombre_lignes; i++)
4947: {
4948: for(j = 0; j < nombre_colonnes; j++)
4949: {
4950: if ((chaine_formatee =
4951: formateur_fichier_nombre(s_etat_processus,
4952: (void *) &(((integer8 **) ((*((struct_matrice *)
4953: ((*s_objet).objet))).tableau))[i][j]), 'I',
4954: longueur, longueur_champ, format_sortie))
4955: == NULL)
4956: {
4957: (*s_etat_processus).erreur_systeme =
4958: d_es_allocation_memoire;
4959: return(NULL);
4960: }
4961:
4962: chaine_sauvegarde = chaine;
4963: chaine = (unsigned char *) malloc(
4964: (strlen(chaine_sauvegarde) +
4965: strlen(chaine_formatee) + 2)
4966: * sizeof(unsigned char));
4967:
4968: if (chaine == NULL)
4969: {
4970: (*s_etat_processus).erreur_systeme =
4971: d_es_allocation_memoire;
4972: return(NULL);
4973: }
4974:
4975: strcpy(chaine, chaine_sauvegarde);
4976: free(chaine_sauvegarde);
4977: strcat(chaine, " ");
4978: strcat(chaine, chaine_formatee);
4979: free(chaine_formatee);
4980: }
4981:
4982: chaine_sauvegarde = chaine;
4983: if (test_cfsf(s_etat_processus, 45) == d_vrai)
4984: {
4985: chaine = (unsigned char *) malloc(
4986: (strlen(chaine_sauvegarde) + 6)
4987: * sizeof(unsigned char));
4988:
4989: if (chaine == NULL)
4990: {
4991: (*s_etat_processus).erreur_systeme =
4992: d_es_allocation_memoire;
4993: return(NULL);
4994: }
4995:
4996: strcpy(chaine, chaine_sauvegarde);
4997: free(chaine_sauvegarde);
4998: strcat(chaine, " ]\n [");
4999: }
5000: else
5001: {
5002: chaine = (unsigned char *) malloc(
5003: (strlen(chaine_sauvegarde) + 4)
5004: * sizeof(unsigned char));
5005:
5006: if (chaine == NULL)
5007: {
5008: (*s_etat_processus).erreur_systeme =
5009: d_es_allocation_memoire;
5010: return(NULL);
5011: }
5012:
5013: strcpy(chaine, chaine_sauvegarde);
5014: free(chaine_sauvegarde);
5015: strcat(chaine, " ][");
5016: }
5017: }
5018:
5019: if (test_cfsf(s_etat_processus, 45) == d_vrai)
5020: {
5021: chaine[strlen(chaine) - 3] = ']';
5022: chaine[strlen(chaine) - 2] = 0;
5023:
5024: chaine_sauvegarde = chaine;
5025: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
5026: + 1) * sizeof(unsigned char));
5027:
5028: if (chaine == NULL)
5029: {
5030: (*s_etat_processus).erreur_systeme =
5031: d_es_allocation_memoire;
5032: return(NULL);
5033: }
5034:
5035: strcpy(chaine, chaine_sauvegarde);
5036: free(chaine_sauvegarde);
5037: }
5038: else
5039: {
5040: chaine[strlen(chaine) - 2] = ']';
5041: chaine[strlen(chaine) - 1] = 0;
5042:
5043: chaine_sauvegarde = chaine;
5044: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
5045: + 2) * sizeof(unsigned char));
5046:
5047: if (chaine == NULL)
5048: {
5049: (*s_etat_processus).erreur_systeme =
5050: d_es_allocation_memoire;
5051: return(NULL);
5052: }
5053:
5054: strcpy(chaine, chaine_sauvegarde);
5055: free(chaine_sauvegarde);
5056: strcat(chaine, "]");
5057: }
5058: }
5059: }
5060: else if ((*s_objet).type == MRL)
5061: {
5062:
5063: /*
5064: --------------------------------------------------------------------------------
5065: Matrice réelle
5066: --------------------------------------------------------------------------------
5067: */
5068:
5069: if ((format_sortie != 'S') && (format_sortie != 'F') &&
5070: (format_sortie != 'I') && (format_sortie != 'E'))
5071: {
5072: (*s_etat_processus).erreur_execution =
5073: d_ex_erreur_format_fichier;
5074: return(NULL);
5075: }
5076:
5077: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
5078: .nombre_lignes;
5079: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
5080: .nombre_colonnes;
5081:
5082: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
5083:
5084: if (chaine != NULL)
5085: {
5086: strcpy(chaine, "[[");
5087:
5088: for(i = 0; i < nombre_lignes; i++)
5089: {
5090: for(j = 0; j < nombre_colonnes; j++)
5091: {
5092: if ((chaine_formatee =
5093: formateur_fichier_nombre(s_etat_processus,
5094: (void *) &(((real8 **) ((*((struct_matrice *)
5095: ((*s_objet).objet))).tableau))[i][j]), 'R',
5096: longueur, longueur_champ, format_sortie))
5097: == NULL)
5098: {
5099: (*s_etat_processus).erreur_systeme =
5100: d_es_allocation_memoire;
5101: return(NULL);
5102: }
5103:
5104: chaine_sauvegarde = chaine;
5105: chaine = (unsigned char *) malloc(
5106: (strlen(chaine_sauvegarde) +
5107: strlen(chaine_formatee) + 2)
5108: * sizeof(unsigned char));
5109:
5110: if (chaine == NULL)
5111: {
5112: (*s_etat_processus).erreur_systeme =
5113: d_es_allocation_memoire;
5114: return(NULL);
5115: }
5116:
5117: strcpy(chaine, chaine_sauvegarde);
5118: free(chaine_sauvegarde);
5119: strcat(chaine, " ");
5120: strcat(chaine, chaine_formatee);
5121: free(chaine_formatee);
5122: }
5123:
5124: chaine_sauvegarde = chaine;
5125: if (test_cfsf(s_etat_processus, 45) == d_vrai)
5126: {
5127: chaine = (unsigned char *) malloc(
5128: (strlen(chaine_sauvegarde) + 6)
5129: * sizeof(unsigned char));
5130:
5131: if (chaine == NULL)
5132: {
5133: (*s_etat_processus).erreur_systeme =
5134: d_es_allocation_memoire;
5135: return(NULL);
5136: }
5137:
5138: strcpy(chaine, chaine_sauvegarde);
5139: free(chaine_sauvegarde);
5140: strcat(chaine, " ]\n [");
5141: }
5142: else
5143: {
5144: chaine = (unsigned char *) malloc(
5145: (strlen(chaine_sauvegarde) + 4)
5146: * sizeof(unsigned char));
5147:
5148: if (chaine == NULL)
5149: {
5150: (*s_etat_processus).erreur_systeme =
5151: d_es_allocation_memoire;
5152: return(NULL);
5153: }
5154:
5155: strcpy(chaine, chaine_sauvegarde);
5156: free(chaine_sauvegarde);
5157: strcat(chaine, " ][");
5158: }
5159: }
5160:
5161: if (test_cfsf(s_etat_processus, 45) == d_vrai)
5162: {
5163: chaine[strlen(chaine) - 3] = ']';
5164: chaine[strlen(chaine) - 2] = 0;
5165:
5166: chaine_sauvegarde = chaine;
5167: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
5168: + 1) * sizeof(unsigned char));
5169:
5170: if (chaine == NULL)
5171: {
5172: (*s_etat_processus).erreur_systeme =
5173: d_es_allocation_memoire;
5174: return(NULL);
5175: }
5176:
5177: strcpy(chaine, chaine_sauvegarde);
5178: free(chaine_sauvegarde);
5179: }
5180: else
5181: {
5182: chaine[strlen(chaine) - 2] = ']';
5183: chaine[strlen(chaine) - 1] = 0;
5184:
5185: chaine_sauvegarde = chaine;
5186: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
5187: + 2) * sizeof(unsigned char));
5188:
5189: if (chaine == NULL)
5190: {
5191: (*s_etat_processus).erreur_systeme =
5192: d_es_allocation_memoire;
5193: return(NULL);
5194: }
5195:
5196: strcpy(chaine, chaine_sauvegarde);
5197: free(chaine_sauvegarde);
5198: strcat(chaine, "]");
5199: }
5200: }
5201: }
5202: else if ((*s_objet).type == NOM)
5203: {
5204:
5205: /*
5206: --------------------------------------------------------------------------------
5207: Nom
5208: --------------------------------------------------------------------------------
5209: */
5210:
5211: chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
5212: (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
5213:
5214: if (chaine == NULL)
5215: {
5216: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5217: return(NULL);
5218: }
5219:
5220: sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom);
5221: }
5222: else if ((*s_objet).type == REL)
5223: {
5224:
5225: /*
5226: --------------------------------------------------------------------------------
5227: Réel
5228: --------------------------------------------------------------------------------
5229: */
5230:
5231: if (format_sortie != 'R')
5232: {
5233: (*s_etat_processus).erreur_execution =
5234: d_ex_erreur_format_fichier;
5235: return(NULL);
5236: }
5237:
5238: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
5239: (*s_objet).objet, 'R', longueur, longueur_effective))
5240: == NULL)
5241: {
5242: return(NULL);
5243: }
5244: }
5245: else if ((*s_objet).type == VCX)
5246: {
5247:
5248: /*
5249: --------------------------------------------------------------------------------
5250: Vecteur complexe
5251: --------------------------------------------------------------------------------
5252: */
5253:
5254: if ((format_sortie != 'S') && (format_sortie != 'F') &&
5255: (format_sortie != 'I') && (format_sortie != 'E'))
5256: {
5257: (*s_etat_processus).erreur_execution =
5258: d_ex_erreur_format_fichier;
5259: return(NULL);
5260: }
5261:
5262: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
5263: .taille;
5264:
5265: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
5266:
5267: if (chaine != NULL)
5268: {
5269: strcpy(chaine, "[");
5270:
5271: for(i = 0; i < nombre_colonnes; i++)
5272: {
5273: if ((chaine_formatee =
5274: formateur_fichier_nombre(s_etat_processus,
5275: (void *) &(((struct_complexe16 *)
5276: ((*((struct_vecteur *)
5277: ((*s_objet).objet))).tableau))[i]), 'C',
5278: longueur, longueur_champ, format_sortie)) == NULL)
5279: {
5280: (*s_etat_processus).erreur_systeme =
5281: d_es_allocation_memoire;
5282: return(NULL);
5283: }
5284:
5285: chaine_sauvegarde = chaine;
5286: chaine = (unsigned char *) malloc(
5287: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
5288: + 2) * sizeof(unsigned char));
5289:
5290: if (chaine == NULL)
5291: {
5292: (*s_etat_processus).erreur_systeme =
5293: d_es_allocation_memoire;
5294: return(NULL);
5295: }
5296:
5297: strcpy(chaine, chaine_sauvegarde);
5298: free(chaine_sauvegarde);
5299: strcat(chaine, " ");
5300: strcat(chaine, chaine_formatee);
5301: free(chaine_formatee);
5302: }
5303:
5304: chaine_sauvegarde = chaine;
5305: chaine = (unsigned char *) malloc(
5306: (strlen(chaine_sauvegarde) + 3)
5307: * sizeof(unsigned char));
5308:
5309: if (chaine == NULL)
5310: {
5311: (*s_etat_processus).erreur_systeme =
5312: d_es_allocation_memoire;
5313: return(NULL);
5314: }
5315:
5316: strcpy(chaine, chaine_sauvegarde);
5317: free(chaine_sauvegarde);
5318: strcat(chaine, " ]");
5319: }
5320: }
5321: else if ((*s_objet).type == VIN)
5322: {
5323:
5324: /*
5325: --------------------------------------------------------------------------------
5326: Vecteur entier
5327: --------------------------------------------------------------------------------
5328: */
5329:
5330: if ((format_sortie != 'S') && (format_sortie != 'F') &&
5331: (format_sortie != 'I') && (format_sortie != 'E'))
5332: {
5333: (*s_etat_processus).erreur_execution =
5334: d_ex_erreur_format_fichier;
5335: return(NULL);
5336: }
5337:
5338: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
5339: .taille;
5340:
5341: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
5342:
5343: if (chaine != NULL)
5344: {
5345: strcpy(chaine, "[");
5346:
5347: for(i = 0; i < nombre_colonnes; i++)
5348: {
5349: if ((chaine_formatee =
5350: formateur_fichier_nombre(s_etat_processus,
5351: (void *) &(((integer8 *) ((*((struct_vecteur *)
5352: ((*s_objet).objet))).tableau))[i]), 'I',
5353: longueur, longueur_champ, format_sortie)) == NULL)
5354: {
5355: (*s_etat_processus).erreur_systeme =
5356: d_es_allocation_memoire;
5357: return(NULL);
5358: }
5359:
5360: chaine_sauvegarde = chaine;
5361: chaine = (unsigned char *) malloc(
5362: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
5363: + 2) * sizeof(unsigned char));
5364:
5365: if (chaine == NULL)
5366: {
5367: (*s_etat_processus).erreur_systeme =
5368: d_es_allocation_memoire;
5369: return(NULL);
5370: }
5371:
5372: strcpy(chaine, chaine_sauvegarde);
5373: free(chaine_sauvegarde);
5374: strcat(chaine, " ");
5375: strcat(chaine, chaine_formatee);
5376: free(chaine_formatee);
5377: }
5378:
5379: chaine_sauvegarde = chaine;
5380: chaine = (unsigned char *) malloc(
5381: (strlen(chaine_sauvegarde) + 3)
5382: * sizeof(unsigned char));
5383:
5384: if (chaine == NULL)
5385: {
5386: (*s_etat_processus).erreur_systeme =
5387: d_es_allocation_memoire;
5388: return(NULL);
5389: }
5390:
5391: strcpy(chaine, chaine_sauvegarde);
5392: free(chaine_sauvegarde);
5393: strcat(chaine, " ]");
5394: }
5395: }
5396: else if ((*s_objet).type == VRL)
5397: {
5398:
5399: /*
5400: --------------------------------------------------------------------------------
5401: Vecteur réel
5402: --------------------------------------------------------------------------------
5403: */
5404:
5405: if ((format_sortie != 'S') && (format_sortie != 'F') &&
5406: (format_sortie != 'I') && (format_sortie != 'E'))
5407: {
5408: (*s_etat_processus).erreur_execution =
5409: d_ex_erreur_format_fichier;
5410: return(NULL);
5411: }
5412:
5413: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
5414: .taille;
5415:
5416: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
5417:
5418: if (chaine != NULL)
5419: {
5420: strcpy(chaine, "[");
5421:
5422: for(i = 0; i < nombre_colonnes; i++)
5423: {
5424: if ((chaine_formatee =
5425: formateur_fichier_nombre(s_etat_processus,
5426: (void *) &(((real8 *) ((*((struct_vecteur *)
5427: ((*s_objet).objet))).tableau))[i]), 'R',
5428: longueur, longueur_champ, format_sortie)) == NULL)
5429: {
5430: (*s_etat_processus).erreur_systeme =
5431: d_es_allocation_memoire;
5432: return(NULL);
5433: }
5434:
5435: chaine_sauvegarde = chaine;
5436: chaine = (unsigned char *) malloc(
5437: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
5438: + 2) * sizeof(unsigned char));
5439:
5440: if (chaine == NULL)
5441: {
5442: (*s_etat_processus).erreur_systeme =
5443: d_es_allocation_memoire;
5444: return(NULL);
5445: }
5446:
5447: strcpy(chaine, chaine_sauvegarde);
5448: free(chaine_sauvegarde);
5449: strcat(chaine, " ");
5450: strcat(chaine, chaine_formatee);
5451: free(chaine_formatee);
5452: }
5453:
5454: chaine_sauvegarde = chaine;
5455: chaine = (unsigned char *) malloc(
5456: (strlen(chaine_sauvegarde) + 3)
5457: * sizeof(unsigned char));
5458:
5459: if (chaine == NULL)
5460: {
5461: (*s_etat_processus).erreur_systeme =
5462: d_es_allocation_memoire;
5463: return(NULL);
5464: }
5465:
5466: strcpy(chaine, chaine_sauvegarde);
5467: free(chaine_sauvegarde);
5468: strcat(chaine, " ]");
5469: }
5470: }
5471: else
5472: {
5473: // Type non exportable
5474:
5475: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
5476: free(chaine);
5477:
5478: return(NULL);
5479: }
5480: }
5481:
5482: (*recursivite)--;
5483:
5484: return(chaine);
5485: }
5486:
5487:
5488: /*
5489: ================================================================================
5490: Routines qui transforment un nombre entier, réel ou complexe en chaîne de
5491: caractères suivant le format courant
5492: ================================================================================
5493: Entrées : pointeur générique sur la donnée numérique à convertir,
5494: type de l'entité (I, R ou C).
5495: --------------------------------------------------------------------------------
5496: Sorties : chaîne de caractères allouée dans la routine
5497: --------------------------------------------------------------------------------
5498: Effets de bord : néant
5499: ================================================================================
5500: */
5501:
5502: /*
5503: --------------------------------------------------------------------------------
5504: Formatage des complexes, réels et entiers
5505: --------------------------------------------------------------------------------
5506: */
5507:
5508: unsigned char *
5509: formateur_fichier_nombre(struct_processus *s_etat_processus,
5510: void *valeur_numerique, unsigned char type,
5511: long longueur, long longueur_champ, unsigned char format)
5512: {
5513: unsigned char *chaine;
5514: unsigned char *construction_chaine;
5515: unsigned char *sauvegarde;
5516: unsigned char *tampon;
5517:
5518: chaine = NULL;
5519:
5520: switch(type)
5521: {
5522: case 'C' :
5523: {
5524: construction_chaine = (unsigned char *) malloc(
5525: 2 * sizeof(unsigned char));
5526:
5527: if (construction_chaine == NULL)
5528: {
5529: (*s_etat_processus).erreur_systeme =
5530: d_es_allocation_memoire;
5531: return(NULL);
5532: }
5533:
5534: strcpy(construction_chaine, "(");
5535:
5536: tampon = formateur_fichier_reel(s_etat_processus,
5537: (void *) &((*((struct_complexe16 *)
5538: valeur_numerique)).partie_reelle), 'R',
5539: longueur, longueur_champ, format);
5540:
5541: if (tampon == NULL)
5542: {
5543: (*s_etat_processus).erreur_systeme =
5544: d_es_allocation_memoire;
5545: return(NULL);
5546: }
5547:
5548: sauvegarde = construction_chaine;
5549:
5550: construction_chaine = (unsigned char *) malloc(
5551: (strlen(sauvegarde) + strlen(tampon) + 2)
5552: * sizeof(unsigned char));
5553:
5554: if (construction_chaine == NULL)
5555: {
5556: (*s_etat_processus).erreur_systeme =
5557: d_es_allocation_memoire;
5558: return(NULL);
5559: }
5560:
5561: strcpy(construction_chaine, sauvegarde);
5562: free(sauvegarde);
5563: strcat(construction_chaine, tampon);
5564: free(tampon);
5565:
5566: strcat(construction_chaine, ",");
5567:
5568: tampon = formateur_fichier_reel(s_etat_processus,
5569: (void *) &((*((struct_complexe16 *)
5570: valeur_numerique)).partie_imaginaire), 'R',
5571: longueur, longueur_champ, format);
5572:
5573: if (tampon == NULL)
5574: {
5575: (*s_etat_processus).erreur_systeme =
5576: d_es_allocation_memoire;
5577: return(NULL);
5578: }
5579:
5580: sauvegarde = construction_chaine;
5581:
5582: construction_chaine = (unsigned char *) malloc(
5583: (strlen(sauvegarde) + strlen(tampon) + 2)
5584: * sizeof(unsigned char));
5585:
5586: if (construction_chaine == NULL)
5587: {
5588: (*s_etat_processus).erreur_systeme =
5589: d_es_allocation_memoire;
5590: return(NULL);
5591: }
5592:
5593: strcpy(construction_chaine, sauvegarde);
5594: free(sauvegarde);
5595: strcat(construction_chaine, tampon);
5596: free(tampon);
5597: strcat(construction_chaine, ")");
5598:
5599: chaine = construction_chaine;
5600:
5601: break;
5602: }
5603:
5604: case 'R' :
5605: {
5606: chaine = formateur_fichier_reel(s_etat_processus,
5607: valeur_numerique, 'R', longueur, longueur_champ,
5608: format);
5609:
5610: if (chaine == NULL)
5611: {
5612: (*s_etat_processus).erreur_systeme =
5613: d_es_allocation_memoire;
5614: return(NULL);
5615: }
5616:
5617: break;
5618: }
5619:
5620: default :
5621: case 'I' :
5622: {
5623: chaine = formateur_fichier_reel(s_etat_processus,
5624: valeur_numerique, 'I', longueur, longueur_champ,
5625: format);
5626:
5627: if (chaine == NULL)
5628: {
5629: (*s_etat_processus).erreur_systeme =
5630: d_es_allocation_memoire;
5631: return(NULL);
5632: }
5633:
5634: break;
5635: }
5636: }
5637:
5638: return(chaine);
5639: }
5640:
5641:
5642: /*
5643: --------------------------------------------------------------------------------
5644: Formateur des réels et entiers
5645: --------------------------------------------------------------------------------
5646: */
5647:
5648: unsigned char *
5649: formateur_fichier_reel(struct_processus *s_etat_processus,
5650: void *valeur_numerique, unsigned char type,
5651: long longueur, long longueur_champ,
5652: unsigned char format_sortie)
5653: {
5654: real8 mantisse;
5655: real8 tampon_reel;
5656:
5657: integer8 tampon_entier;
5658:
5659: long correction;
5660: long exposant;
5661: long longueur_utile;
5662: long longueur_utile_limite;
5663:
5664: unsigned char *chaine;
5665: unsigned char format[16 + 1];
5666: unsigned char mode[3 + 1];
5667: unsigned char tampon[16 + 1];
5668:
5669: unsigned long i;
5670:
5671: chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
5672:
5673: if (chaine == NULL)
5674: {
5675: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5676: return(NULL);
5677: }
5678:
5679: if (type == 'R')
5680: {
5681: tampon_reel = *((real8 *) valeur_numerique);
5682:
5683: if (tampon_reel > ((real8) 0))
5684: {
5685: exposant = (long) floor(log10(tampon_reel));
5686: }
5687: else if (tampon_reel < ((real8) 0))
5688: {
5689: exposant = (long) floor(log10(-tampon_reel));
5690: }
5691: else
5692: {
5693: exposant = 0;
5694: }
5695:
5696: mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
5697: }
5698: else
5699: {
5700: tampon_entier = *((integer8 *) valeur_numerique);
5701:
5702: if (tampon_entier > ((integer8) 0))
5703: {
5704: exposant = (long) floor(log10(tampon_entier));
5705: }
5706: else if (tampon_entier < ((integer8) 0))
5707: {
5708: exposant = (long) floor(log10(-tampon_entier));
5709: }
5710: else
5711: {
5712: exposant = 0;
5713: }
5714:
5715: mantisse = (*((integer8 *) valeur_numerique)) / pow(10, exposant);
5716: }
5717:
5718: longueur_utile = longueur;
5719: longueur_utile_limite = 15;
5720:
5721: if (longueur_utile > longueur_utile_limite)
5722: {
5723: longueur_utile = longueur_utile_limite;
5724: }
5725:
5726: if (format_sortie == 'S')
5727: {
5728: strcpy(mode, "STD");
5729: }
5730: else if (format_sortie == 'C')
5731: {
5732: strcpy(mode, "SCI");
5733: }
5734: else if (format_sortie == 'F')
5735: {
5736: strcpy(mode, "FIX");
5737: }
5738: else
5739: {
5740: strcpy(mode, "ENG");
5741: }
5742:
5743: if ((strcmp(mode, "SCI") == 0) ||
5744: ((strcmp(mode, "STD") == 0) && ((exposant >
5745: longueur_utile_limite) ||
5746: (exposant < -longueur_utile_limite))) ||
5747: ((strcmp(mode, "FIX") == 0) &&
5748: ((exposant >= longueur_utile_limite) ||
5749: (exposant < -longueur_utile))))
5750: {
5751: chaine[0] = 0;
5752: format[0] = 0;
5753:
5754: if (strcmp(mode, "STD") == 0)
5755: {
5756: longueur_utile = longueur_utile_limite - 1;
5757: }
5758:
5759: sprintf(format, "%%.%luf", longueur_utile);
5760:
5761: sprintf(tampon, format, mantisse);
5762: strcpy(chaine, tampon);
5763: strcat(chaine, "E");
5764: sprintf(tampon, "%ld", exposant);
5765: strcat(chaine, tampon);
5766: }
5767: else if (strcmp(mode, "FIX") == 0)
5768: {
5769: chaine[0] = 0;
5770: format[0] = 0;
5771:
5772: if (longueur_utile + exposant >= longueur_utile_limite)
5773: {
5774: longueur_utile = longueur_utile_limite - (exposant + 1);
5775: }
5776:
5777: sprintf(format, "%%.%luf", longueur_utile);
5778:
5779: sprintf(tampon, format, (mantisse * pow(10, exposant)));
5780: strcpy(chaine, tampon);
5781: }
5782: else if (strcmp(mode, "ENG") == 0)
5783: {
5784: chaine[0] = 0;
5785: format[0] = 0;
5786:
5787: correction = labs(exposant) % 3;
5788:
5789: if (exposant < 0)
5790: {
5791: if (correction == 0)
5792: {
5793: correction = 3;
5794: }
5795:
5796: correction = 3 - correction;
5797: }
5798:
5799: longueur_utile -= correction;
5800: sprintf(format, "%%.%luf", longueur_utile);
5801:
5802: sprintf(tampon, format, (mantisse * pow(10, correction)));
5803: strcpy(chaine, tampon);
5804: strcat(chaine, "E");
5805: sprintf(tampon, "%ld", (exposant - correction));
5806: strcat(chaine, tampon);
5807: }
5808: else
5809: {
5810: if (type == 'I')
5811: {
5812: chaine[0] = 0;
5813: sprintf(tampon, "%lld", *((integer8 *) valeur_numerique));
5814: }
5815: else
5816: {
5817: chaine[0] = 0;
5818: format[0] = 0;
5819:
5820: if (exposant >= 0)
5821: {
5822: sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
5823: - 1));
5824: }
5825: else
5826: {
5827: sprintf(format, "%%.%luf", longueur_utile_limite);
5828: }
5829:
5830: sprintf(tampon, format, *((real8 *) valeur_numerique));
5831:
5832: i = strlen(tampon) - 1;
5833: while(tampon[i] == '0')
5834: {
5835: tampon[i] = 0;
5836: i--;
5837: }
5838:
5839: if (ds_imposition_separateur_decimal == d_faux)
5840: {
5841: i = strlen(tampon) - 1;
5842: if (tampon[i] == '.')
5843: {
5844: tampon[i] = 0;
5845: }
5846: }
5847: }
5848: strcpy(chaine, tampon);
5849: }
5850:
5851: if (longueur_champ >= 0)
5852: {
5853: if (strlen(chaine) > (size_t) longueur_champ)
5854: {
5855: for(i = 0; i < (unsigned long) longueur_champ; i++)
5856: {
5857: chaine[i] = '*';
5858: }
5859:
5860: chaine[i] = d_code_fin_chaine;
5861: }
5862: }
5863:
5864: return(chaine);
5865: }
5866:
5867:
5868: /*
5869: --------------------------------------------------------------------------------
5870: Mêmes fonctions mais pour les fichiers binaires
5871: --------------------------------------------------------------------------------
5872: */
5873:
5874: unsigned char *
5875: formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,
5876: void *valeur_numerique, unsigned char type, long longueur,
5877: long *longueur_conversion)
5878: {
5879: unsigned char *chaine;
5880:
5881: switch(type)
5882: {
5883: default :
5884: case 'I' :
5885: {
5886: switch(longueur)
5887: {
5888: case 1:
5889: {
5890: if ((*((integer8 *) valeur_numerique)) !=
5891: ((integer1) (*((integer8 *) valeur_numerique))))
5892: {
5893: (*s_etat_processus).erreur_execution =
5894: d_ex_representation;
5895: return(NULL);
5896: }
5897:
5898: if ((chaine = malloc(2 * sizeof(unsigned char))) == NULL)
5899: {
5900: (*s_etat_processus).erreur_systeme =
5901: d_es_allocation_memoire;
5902: return(NULL);
5903: }
5904:
5905: (*longueur_conversion) = 2;
5906: chaine[0] = 0x10;
5907: chaine[1] = (*((integer8 *) valeur_numerique)) & 0xFF;
5908: break;
5909: }
5910:
5911: case 2:
5912: {
5913: if ((*((integer8 *) valeur_numerique)) !=
5914: ((integer2) (*((integer8 *) valeur_numerique))))
5915: {
5916: (*s_etat_processus).erreur_execution =
5917: d_ex_representation;
5918: return(NULL);
5919: }
5920:
5921: if ((chaine = malloc(3 * sizeof(unsigned char))) == NULL)
5922: {
5923: (*s_etat_processus).erreur_systeme =
5924: d_es_allocation_memoire;
5925: return(NULL);
5926: }
5927:
5928: (*longueur_conversion) = 3;
5929: chaine[0] = 0x11;
5930: chaine[1] = ((*((integer8 *) valeur_numerique)) >> 8)
5931: & 0xFF;
5932: chaine[2] = (*((integer8 *) valeur_numerique)) & 0xFF;
5933: break;
5934: }
5935:
5936: case 4:
5937: {
5938: if ((*((integer8 *) valeur_numerique)) !=
5939: ((integer2) (*((integer8 *) valeur_numerique))))
5940: {
5941: (*s_etat_processus).erreur_execution =
5942: d_ex_representation;
5943: return(NULL);
5944: }
5945:
5946: if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
5947: {
5948: (*s_etat_processus).erreur_systeme =
5949: d_es_allocation_memoire;
5950: return(NULL);
5951: }
5952:
5953: (*longueur_conversion) = 5;
5954: chaine[0] = 0x12;
5955: chaine[1] = ((*((integer8 *) valeur_numerique)) >> 24)
5956: & 0xFF;
5957: chaine[2] = ((*((integer8 *) valeur_numerique)) >> 16)
5958: & 0xFF;
5959: chaine[3] = ((*((integer8 *) valeur_numerique)) >> 8)
5960: & 0xFF;
5961: chaine[4] = (*((integer8 *) valeur_numerique)) & 0xFF;
5962: break;
5963: }
5964:
5965: case 8:
5966: {
5967: if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
5968: {
5969: (*s_etat_processus).erreur_systeme =
5970: d_es_allocation_memoire;
5971: return(NULL);
5972: }
5973:
5974: (*longueur_conversion) = 9;
5975: chaine[0] = 0x13;
5976: chaine[1] = ((*((integer8 *) valeur_numerique)) >> 56)
5977: & 0xFF;
5978: chaine[2] = ((*((integer8 *) valeur_numerique)) >> 48)
5979: & 0xFF;
5980: chaine[3] = ((*((integer8 *) valeur_numerique)) >> 40)
5981: & 0xFF;
5982: chaine[4] = ((*((integer8 *) valeur_numerique)) >> 32)
5983: & 0xFF;
5984: chaine[5] = ((*((integer8 *) valeur_numerique)) >> 24)
5985: & 0xFF;
5986: chaine[6] = ((*((integer8 *) valeur_numerique)) >> 16)
5987: & 0xFF;
5988: chaine[7] = ((*((integer8 *) valeur_numerique)) >> 8)
5989: & 0xFF;
5990: chaine[8] = (*((integer8 *) valeur_numerique)) & 0xFF;
5991: break;
5992: }
5993:
5994: default :
5995: {
5996: (*s_etat_processus).erreur_execution =
5997: d_ex_erreur_format_fichier;
5998: return(NULL);
5999: }
6000: }
6001:
6002: break;
6003: }
6004:
6005: case 'R' :
6006: {
6007: switch(longueur)
6008: {
6009: case 4:
6010: {
6011: double vinf;
6012: double vsup;
6013:
6014: union
6015: {
6016: real4 r4;
6017: integer4 i4;
6018: } eq4;
6019:
6020: if ((*((real8 *) valeur_numerique)) > 0)
6021: {
6022: vinf = nextafter((*((real8 *) valeur_numerique)), 0);
6023: vsup = nextafter((*((real8 *) valeur_numerique)),
6024: (*((real8 *) valeur_numerique)) * 2);
6025: }
6026: else
6027: {
6028: vinf = nextafter((*((real8 *) valeur_numerique)),
6029: (*((real8 *) valeur_numerique)) * 2);
6030: vsup = nextafter((*((real8 *) valeur_numerique)), 0);
6031: }
6032:
6033: if (!((vinf <= ((real4) (*((real8 *) valeur_numerique)))) &&
6034: ((real4) ((*((real8 *) valeur_numerique)))
6035: <= vsup)))
6036: {
6037: (*s_etat_processus).erreur_execution =
6038: d_ex_representation;
6039: return(NULL);
6040: }
6041:
6042: if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
6043: {
6044: (*s_etat_processus).erreur_systeme =
6045: d_es_allocation_memoire;
6046: return(NULL);
6047: }
6048:
6049: eq4.r4 = (real4) (*((real8 *) valeur_numerique));
6050: (*longueur_conversion) = 5;
6051: chaine[0] = 0x12;
6052: chaine[1] = (eq4.i4 >> 24) & 0xFF;
6053: chaine[2] = (eq4.i4 >> 16) & 0xFF;
6054: chaine[3] = (eq4.i4 >> 8) & 0xFF;
6055: chaine[4] = eq4.i4 & 0xFF;
6056: break;
6057: }
6058:
6059: case 8:
6060: {
6061: union
6062: {
6063: real8 r8;
6064: integer8 i8;
6065: } eq8;
6066:
6067: if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
6068: {
6069: (*s_etat_processus).erreur_systeme =
6070: d_es_allocation_memoire;
6071: return(NULL);
6072: }
6073:
6074: eq8.r8 = (*((real8 *) valeur_numerique));
6075:
6076: (*longueur_conversion) = 9;
6077: chaine[0] = 0x13;
6078: chaine[1] = (eq8.i8 >> 56) & 0xFF;
6079: chaine[2] = (eq8.i8 >> 48) & 0xFF;
6080: chaine[3] = (eq8.i8 >> 40) & 0xFF;
6081: chaine[4] = (eq8.i8 >> 32) & 0xFF;
6082: chaine[5] = (eq8.i8 >> 24) & 0xFF;
6083: chaine[6] = (eq8.i8 >> 16) & 0xFF;
6084: chaine[7] = (eq8.i8 >> 8) & 0xFF;
6085: chaine[8] = eq8.i8 & 0xFF;
6086: break;
6087: }
6088:
6089: default :
6090: {
6091: (*s_etat_processus).erreur_execution =
6092: d_ex_erreur_format_fichier;
6093: return(NULL);
6094: }
6095: }
6096:
6097: break;
6098: }
6099:
6100: case 'C' :
6101: {
6102: switch(longueur)
6103: {
6104: case 8:
6105: {
6106: unsigned char *partie_reelle;
6107: unsigned char *partie_imaginaire;
6108:
6109: long limag;
6110: long lreel;
6111:
6112: if ((partie_reelle = formateur_fichier_binaire_nombre(
6113: s_etat_processus, &((*((complex16 *)
6114: valeur_numerique)).partie_reelle), 'R', 4, &lreel))
6115: == NULL)
6116: {
6117: return(NULL);
6118: }
6119:
6120: if ((partie_imaginaire = formateur_fichier_binaire_nombre(
6121: s_etat_processus, &((*((complex16 *)
6122: valeur_numerique)).partie_imaginaire), 'R', 4,
6123: &limag)) == NULL)
6124: {
6125: free(partie_reelle);
6126: return(NULL);
6127: }
6128:
6129: if ((chaine = malloc((lreel + limag - 1) *
6130: sizeof(unsigned char))) == NULL)
6131: {
6132: free(partie_reelle);
6133: free(partie_imaginaire);
6134:
6135: (*s_etat_processus).erreur_systeme =
6136: d_es_allocation_memoire;
6137: return(NULL);
6138: }
6139:
6140: chaine[0] = 0x18;
6141: memcpy(chaine + 1, partie_reelle + 1, lreel - 1);
6142: memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);
6143: (*longueur_conversion) = lreel + limag - 1;
6144:
6145: free(partie_reelle);
6146: free(partie_imaginaire);
6147: break;
6148: }
6149:
6150: case 16:
6151: {
6152: unsigned char *partie_reelle;
6153: unsigned char *partie_imaginaire;
6154:
6155: long limag;
6156: long lreel;
6157:
6158: if ((partie_reelle = formateur_fichier_binaire_nombre(
6159: s_etat_processus, &((*((complex16 *)
6160: valeur_numerique)).partie_reelle), 'R', 8, &lreel))
6161: == NULL)
6162: {
6163: return(NULL);
6164: }
6165:
6166: if ((partie_imaginaire = formateur_fichier_binaire_nombre(
6167: s_etat_processus, &((*((complex16 *)
6168: valeur_numerique)).partie_imaginaire), 'R', 8,
6169: &limag)) == NULL)
6170: {
6171: free(partie_reelle);
6172: return(NULL);
6173: }
6174:
6175: if ((chaine = malloc((lreel + limag - 1) *
6176: sizeof(unsigned char))) == NULL)
6177: {
6178: free(partie_reelle);
6179: free(partie_imaginaire);
6180:
6181: (*s_etat_processus).erreur_systeme =
6182: d_es_allocation_memoire;
6183: return(NULL);
6184: }
6185:
6186: chaine[0] = 0x19;
6187: memcpy(chaine + 1, partie_reelle + 1, lreel - 1);
6188: memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);
6189: (*longueur_conversion) = lreel + limag - 1;
6190:
6191: free(partie_reelle);
6192: free(partie_imaginaire);
6193: break;
6194: }
6195:
6196: default :
6197: {
6198: (*s_etat_processus).erreur_execution =
6199: d_ex_erreur_format_fichier;
6200: return(NULL);
6201: }
6202: }
6203:
6204: break;
6205: }
6206: }
6207:
6208: return(chaine);
6209: }
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to formateur_fichiers.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src