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