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