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