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