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