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