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