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