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