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