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