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