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: * 1111 XXXXX page 2
3110: * 1111 XXXXX 000000001 entier long
3111: * 1111 XXXXX 000000010 réel long
3112: * 1111 XXXXX 000000011 complexe long
3113: *
3114: * Les longueurs indiquées par le champ LL suivent l'en-tête :
3115: * 00 : integer*1
3116: * 01 : integer*2
3117: * 10 : integer*4
3118: * 11 : integer*8
3119: *
3120: * [En-tête][longueur_1][longueur_2][données]
3121: * le nombre de champs longueur dépendant des types d'enregistrement.
3122: *
3123: * Toutes les autres combinaisons sont invalides.
3124: */
3125:
3126: chaine = NULL;
3127: chaine_formatee = NULL;
3128: chaine_sauvegarde = NULL;
3129:
3130: if ((*s_objet).type == BIN)
3131: {
3132:
3133: /*
3134: --------------------------------------------------------------------------------
3135: Entier binaire en base 2, 8, 10 ou 16
3136: Poids fort 0000
3137: --------------------------------------------------------------------------------
3138: */
3139:
3140: if (format_sortie == 'N')
3141: {
3142: format_sortie = 'L';
3143: longueur_champ = 8;
3144: }
3145:
3146: if (format_sortie != 'L')
3147: {
3148: (*s_etat_processus).erreur_execution =
3149: d_ex_erreur_format_fichier;
3150: return(NULL);
3151: }
3152:
3153: if (longueur_champ < 8)
3154: {
3155: if ((*((logical8 *) (*s_objet).objet)) >=
3156: ((logical8) 1 << (8 * longueur_champ)))
3157: {
3158: (*s_etat_processus).erreur_execution =
3159: d_ex_representation;
3160: return(NULL);
3161: }
3162: }
3163:
3164: (*longueur_effective) = longueur_champ + 1;
3165:
3166: if ((chaine = malloc(((size_t) (*longueur_effective))
3167: * sizeof(unsigned char))) == NULL)
3168: {
3169: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3170: return(NULL);
3171: }
3172:
3173: chaine[0] = (unsigned char) longueur_champ;
3174:
3175: for(i = 1; i <= (*longueur_effective); i++)
3176: {
3177: chaine[i] = ((*((logical8 *) (*s_objet).objet)) >>
3178: (8 * (longueur_champ - i))) & 0xFF;
3179: }
3180: }
3181: else if ((*s_objet).type == CHN)
3182: {
3183:
3184: /*
3185: --------------------------------------------------------------------------------
3186: Chaîne de caractères
3187: Poids fort 1000 0XXX (longueur inférieure à 2**3-1
3188: 1000 10LL (autres longueurs)
3189: --------------------------------------------------------------------------------
3190: */
3191:
3192: if (format_sortie == 'N')
3193: {
3194: format_sortie = 'S';
3195: longueur_champ = -1;
3196: }
3197:
3198: if (format_sortie != 'S')
3199: {
3200: (*s_etat_processus).erreur_execution =
3201: d_ex_erreur_format_fichier;
3202: return(NULL);
3203: }
3204:
3205: longueur_reelle_chaine = longueur_chaine(s_etat_processus,
3206: (unsigned char *) (*s_objet).objet);
3207:
3208: if ((longueur_champ == -1) || (longueur_reelle_chaine <
3209: longueur_champ))
3210: {
3211: // Le format est CHARACTER*(*). On copie dans la sortie
3212: // la chaine en évaluant les caractères échappés.
3213:
3214: if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
3215: (*s_objet).objet, &longueur_chaine_traitee)) == NULL)
3216: {
3217: return(NULL);
3218: }
3219: }
3220: else
3221: {
3222: // Format de type CHARACTER*(n)
3223:
3224: if ((chaine_sauvegarde = formateur_flux(s_etat_processus,
3225: (unsigned char *) (*s_objet).objet,
3226: &longueur_chaine_traitee)) == NULL)
3227: {
3228: return(NULL);
3229: }
3230:
3231: if ((chaine = malloc(((size_t) longueur_champ)
3232: * sizeof(unsigned char))) == NULL)
3233: {
3234: (*s_etat_processus).erreur_systeme =
3235: d_es_allocation_memoire;
3236: return(NULL);
3237: }
3238:
3239: memcpy(chaine, chaine_sauvegarde, (size_t) longueur_champ);
3240: longueur_chaine_traitee = longueur_champ;
3241: free(chaine_sauvegarde);
3242: }
3243:
3244: chaine_sauvegarde = chaine;
3245:
3246: if (longueur_chaine_traitee < (1LL << 3))
3247: {
3248: if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 1)
3249: * sizeof(unsigned char))) == NULL)
3250: {
3251: (*s_etat_processus).erreur_systeme =
3252: d_es_allocation_memoire;
3253: return(NULL);
3254: }
3255:
3256: chaine[0] = (unsigned char) (0x80 |
3257: (longueur_chaine_traitee & 0x7));
3258:
3259: memcpy(chaine + 1, chaine_sauvegarde,
3260: (size_t) longueur_chaine_traitee);
3261: longueur_totale = longueur_chaine_traitee + 1;
3262: }
3263: else if (longueur_chaine_traitee < (1LL << 8))
3264: {
3265: if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 2)
3266: * sizeof(unsigned char))) == NULL)
3267: {
3268: (*s_etat_processus).erreur_systeme =
3269: d_es_allocation_memoire;
3270: return(NULL);
3271: }
3272:
3273: chaine[0] = (unsigned char) 0x88;
3274: chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF);
3275:
3276: memcpy(chaine + 2, chaine_sauvegarde,
3277: (size_t) longueur_chaine_traitee);
3278: longueur_totale = longueur_chaine_traitee + 2;
3279: }
3280: else if (longueur_chaine_traitee < (1LL << 16))
3281: {
3282: if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 3)
3283: * sizeof(unsigned char))) == NULL)
3284: {
3285: (*s_etat_processus).erreur_systeme =
3286: d_es_allocation_memoire;
3287: return(NULL);
3288: }
3289:
3290: chaine[0] = (unsigned char) 0x89;
3291: chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8)
3292: & 0xFF);
3293: chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF);
3294:
3295: memcpy(chaine + 3, chaine_sauvegarde,
3296: (size_t) longueur_chaine_traitee);
3297: longueur_totale = longueur_chaine_traitee + 3;
3298: }
3299: else if (longueur_chaine_traitee < (1LL << 32))
3300: {
3301: if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 5)
3302: * sizeof(unsigned char))) == NULL)
3303: {
3304: (*s_etat_processus).erreur_systeme =
3305: d_es_allocation_memoire;
3306: return(NULL);
3307: }
3308:
3309: chaine[0] = (unsigned char) 0x8A;
3310: chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24)
3311: & 0xFF);
3312: chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 16)
3313: & 0xFF);
3314: chaine[3] = (unsigned char) ((longueur_chaine_traitee >> 8)
3315: & 0xFF);
3316: chaine[4] = (unsigned char) (longueur_chaine_traitee & 0xFF);
3317:
3318: memcpy(chaine + 5, chaine_sauvegarde,
3319: (size_t) longueur_chaine_traitee);
3320: longueur_totale = longueur_chaine_traitee + 5;
3321: }
3322: else
3323: {
3324: if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 9)
3325: * sizeof(unsigned char))) == NULL)
3326: {
3327: (*s_etat_processus).erreur_systeme =
3328: d_es_allocation_memoire;
3329: return(NULL);
3330: }
3331:
3332: chaine[0] = (unsigned char) 0x8B;
3333: chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 56)
3334: & 0xFF);
3335: chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 48)
3336: & 0xFF);
3337: chaine[3] = (unsigned char) ((longueur_chaine_traitee >> 40)
3338: & 0xFF);
3339: chaine[4] = (unsigned char) ((longueur_chaine_traitee >> 32)
3340: & 0xFF);
3341: chaine[5] = (unsigned char) ((longueur_chaine_traitee >> 24)
3342: & 0xFF);
3343: chaine[6] = (unsigned char) ((longueur_chaine_traitee >> 16)
3344: & 0xFF);
3345: chaine[7] = (unsigned char) ((longueur_chaine_traitee >> 8)
3346: & 0xFF);
3347: chaine[8] = (unsigned char) (longueur_chaine_traitee & 0xFF);
3348:
3349: memcpy(chaine + 9, chaine_sauvegarde,
3350: (size_t) longueur_chaine_traitee);
3351: longueur_totale = longueur_chaine_traitee + 9;
3352: }
3353:
3354: (*longueur_effective) = longueur_totale;
3355: }
3356: else if ((*s_objet).type == CPL)
3357: {
3358:
3359: /*
3360: --------------------------------------------------------------------------------
3361: Complexe
3362: Poids fort 0001 10
3363: --------------------------------------------------------------------------------
3364: */
3365:
3366: if (format_sortie == 'N')
3367: {
3368: format_sortie = 'C';
3369: longueur = 8;
3370: }
3371:
3372: if (format_sortie != 'C')
3373: {
3374: (*s_etat_processus).erreur_execution =
3375: d_ex_erreur_format_fichier;
3376: return(NULL);
3377: }
3378:
3379: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
3380: (*s_objet).objet, 'C', 'C', longueur, longueur_effective))
3381: == NULL)
3382: {
3383: return(NULL);
3384: }
3385: }
3386: else if ((*s_objet).type == INT)
3387: {
3388:
3389: /*
3390: --------------------------------------------------------------------------------
3391: Entier
3392: Poids fort 0001 00
3393: --------------------------------------------------------------------------------
3394: */
3395:
3396: if (format_sortie == 'N')
3397: {
3398: format_sortie = 'I';
3399: longueur = 8;
3400: }
3401:
3402: if ((format_sortie != 'I') && (format_sortie != 'R')
3403: && (format_sortie != 'C'))
3404: {
3405: (*s_etat_processus).erreur_execution =
3406: d_ex_erreur_format_fichier;
3407: return(NULL);
3408: }
3409:
3410: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
3411: (*s_objet).objet, 'I', format_sortie, longueur,
3412: longueur_effective)) == NULL)
3413: {
3414: return(NULL);
3415: }
3416: }
3417: else if ((*s_objet).type == FCT)
3418: {
3419:
3420: /*
3421: --------------------------------------------------------------------------------
3422: Fonction
3423: Poids fort 1110
3424: --------------------------------------------------------------------------------
3425: */
3426:
3427: if (format_sortie != 'N')
3428: {
3429: (*s_etat_processus).erreur_execution =
3430: d_ex_erreur_format_fichier;
3431: return(NULL);
3432: }
3433:
3434: longueur_fonction = (integer8) strlen((*((struct_fonction *)
3435: (*s_objet).objet)).nom_fonction);
3436:
3437: if (longueur_fonction < (1LL << 3))
3438: {
3439: if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 8)
3440: * sizeof(unsigned char)))== NULL)
3441: {
3442: (*s_etat_processus).erreur_systeme =
3443: d_es_allocation_memoire;
3444: return(NULL);
3445: }
3446:
3447: chaine[0] = (unsigned char) (0xE0 | (longueur_fonction & 0x7));
3448:
3449: strcpy(chaine + 1, (*((struct_fonction *) (*s_objet).objet))
3450: .nom_fonction);
3451: (*longueur_effective) = 1 + longueur_fonction + 8;
3452: }
3453: else if (longueur_fonction < (1LL << 8))
3454: {
3455: if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 8)
3456: * sizeof(unsigned char)))== NULL)
3457: {
3458: (*s_etat_processus).erreur_systeme =
3459: d_es_allocation_memoire;
3460: return(NULL);
3461: }
3462:
3463: chaine[0] = (unsigned char) (0xE0 | 0x08);
3464: chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
3465:
3466: strcpy(chaine + 2, (*((struct_fonction *) (*s_objet).objet))
3467: .nom_fonction);
3468: (*longueur_effective) = 2 + longueur_fonction + 8;
3469: }
3470: else if (longueur_fonction < (1LL << 16))
3471: {
3472: if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 8)
3473: * sizeof(unsigned char)))== NULL)
3474: {
3475: (*s_etat_processus).erreur_systeme =
3476: d_es_allocation_memoire;
3477: return(NULL);
3478: }
3479:
3480: chaine[0] = (unsigned char ) (0xE0 | 0x09);
3481: chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
3482: chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
3483:
3484: strcpy(chaine + 3, (*((struct_fonction *) (*s_objet).objet))
3485: .nom_fonction);
3486: (*longueur_effective) = 3 + longueur_fonction + 9;
3487: }
3488: else if (longueur_fonction < (1LL << 32))
3489: {
3490: if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 8)
3491: * sizeof(unsigned char)))== NULL)
3492: {
3493: (*s_etat_processus).erreur_systeme =
3494: d_es_allocation_memoire;
3495: return(NULL);
3496: }
3497:
3498: chaine[0] = (unsigned char) (0xE0 | 0x0A);
3499: chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
3500: chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
3501: chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
3502: chaine[4] = (unsigned char) (longueur_fonction & 0xFF);
3503:
3504: strcpy(chaine + 5, (*((struct_fonction *) (*s_objet).objet))
3505: .nom_fonction);
3506: (*longueur_effective) = 5 + longueur_fonction + 8;
3507: }
3508: else
3509: {
3510: if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 8)
3511: * sizeof(unsigned char)))== NULL)
3512: {
3513: (*s_etat_processus).erreur_systeme =
3514: d_es_allocation_memoire;
3515: return(NULL);
3516: }
3517:
3518: chaine[0] = (unsigned char) (0xE0 | 0x0B);
3519: chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
3520: chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
3521: chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
3522: chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF);
3523: chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
3524: chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
3525: chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
3526: chaine[8] = (unsigned char) (longueur_fonction & 0xFF);
3527:
3528: strcpy(chaine + 9, (*((struct_fonction *) (*s_objet).objet))
3529: .nom_fonction);
3530: (*longueur_effective) = 9 + longueur_fonction + 8;
3531: }
3532:
3533: for(i = 1; i <= 8; i++)
3534: {
3535: chaine[(*longueur_effective) - i] = (unsigned char)
3536: (((*((struct_fonction *) (*s_objet).objet))
3537: .nombre_arguments >> ((8 - i) * 8)) & 0xFF);
3538: }
3539: }
3540: else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)
3541: || ((*s_objet).type == RPN))
3542: {
3543:
3544: /*
3545: --------------------------------------------------------------------------------
3546: Liste
3547: Poids fort 0100
3548:
3549: Expression algébrique
3550: Poids fort 0111
3551:
3552: Définition
3553: Poids fort 0110
3554: --------------------------------------------------------------------------------
3555: */
3556:
3557: chaine = malloc(sizeof(unsigned char));
3558:
3559: if (chaine == NULL)
3560: {
3561: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3562: return(NULL);
3563: }
3564:
3565: if ((*s_objet).type == LST)
3566: {
3567: type_binaire = 0x40;
3568: }
3569: else if ((*s_objet).type == RPN)
3570: {
3571: type_binaire = 0x60;
3572: }
3573: else // ALG
3574: {
3575: type_binaire = 0x70;
3576: }
3577:
3578: // Calcul de la longueur de la liste.
3579:
3580: longueur_liste = 0;
3581: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
3582:
3583: while(l_element_courant != NULL)
3584: {
3585: l_element_courant = (*l_element_courant).suivant;
3586: longueur_liste++;
3587: }
3588:
3589: if (longueur_liste < (1LL << 3))
3590: {
3591: chaine[0] = (unsigned char) (type_binaire |
3592: (longueur_liste & 0x7));
3593: }
3594: else if (longueur_liste < (1LL << 8))
3595: {
3596: chaine[0] = (unsigned char) (type_binaire | 0x08);
3597: }
3598: else if (longueur_liste < (1LL << 16))
3599: {
3600: chaine[0] = (unsigned char ) (type_binaire | 0x09);
3601: }
3602: else if (longueur_liste < (1LL << 32))
3603: {
3604: chaine[0] = (unsigned char) (type_binaire | 0x0A);
3605: }
3606: else
3607: {
3608: chaine[0] = (unsigned char) (type_binaire | 0x0B);
3609: }
3610:
3611: longueur_totale = 1;
3612:
3613: if ((chaine[0] & 0x8) != 0)
3614: {
3615: switch(chaine[0] & 0x03)
3616: {
3617: case 0x00 :
3618: {
3619: longueur_totale += 1;
3620:
3621: if ((chaine = realloc(chaine,
3622: ((size_t) longueur_totale) *
3623: sizeof(unsigned char))) == NULL)
3624: {
3625: (*s_etat_processus).erreur_systeme =
3626: d_es_allocation_memoire;
3627: return(NULL);
3628: }
3629:
3630: chaine[longueur_totale - 1] =
3631: (unsigned char) (longueur_liste & 0xFF);
3632: break;
3633: }
3634:
3635: case 0x01 :
3636: {
3637: longueur_totale += 2;
3638:
3639: if ((chaine = realloc(chaine,
3640: ((size_t) longueur_totale) *
3641: sizeof(unsigned char))) == NULL)
3642: {
3643: (*s_etat_processus).erreur_systeme =
3644: d_es_allocation_memoire;
3645: return(NULL);
3646: }
3647:
3648: chaine[longueur_totale - 2] =
3649: (unsigned char) ((longueur_liste >> 8) & 0xFF);
3650: chaine[longueur_totale - 1] =
3651: (unsigned char) (longueur_liste & 0xFF);
3652: break;
3653: }
3654:
3655: case 0x02 :
3656: {
3657: longueur_totale += 4;
3658:
3659: if ((chaine = realloc(chaine,
3660: ((size_t) longueur_totale) *
3661: sizeof(unsigned char))) == NULL)
3662: {
3663: (*s_etat_processus).erreur_systeme =
3664: d_es_allocation_memoire;
3665: return(NULL);
3666: }
3667:
3668: chaine[longueur_totale - 4] =
3669: (unsigned char) ((longueur_liste >> 24) & 0xFF);
3670: chaine[longueur_totale - 3] =
3671: (unsigned char) ((longueur_liste >> 16) & 0xFF);
3672: chaine[longueur_totale - 2] =
3673: (unsigned char) ((longueur_liste >> 8) & 0xFF);
3674: chaine[longueur_totale - 1] =
3675: (unsigned char) (longueur_liste & 0xFF);
3676: break;
3677: }
3678:
3679: case 0x03 :
3680: {
3681: longueur_totale += 8;
3682:
3683: if ((chaine = realloc(chaine,
3684: ((size_t) longueur_totale) *
3685: sizeof(unsigned char))) == NULL)
3686: {
3687: (*s_etat_processus).erreur_systeme =
3688: d_es_allocation_memoire;
3689: return(NULL);
3690: }
3691:
3692: chaine[longueur_totale - 8] =
3693: (unsigned char) ((longueur_liste >> 56) & 0xFF);
3694: chaine[longueur_totale - 7] =
3695: (unsigned char) ((longueur_liste >> 48) & 0xFF);
3696: chaine[longueur_totale - 6] =
3697: (unsigned char) ((longueur_liste >> 40) & 0xFF);
3698: chaine[longueur_totale - 5] =
3699: (unsigned char) ((longueur_liste >> 32) & 0xFF);
3700: chaine[longueur_totale - 4] =
3701: (unsigned char) ((longueur_liste >> 24) & 0xFF);
3702: chaine[longueur_totale - 3] =
3703: (unsigned char) ((longueur_liste >> 16) & 0xFF);
3704: chaine[longueur_totale - 2] =
3705: (unsigned char) ((longueur_liste >> 8) & 0xFF);
3706: chaine[longueur_totale - 1] =
3707: (unsigned char) (longueur_liste & 0xFF);
3708: break;
3709: }
3710:
3711: default :
3712: {
3713: BUG(1, printf("Internal format error\n"));
3714: }
3715: }
3716: }
3717:
3718: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
3719: l_element_courant_format = (struct_liste_chainee *)
3720: (*s_format).objet;
3721: nombre_elements = 0;
3722:
3723: while((l_element_courant != NULL) &&
3724: (l_element_courant_format != NULL))
3725: {
3726: if ((((*(*l_element_courant_format).donnee).type == LST)
3727: && ((*(*l_element_courant).donnee).type == LST)) ||
3728: (((*(*l_element_courant_format).donnee).type == TBL)
3729: && ((*(*l_element_courant).donnee).type == TBL)))
3730: {
3731: if (format_sortie != 'N')
3732: {
3733: if ((chaine_formatee = formateur_fichier(
3734: s_etat_processus,
3735: (*l_element_courant).donnee,
3736: (*l_element_courant_format).donnee,
3737: 0, 0, ' ', 'U', longueur_effective, recursivite,
3738: export_fichier)) == NULL)
3739: {
3740: free(chaine);
3741: return(NULL);
3742: }
3743: }
3744: else
3745: {
3746: if ((chaine_formatee = formateur_fichier(
3747: s_etat_processus,
3748: (*l_element_courant).donnee,
3749: (*l_element_courant_format).donnee,
3750: 0, 0, 'N', 'U', longueur_effective, recursivite,
3751: export_fichier)) == NULL)
3752: {
3753: free(chaine);
3754: return(NULL);
3755: }
3756: }
3757:
3758: if ((chaine = realloc(chaine, ((size_t) (longueur_totale +
3759: (*longueur_effective))) * sizeof(unsigned char)))
3760: == NULL)
3761: {
3762: (*s_etat_processus).erreur_systeme =
3763: d_es_allocation_memoire;
3764: return(NULL);
3765: }
3766:
3767: memcpy(&(chaine[longueur_totale]), chaine_formatee,
3768: (size_t) (*longueur_effective));
3769: longueur_totale += (*longueur_effective);
3770: free(chaine_formatee);
3771: }
3772: else if ((*(*l_element_courant_format).donnee).type != CHN)
3773: {
3774: free(chaine);
3775:
3776: (*s_etat_processus).erreur_execution =
3777: d_ex_erreur_format_fichier;
3778: return(NULL);
3779: }
3780: else
3781: {
3782: format_degenere = d_faux;
3783:
3784: if ((format_chaine = conversion_majuscule(
3785: s_etat_processus, (unsigned char *)
3786: (*(*l_element_courant_format).donnee).objet))
3787: == NULL)
3788: {
3789: (*s_etat_processus).erreur_systeme =
3790: d_es_allocation_memoire;
3791: return(NULL);
3792: }
3793:
3794: if (strncmp("INTEGER*", format_chaine, 8) == 0)
3795: {
3796: format_sortie = 'I';
3797: position_1 = 8;
3798: }
3799: else if (strncmp("LOGICAL*", format_chaine, 8) == 0)
3800: {
3801: format_sortie = 'L';
3802: position_1 = 8;
3803: }
3804: else if (strncmp("REAL*", format_chaine, 5) == 0)
3805: {
3806: format_sortie = 'R';
3807: position_1 = 5;
3808: }
3809: else if (strncmp("COMPLEX*", format_chaine, 8) == 0)
3810: {
3811: format_sortie = 'C';
3812: position_1 = 8;
3813: }
3814: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
3815: {
3816: format_sortie = 'S';
3817: position_1 = 10;
3818: format_degenere = d_vrai;
3819: }
3820: else if (strcmp("NATIVE*(*)", format_chaine) == 0)
3821: {
3822: format_sortie = 'N';
3823: position_1 = 7;
3824: format_degenere = d_vrai;
3825: }
3826: else
3827: {
3828: free(chaine);
3829: free(format_chaine);
3830:
3831: (*s_etat_processus).erreur_execution =
3832: d_ex_erreur_format_fichier;
3833: return(NULL);
3834: }
3835:
3836: if (format_chaine[position_1] == d_code_fin_chaine)
3837: {
3838: free(chaine);
3839: free(format_chaine);
3840:
3841: (*s_etat_processus).erreur_execution =
3842: d_ex_erreur_format_fichier;
3843: return(NULL);
3844: }
3845:
3846: if (strcmp(&(format_chaine[position_1]), "(*)") != 0)
3847: {
3848: if (sscanf(&(format_chaine[position_1]), "%lld",
3849: &longueur) != 1)
3850: {
3851: free(chaine);
3852: free(format_chaine);
3853:
3854: (*s_etat_processus).erreur_execution =
3855: d_ex_erreur_format_fichier;
3856: return(NULL);
3857: }
3858:
3859: longueur_champ = longueur;
3860: }
3861: else
3862: {
3863: longueur_champ = -1;
3864: longueur = -1;
3865: }
3866:
3867: free(format_chaine);
3868:
3869: // Si le format_sortie vaut 'N', on remplace le format par
3870: // { "native*(*)" }. L'intérêt est de pouvoir traiter une
3871: // liste par un format "native*(*)".
3872:
3873: if ((format_sortie == 'N') && ((*(*l_element_courant)
3874: .donnee).type == LST))
3875: {
3876: if ((s_format_tmp = allocation(s_etat_processus, LST))
3877: == NULL)
3878: {
3879: return(NULL);
3880: }
3881:
3882: if (((*s_format_tmp).objet = allocation_maillon(
3883: s_etat_processus)) == NULL)
3884: {
3885: return(NULL);
3886: }
3887:
3888: (*((struct_liste_chainee *) (*s_format_tmp).objet))
3889: .suivant = NULL;
3890:
3891: if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
3892: .donnee = allocation(s_etat_processus, CHN))
3893: == NULL)
3894: {
3895: return(NULL);
3896: }
3897:
3898: if (((*(*((struct_liste_chainee *) (*s_format_tmp)
3899: .objet)).donnee).objet = malloc(11 *
3900: sizeof(unsigned char))) == NULL)
3901: {
3902: (*s_etat_processus).erreur_systeme =
3903: d_es_allocation_memoire;
3904: return(NULL);
3905: }
3906:
3907: strcpy((unsigned char *) (*(*((struct_liste_chainee *)
3908: (*s_format_tmp).objet)).donnee).objet,
3909: "native*(*)");
3910: }
3911: else
3912: {
3913: if ((s_format_tmp = copie_objet(s_etat_processus,
3914: s_format, 'P')) == NULL)
3915: {
3916: return(NULL);
3917: }
3918: }
3919:
3920: if ((chaine_formatee = formateur_fichier(s_etat_processus,
3921: (*l_element_courant).donnee, s_format_tmp,
3922: longueur, longueur_champ, format_sortie, type,
3923: longueur_effective, recursivite, export_fichier))
3924: == NULL)
3925: {
3926: liberation(s_etat_processus, s_format_tmp);
3927: free(chaine);
3928: return(NULL);
3929: }
3930:
3931: liberation(s_etat_processus, s_format_tmp);
3932:
3933: if ((chaine = realloc(chaine,
3934: ((size_t) (longueur_totale + (*longueur_effective)))
3935: * sizeof(unsigned char))) == NULL)
3936: {
3937: (*s_etat_processus).erreur_systeme =
3938: d_es_allocation_memoire;
3939: return(NULL);
3940: }
3941:
3942: memcpy(&(chaine[longueur_totale]), chaine_formatee,
3943: (size_t) (*longueur_effective));
3944: longueur_totale += (*longueur_effective);
3945: free(chaine_formatee);
3946: }
3947:
3948: if (format_sortie != 'N')
3949: {
3950: l_element_courant_format =
3951: (*l_element_courant_format).suivant;
3952: }
3953:
3954: nombre_elements++;
3955: l_element_courant = (*l_element_courant).suivant;
3956: }
3957:
3958: if (format_sortie != 'N')
3959: {
3960: if ((l_element_courant != NULL) ||
3961: (l_element_courant_format != NULL))
3962: {
3963: free(chaine);
3964:
3965: (*s_etat_processus).erreur_execution =
3966: d_ex_erreur_format_fichier;
3967: return(NULL);
3968: }
3969: }
3970:
3971: (*longueur_effective) = longueur_totale;
3972: }
3973: else if ((*s_objet).type == TBL)
3974: {
3975:
3976: /*
3977: --------------------------------------------------------------------------------
3978: Table
3979: Bits de poids fort : 1001
3980: --------------------------------------------------------------------------------
3981: */
3982:
3983: chaine = malloc(sizeof(unsigned char));
3984:
3985: if (chaine == NULL)
3986: {
3987: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3988: return(NULL);
3989: }
3990:
3991: type_binaire = 0x90;
3992: longueur_liste = (*((struct_tableau *) (*s_objet).objet))
3993: .nombre_elements;
3994:
3995: if (longueur_liste < (1LL << 3))
3996: {
3997: chaine[0] = (unsigned char) (type_binaire |
3998: (longueur_liste & 0x7));
3999: }
4000: else if (longueur_liste < (1LL << 8))
4001: {
4002: chaine[0] = (unsigned char) (type_binaire | 0x08);
4003: }
4004: else if (longueur_liste < (1LL << 16))
4005: {
4006: chaine[0] = (unsigned char ) (type_binaire | 0x09);
4007: }
4008: else if (longueur_liste < (1LL << 32))
4009: {
4010: chaine[0] = (unsigned char) (type_binaire | 0x0A);
4011: }
4012: else
4013: {
4014: chaine[0] = (unsigned char) (type_binaire | 0x0B);
4015: }
4016:
4017: longueur_totale = 1;
4018:
4019: if ((chaine[0] & 0x8) != 0)
4020: { // Longueur sur un entier distinct de l'en-tête
4021: switch(chaine[0] & 0x03)
4022: {
4023: case 0x00 :
4024: {
4025: longueur_totale += 1;
4026:
4027: if ((chaine = realloc(chaine,
4028: ((size_t) longueur_totale) *
4029: sizeof(unsigned char))) == NULL)
4030: {
4031: (*s_etat_processus).erreur_systeme =
4032: d_es_allocation_memoire;
4033: return(NULL);
4034: }
4035:
4036: chaine[longueur_totale - 1] =
4037: (unsigned char) (longueur_liste & 0xFF);
4038: break;
4039: }
4040:
4041: case 0x01 :
4042: {
4043: longueur_totale += 2;
4044:
4045: if ((chaine = realloc(chaine,
4046: ((size_t) longueur_totale) *
4047: sizeof(unsigned char))) == NULL)
4048: {
4049: (*s_etat_processus).erreur_systeme =
4050: d_es_allocation_memoire;
4051: return(NULL);
4052: }
4053:
4054: chaine[longueur_totale - 2] =
4055: (unsigned char) ((longueur_liste >> 8) & 0xFF);
4056: chaine[longueur_totale - 1] =
4057: (unsigned char) (longueur_liste & 0xFF);
4058: break;
4059: }
4060:
4061: case 0x02 :
4062: {
4063: longueur_totale += 4;
4064:
4065: if ((chaine = realloc(chaine,
4066: ((size_t) longueur_totale) *
4067: sizeof(unsigned char))) == NULL)
4068: {
4069: (*s_etat_processus).erreur_systeme =
4070: d_es_allocation_memoire;
4071: return(NULL);
4072: }
4073:
4074: chaine[longueur_totale - 4] =
4075: (unsigned char) ((longueur_liste >> 24) & 0xFF);
4076: chaine[longueur_totale - 3] =
4077: (unsigned char) ((longueur_liste >> 16) & 0xFF);
4078: chaine[longueur_totale - 2] =
4079: (unsigned char) ((longueur_liste >> 8) & 0xFF);
4080: chaine[longueur_totale - 1] =
4081: (unsigned char) (longueur_liste & 0xFF);
4082: break;
4083: }
4084:
4085: case 0x03 :
4086: {
4087: longueur_totale += 8;
4088:
4089: if ((chaine = realloc(chaine,
4090: ((size_t) longueur_totale) *
4091: sizeof(unsigned char))) == NULL)
4092: {
4093: (*s_etat_processus).erreur_systeme =
4094: d_es_allocation_memoire;
4095: return(NULL);
4096: }
4097:
4098: chaine[longueur_totale - 8] =
4099: (unsigned char) ((longueur_liste >> 56) & 0xFF);
4100: chaine[longueur_totale - 7] =
4101: (unsigned char) ((longueur_liste >> 48) & 0xFF);
4102: chaine[longueur_totale - 6] =
4103: (unsigned char) ((longueur_liste >> 40) & 0xFF);
4104: chaine[longueur_totale - 5] =
4105: (unsigned char) ((longueur_liste >> 32) & 0xFF);
4106: chaine[longueur_totale - 4] =
4107: (unsigned char) ((longueur_liste >> 24) & 0xFF);
4108: chaine[longueur_totale - 3] =
4109: (unsigned char) ((longueur_liste >> 16) & 0xFF);
4110: chaine[longueur_totale - 2] =
4111: (unsigned char) ((longueur_liste >> 8) & 0xFF);
4112: chaine[longueur_totale - 1] =
4113: (unsigned char) (longueur_liste & 0xFF);
4114: break;
4115: }
4116:
4117: default :
4118: {
4119: BUG(1, printf("Internal format error\n"));
4120: }
4121: }
4122: }
4123:
4124: if ((*s_format).type == CHN)
4125: {
4126: if ((format_chaine = conversion_majuscule(
4127: s_etat_processus, (unsigned char *)
4128: (*s_format).objet)) == NULL)
4129: {
4130: (*s_etat_processus).erreur_systeme =
4131: d_es_allocation_memoire;
4132: return(NULL);
4133: }
4134:
4135: if (strncmp("INTEGER*", format_chaine, 8) == 0)
4136: {
4137: format_sortie = 'I';
4138: position_1 = 8;
4139: }
4140: else if (strncmp("LOGICAL*", format_chaine, 8) == 0)
4141: {
4142: format_sortie = 'L';
4143: position_1 = 8;
4144: }
4145: else if (strncmp("REAL*", format_chaine, 5) == 0)
4146: {
4147: format_sortie = 'R';
4148: position_1 = 5;
4149: }
4150: else if (strncmp("COMPLEX*", format_chaine, 8) == 0)
4151: {
4152: format_sortie = 'C';
4153: position_1 = 8;
4154: }
4155: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
4156: {
4157: format_sortie = 'S';
4158: position_1 = 10;
4159: format_degenere = d_vrai;
4160: }
4161: else if (strcmp("NATIVE*(*)", format_chaine) == 0)
4162: {
4163: format_sortie = 'N';
4164: position_1 = 7;
4165: format_degenere = d_vrai;
4166: }
4167: else
4168: {
4169: free(chaine);
4170: free(format_chaine);
4171:
4172: (*s_etat_processus).erreur_execution =
4173: d_ex_erreur_format_fichier;
4174: return(NULL);
4175: }
4176:
4177: if (format_chaine[position_1] == d_code_fin_chaine)
4178: {
4179: free(chaine);
4180: free(format_chaine);
4181:
4182: (*s_etat_processus).erreur_execution =
4183: d_ex_erreur_format_fichier;
4184: return(NULL);
4185: }
4186:
4187: if (strcmp(&(format_chaine[position_1]), "(*)") != 0)
4188: {
4189: if (sscanf(&(format_chaine[position_1]), "%lld",
4190: &longueur) != 1)
4191: {
4192: free(chaine);
4193: free(format_chaine);
4194:
4195: (*s_etat_processus).erreur_execution =
4196: d_ex_erreur_format_fichier;
4197: return(NULL);
4198: }
4199:
4200: longueur_champ = longueur;
4201: }
4202: else
4203: {
4204: longueur_champ = -1;
4205: longueur = -1;
4206: }
4207:
4208: free(format_chaine);
4209:
4210: for(i = 0; i < longueur_liste; i++)
4211: {
4212: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4213: (*((struct_tableau *) (*s_objet).objet))
4214: .elements[i], (*s_format).objet,
4215: longueur, longueur_champ,
4216: format_sortie, type, longueur_effective,
4217: recursivite, export_fichier)) == NULL)
4218: {
4219: free(chaine);
4220: return(NULL);
4221: }
4222: }
4223: }
4224: else if ((*s_format).type == TBL)
4225: {
4226: }
4227: else
4228: {
4229: free(chaine);
4230:
4231: (*s_etat_processus).erreur_execution =
4232: d_ex_erreur_format_fichier;
4233: return(NULL);
4234: }
4235:
4236: // A FIXER
4237:
4238:
4239: /*
4240: while((l_element_courant != NULL) &&
4241: (l_element_courant_format != NULL))
4242: {
4243: if ((((*(*l_element_courant_format).donnee).type == LST)
4244: && ((*(*l_element_courant).donnee).type == LST)) ||
4245: (((*(*l_element_courant_format).donnee).type == TBL)
4246: && ((*(*l_element_courant).donnee).type == TBL)))
4247: {
4248: if (format_sortie != 'N')
4249: {
4250: if ((chaine_formatee = formateur_fichier(
4251: s_etat_processus,
4252: (*l_element_courant).donnee,
4253: (*l_element_courant_format).donnee,
4254: 0, 0, ' ', 'U', longueur_effective, recursivite,
4255: export_fichier)) == NULL)
4256: {
4257: return(NULL);
4258: }
4259: }
4260: else
4261: {
4262: if ((chaine_formatee = formateur_fichier(
4263: s_etat_processus,
4264: (*l_element_courant).donnee,
4265: (*l_element_courant_format).donnee,
4266: 0, 0, 'N', 'U', longueur_effective, recursivite,
4267: export_fichier)) == NULL)
4268: {
4269: return(NULL);
4270: }
4271: }
4272:
4273: if ((chaine = realloc(chaine, ((size_t) (longueur_totale +
4274: (*longueur_effective))) * sizeof(unsigned char)))
4275: == NULL)
4276: {
4277: (*s_etat_processus).erreur_systeme =
4278: d_es_allocation_memoire;
4279: return(NULL);
4280: }
4281:
4282: memcpy(&(chaine[longueur_totale]), chaine_formatee,
4283: (size_t) (*longueur_effective));
4284: longueur_totale += (*longueur_effective);
4285: free(chaine_formatee);
4286: }
4287: else if ((*(*l_element_courant_format).donnee).type != CHN)
4288: {
4289: free(chaine);
4290:
4291: (*s_etat_processus).erreur_execution =
4292: d_ex_erreur_format_fichier;
4293: return(NULL);
4294: }
4295: else
4296: {
4297: if ((format_chaine = conversion_majuscule(
4298: s_etat_processus, (unsigned char *)
4299: (*(*l_element_courant_format).donnee).objet))
4300: == NULL)
4301: {
4302: (*s_etat_processus).erreur_systeme =
4303: d_es_allocation_memoire;
4304: return(NULL);
4305: }
4306:
4307: if (strncmp("INTEGER*", format_chaine, 8) == 0)
4308: {
4309: format_sortie = 'I';
4310: position_1 = 8;
4311: }
4312: else if (strncmp("LOGICAL*", format_chaine, 8) == 0)
4313: {
4314: format_sortie = 'L';
4315: position_1 = 8;
4316: }
4317: else if (strncmp("REAL*", format_chaine, 5) == 0)
4318: {
4319: format_sortie = 'R';
4320: position_1 = 5;
4321: }
4322: else if (strncmp("COMPLEX*", format_chaine, 8) == 0)
4323: {
4324: format_sortie = 'C';
4325: position_1 = 8;
4326: }
4327: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
4328: {
4329: format_sortie = 'S';
4330: position_1 = 10;
4331: format_degenere = d_vrai;
4332: }
4333: else if (strcmp("NATIVE*(*)", format_chaine) == 0)
4334: {
4335: format_sortie = 'N';
4336: position_1 = 7;
4337: format_degenere = d_vrai;
4338: }
4339: else
4340: {
4341: free(chaine);
4342: free(format_chaine);
4343:
4344: (*s_etat_processus).erreur_execution =
4345: d_ex_erreur_format_fichier;
4346: return(NULL);
4347: }
4348:
4349: if (format_chaine[position_1] == d_code_fin_chaine)
4350: {
4351: free(chaine);
4352: free(format_chaine);
4353:
4354: (*s_etat_processus).erreur_execution =
4355: d_ex_erreur_format_fichier;
4356: return(NULL);
4357: }
4358:
4359: if (strcmp(&(format_chaine[position_1]), "(*)") != 0)
4360: {
4361: if (sscanf(&(format_chaine[position_1]), "%lld",
4362: &longueur) != 1)
4363: {
4364: free(chaine);
4365: free(format_chaine);
4366:
4367: (*s_etat_processus).erreur_execution =
4368: d_ex_erreur_format_fichier;
4369: return(NULL);
4370: }
4371:
4372: longueur_champ = longueur;
4373: }
4374: else
4375: {
4376: longueur_champ = -1;
4377: longueur = -1;
4378: }
4379:
4380: free(format_chaine);
4381:
4382: // Si le format_sortie vaut 'N', on remplace le format par
4383: // { "native*(*)" }. L'intérêt est de pouvoir traiter une
4384: // liste par un format "native*(*)".
4385:
4386: if ((format_sortie == 'N') && ((*(*l_element_courant)
4387: .donnee).type == LST))
4388: {
4389: if ((s_format_tmp = allocation(s_etat_processus, LST))
4390: == NULL)
4391: {
4392: return(NULL);
4393: }
4394:
4395: if (((*s_format_tmp).objet = allocation_maillon(
4396: s_etat_processus)) == NULL)
4397: {
4398: return(NULL);
4399: }
4400:
4401: (*((struct_liste_chainee *) (*s_format_tmp).objet))
4402: .suivant = NULL;
4403:
4404: if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
4405: .donnee = allocation(s_etat_processus, CHN))
4406: == NULL)
4407: {
4408: return(NULL);
4409: }
4410:
4411: if (((*(*((struct_liste_chainee *) (*s_format_tmp)
4412: .objet)).donnee).objet = malloc(11 *
4413: sizeof(unsigned char))) == NULL)
4414: {
4415: (*s_etat_processus).erreur_systeme =
4416: d_es_allocation_memoire;
4417: return(NULL);
4418: }
4419:
4420: strcpy((unsigned char *) (*(*((struct_liste_chainee *)
4421: (*s_format_tmp).objet)).donnee).objet,
4422: "native*(*)");
4423: }
4424: else
4425: {
4426: if ((s_format_tmp = copie_objet(s_etat_processus,
4427: s_format, 'P')) == NULL)
4428: {
4429: return(NULL);
4430: }
4431: }
4432:
4433: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4434: (*l_element_courant).donnee, s_format_tmp,
4435: longueur, longueur_champ, format_sortie, type,
4436: longueur_effective, recursivite, export_fichier))
4437: == NULL)
4438: {
4439: liberation(s_etat_processus, s_format_tmp);
4440: free(chaine);
4441: return(NULL);
4442: }
4443:
4444: liberation(s_etat_processus, s_format_tmp);
4445:
4446: if ((chaine = realloc(chaine,
4447: ((size_t) (longueur_totale + (*longueur_effective)))
4448: * sizeof(unsigned char))) == NULL)
4449: {
4450: (*s_etat_processus).erreur_systeme =
4451: d_es_allocation_memoire;
4452: return(NULL);
4453: }
4454:
4455: memcpy(&(chaine[longueur_totale]), chaine_formatee,
4456: (size_t) (*longueur_effective));
4457: longueur_totale += (*longueur_effective);
4458: free(chaine_formatee);
4459: }
4460:
4461: if (format_sortie != 'N')
4462: {
4463: l_element_courant_format =
4464: (*l_element_courant_format).suivant;
4465: }
4466:
4467: nombre_elements++;
4468: l_element_courant = (*l_element_courant).suivant;
4469: }
4470:
4471: if (format_sortie != 'N')
4472: {
4473: if ((l_element_courant != NULL) ||
4474: (l_element_courant_format != NULL))
4475: {
4476: free(chaine);
4477:
4478: (*s_etat_processus).erreur_execution =
4479: d_ex_erreur_format_fichier;
4480: return(NULL);
4481: }
4482: }
4483: */
4484:
4485: (*longueur_effective) = longueur_totale;
4486: }
4487: else if ((*s_objet).type == MCX)
4488: {
4489:
4490: /*
4491: --------------------------------------------------------------------------------
4492: Matrice complexe
4493: --------------------------------------------------------------------------------
4494: */
4495:
4496: if (format_sortie == 'N')
4497: {
4498: format_sortie = 'C';
4499: longueur = 16;
4500: }
4501:
4502: if (format_sortie != 'C')
4503: {
4504: (*s_etat_processus).erreur_execution =
4505: d_ex_erreur_format_fichier;
4506: return(NULL);
4507: }
4508:
4509: longueur_objet = (*((struct_matrice *) (*s_objet).objet))
4510: .nombre_lignes * (*((struct_matrice *) (*s_objet).objet))
4511: .nombre_colonnes;
4512:
4513: if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
4514: < (1LL << 8)) && ((*((struct_matrice *) (*s_objet).objet))
4515: .nombre_colonnes < (1LL << 8)))
4516: {
4517: // Taille sur un octet
4518: if ((chaine = malloc((size_t) ((*longueur_effective) =
4519: (3 + (longueur_objet * longueur)))
4520: * sizeof(unsigned char))) == NULL)
4521: {
4522: (*s_etat_processus).erreur_systeme =
4523: d_es_allocation_memoire;
4524: return(NULL);
4525: }
4526:
4527: chaine[0] = 0xD2;
4528: chaine[1] = (unsigned char) ((*((struct_matrice *)
4529: (*s_objet).objet)).nombre_lignes & 0xFF);
4530: chaine[2] = (unsigned char) ((*((struct_matrice *)
4531: (*s_objet).objet)).nombre_colonnes & 0xFF);
4532: chaine_offset = chaine + 3;
4533: }
4534: else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
4535: < (1LL << 16)) && ((*((struct_matrice *) (*s_objet).objet))
4536: .nombre_colonnes < (1LL << 16)))
4537: {
4538: // Taille sur deux octets
4539: if ((chaine = malloc((size_t) ((*longueur_effective) =
4540: (5 + (longueur_objet * longueur)))
4541: * sizeof(unsigned char))) == NULL)
4542: {
4543: (*s_etat_processus).erreur_systeme =
4544: d_es_allocation_memoire;
4545: return(NULL);
4546: }
4547:
4548: chaine[0] = 0xD6;
4549: chaine[1] = (unsigned char) (((*((struct_matrice *)
4550: (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
4551: chaine[2] = (unsigned char) ((*((struct_matrice *)
4552: (*s_objet).objet)).nombre_lignes & 0xFF);
4553: chaine[3] = (unsigned char) (((*((struct_matrice *)
4554: (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
4555: chaine[4] = (unsigned char) ((*((struct_matrice *)
4556: (*s_objet).objet)).nombre_colonnes & 0xFF);
4557: chaine_offset = chaine + 5;
4558: }
4559: else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
4560: < (1LL << 32)) && ((*((struct_matrice *) (*s_objet).objet))
4561: .nombre_colonnes < (1LL << 32)))
4562: {
4563: // Taille sur quatre octets
4564: if ((chaine = malloc((size_t) (((*longueur_effective) =
4565: 9 + (longueur_objet * longueur)))
4566: * sizeof(unsigned char))) == NULL)
4567: {
4568: (*s_etat_processus).erreur_systeme =
4569: d_es_allocation_memoire;
4570: return(NULL);
4571: }
4572:
4573: chaine[0] = 0xDA;
4574: chaine[1] = (unsigned char) (((*((struct_matrice *)
4575: (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
4576: chaine[2] = (unsigned char) (((*((struct_matrice *)
4577: (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
4578: chaine[3] = (unsigned char) (((*((struct_matrice *)
4579: (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
4580: chaine[4] = (unsigned char) ((*((struct_matrice *)
4581: (*s_objet).objet)).nombre_lignes & 0xFF);
4582: chaine[5] = (unsigned char) (((*((struct_matrice *)
4583: (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
4584: chaine[6] = (unsigned char) (((*((struct_matrice *)
4585: (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
4586: chaine[7] = (unsigned char) (((*((struct_matrice *)
4587: (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
4588: chaine[8] = (unsigned char) ((*((struct_matrice *)
4589: (*s_objet).objet)).nombre_colonnes & 0xFF);
4590: chaine_offset = chaine + 9;
4591: }
4592: else
4593: {
4594: // Taille sur huit octets
4595: if ((chaine = malloc((size_t) ((*longueur_effective) =
4596: (17 + (longueur_objet * longueur)))
4597: * sizeof(unsigned char))) == NULL)
4598: {
4599: (*s_etat_processus).erreur_systeme =
4600: d_es_allocation_memoire;
4601: return(NULL);
4602: }
4603:
4604: chaine[0] = 0xDE;
4605: chaine[1] = (unsigned char) (((*((struct_matrice *)
4606: (*s_objet).objet)).nombre_lignes >> 56) & 0xFF);
4607: chaine[2] = (unsigned char) (((*((struct_matrice *)
4608: (*s_objet).objet)).nombre_lignes >> 48) & 0xFF);
4609: chaine[3] = (unsigned char) (((*((struct_matrice *)
4610: (*s_objet).objet)).nombre_lignes >> 40) & 0xFF);
4611: chaine[4] = (unsigned char) (((*((struct_matrice *)
4612: (*s_objet).objet)).nombre_lignes >> 32) & 0xFF);
4613: chaine[5] = (unsigned char) (((*((struct_matrice *)
4614: (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
4615: chaine[6] = (unsigned char) (((*((struct_matrice *)
4616: (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
4617: chaine[7] = (unsigned char) (((*((struct_matrice *)
4618: (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
4619: chaine[8] = (unsigned char) ((*((struct_matrice *)
4620: (*s_objet).objet)).nombre_lignes & 0xFF);
4621: chaine[9] = (unsigned char) (((*((struct_matrice *)
4622: (*s_objet).objet)).nombre_colonnes >> 56) & 0xFF);
4623: chaine[10] = (unsigned char) (((*((struct_matrice *)
4624: (*s_objet).objet)).nombre_colonnes >> 48) & 0xFF);
4625: chaine[11] = (unsigned char) (((*((struct_matrice *)
4626: (*s_objet).objet)).nombre_colonnes >> 40) & 0xFF);
4627: chaine[12] = (unsigned char) (((*((struct_matrice *)
4628: (*s_objet).objet)).nombre_colonnes >> 32) & 0xFF);
4629: chaine[13] = (unsigned char) (((*((struct_matrice *)
4630: (*s_objet).objet)).nombre_colonnes >> 24) & 0xFF);
4631: chaine[14] = (unsigned char) (((*((struct_matrice *)
4632: (*s_objet).objet)).nombre_colonnes >> 16) & 0xFF);
4633: chaine[15] = (unsigned char) (((*((struct_matrice *)
4634: (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
4635: chaine[16] = (unsigned char) ((*((struct_matrice *)
4636: (*s_objet).objet)).nombre_colonnes & 0xFF);
4637: chaine_offset = chaine + 17;
4638: }
4639:
4640: switch(longueur)
4641: {
4642: case 8:
4643: {
4644: break;
4645: }
4646:
4647: default:
4648: case 16:
4649: {
4650: chaine[0] |= 0x01;
4651: break;
4652: }
4653: }
4654:
4655: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
4656: .nombre_lignes; i++)
4657: {
4658: for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
4659: .nombre_colonnes; j++)
4660: {
4661: if ((chaine_tampon = formateur_fichier_binaire_nombre(
4662: s_etat_processus, &(((complex16 **)
4663: (*((struct_matrice *) (*s_objet).objet)).tableau)
4664: [i][j]), 'R', format_sortie,
4665: longueur, &longueur_element)) == NULL)
4666: {
4667: free(chaine);
4668: return(NULL);
4669: }
4670:
4671: memcpy(chaine_offset + (((i * (*((struct_matrice *)
4672: (*s_objet).objet)).nombre_colonnes) + j) *
4673: longueur), chaine_tampon + 1, (size_t) longueur);
4674: free(chaine_tampon);
4675: }
4676: }
4677: }
4678: else if ((*s_objet).type == MIN)
4679: {
4680:
4681: /*
4682: --------------------------------------------------------------------------------
4683: Matrice entière
4684: --------------------------------------------------------------------------------
4685: */
4686:
4687: if (format_sortie == 'N')
4688: {
4689: format_sortie = 'I';
4690: longueur = 8;
4691: }
4692:
4693: if ((format_sortie != 'I') && (format_sortie != 'R')
4694: && (format_sortie != 'C'))
4695: {
4696: (*s_etat_processus).erreur_execution =
4697: d_ex_erreur_format_fichier;
4698: return(NULL);
4699: }
4700:
4701: longueur_objet = (*((struct_matrice *) (*s_objet).objet))
4702: .nombre_lignes * (*((struct_matrice *) (*s_objet).objet))
4703: .nombre_colonnes;
4704:
4705: if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
4706: < (1LL << 8)) && ((*((struct_matrice *) (*s_objet).objet))
4707: .nombre_colonnes < (1LL << 8)))
4708: {
4709: // Taille sur un octet
4710: if ((chaine = malloc((size_t) ((*longueur_effective) =
4711: (3 + (longueur_objet * longueur)))
4712: * sizeof(unsigned char))) == NULL)
4713: {
4714: (*s_etat_processus).erreur_systeme =
4715: d_es_allocation_memoire;
4716: return(NULL);
4717: }
4718:
4719: chaine[0] = 0x00;
4720: chaine[1] = (unsigned char) ((*((struct_matrice *)
4721: (*s_objet).objet)).nombre_lignes & 0xFF);
4722: chaine[2] = (unsigned char) ((*((struct_matrice *)
4723: (*s_objet).objet)).nombre_colonnes & 0xFF);
4724: chaine_offset = chaine + 3;
4725: }
4726: else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
4727: < (1LL << 16)) && ((*((struct_matrice *) (*s_objet).objet))
4728: .nombre_colonnes < (1LL << 16)))
4729: {
4730: // Taille sur deux octets
4731: if ((chaine = malloc((size_t) ((*longueur_effective) =
4732: (5 + (longueur_objet * longueur)))
4733: * sizeof(unsigned char))) == NULL)
4734: {
4735: (*s_etat_processus).erreur_systeme =
4736: d_es_allocation_memoire;
4737: return(NULL);
4738: }
4739:
4740: chaine[0] = 0x04;
4741: chaine[1] = (unsigned char) (((*((struct_matrice *)
4742: (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
4743: chaine[2] = (unsigned char) ((*((struct_matrice *)
4744: (*s_objet).objet)).nombre_lignes & 0xFF);
4745: chaine[3] = (unsigned char) (((*((struct_matrice *)
4746: (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
4747: chaine[4] = (unsigned char) ((*((struct_matrice *)
4748: (*s_objet).objet)).nombre_colonnes & 0xFF);
4749: chaine_offset = chaine + 5;
4750: }
4751: else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
4752: < (1LL << 32)) && ((*((struct_matrice *) (*s_objet).objet))
4753: .nombre_colonnes < (1LL << 32)))
4754: {
4755: // Taille sur quatre octets
4756: if ((chaine = malloc((size_t) (((*longueur_effective) =
4757: 9 + (longueur_objet * longueur)))
4758: * sizeof(unsigned char))) == NULL)
4759: {
4760: (*s_etat_processus).erreur_systeme =
4761: d_es_allocation_memoire;
4762: return(NULL);
4763: }
4764:
4765: chaine[0] = 0x08;
4766: chaine[1] = (unsigned char) (((*((struct_matrice *)
4767: (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
4768: chaine[2] = (unsigned char) (((*((struct_matrice *)
4769: (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
4770: chaine[3] = (unsigned char) (((*((struct_matrice *)
4771: (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
4772: chaine[4] = (unsigned char) ((*((struct_matrice *)
4773: (*s_objet).objet)).nombre_lignes & 0xFF);
4774: chaine[5] = (unsigned char) (((*((struct_matrice *)
4775: (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
4776: chaine[6] = (unsigned char) (((*((struct_matrice *)
4777: (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
4778: chaine[7] = (unsigned char) (((*((struct_matrice *)
4779: (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
4780: chaine[8] = (unsigned char) ((*((struct_matrice *)
4781: (*s_objet).objet)).nombre_colonnes & 0xFF);
4782: chaine_offset = chaine + 9;
4783: }
4784: else
4785: {
4786: // Taille sur huit octets
4787: if ((chaine = malloc((size_t) ((*longueur_effective) =
4788: (17 + (longueur_objet * longueur)))
4789: * sizeof(unsigned char))) == NULL)
4790: {
4791: (*s_etat_processus).erreur_systeme =
4792: d_es_allocation_memoire;
4793: return(NULL);
4794: }
4795:
4796: chaine[0] = 0x0C;
4797: chaine[1] = (unsigned char) (((*((struct_matrice *)
4798: (*s_objet).objet)).nombre_lignes >> 56) & 0xFF);
4799: chaine[2] = (unsigned char) (((*((struct_matrice *)
4800: (*s_objet).objet)).nombre_lignes >> 48) & 0xFF);
4801: chaine[3] = (unsigned char) (((*((struct_matrice *)
4802: (*s_objet).objet)).nombre_lignes >> 40) & 0xFF);
4803: chaine[4] = (unsigned char) (((*((struct_matrice *)
4804: (*s_objet).objet)).nombre_lignes >> 32) & 0xFF);
4805: chaine[5] = (unsigned char) (((*((struct_matrice *)
4806: (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
4807: chaine[6] = (unsigned char) (((*((struct_matrice *)
4808: (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
4809: chaine[7] = (unsigned char) (((*((struct_matrice *)
4810: (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
4811: chaine[8] = (unsigned char) ((*((struct_matrice *)
4812: (*s_objet).objet)).nombre_lignes & 0xFF);
4813: chaine[9] = (unsigned char) (((*((struct_matrice *)
4814: (*s_objet).objet)).nombre_colonnes >> 56) & 0xFF);
4815: chaine[10] = (unsigned char) (((*((struct_matrice *)
4816: (*s_objet).objet)).nombre_colonnes >> 48) & 0xFF);
4817: chaine[11] = (unsigned char) (((*((struct_matrice *)
4818: (*s_objet).objet)).nombre_colonnes >> 40) & 0xFF);
4819: chaine[12] = (unsigned char) (((*((struct_matrice *)
4820: (*s_objet).objet)).nombre_colonnes >> 32) & 0xFF);
4821: chaine[13] = (unsigned char) (((*((struct_matrice *)
4822: (*s_objet).objet)).nombre_colonnes >> 24) & 0xFF);
4823: chaine[14] = (unsigned char) (((*((struct_matrice *)
4824: (*s_objet).objet)).nombre_colonnes >> 16) & 0xFF);
4825: chaine[15] = (unsigned char) (((*((struct_matrice *)
4826: (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
4827: chaine[16] = (unsigned char) ((*((struct_matrice *)
4828: (*s_objet).objet)).nombre_colonnes & 0xFF);
4829: chaine_offset = chaine + 17;
4830: }
4831:
4832: switch(format_sortie)
4833: {
4834: default:
4835: case 'I':
4836: {
4837: switch(longueur)
4838: {
4839: case 1:
4840: {
4841: break;
4842: }
4843:
4844: case 2:
4845: {
4846: chaine[0] |= 0x01;
4847: break;
4848: }
4849:
4850: case 4:
4851: {
4852: chaine[0] |= 0x02;
4853: break;
4854: }
4855:
4856: default:
4857: case 8:
4858: {
4859: chaine[0] |= 0x03;
4860: break;
4861: }
4862: }
4863:
4864: chaine[0] |= 0x30;
4865: break;
4866: }
4867:
4868: case 'R':
4869: {
4870: switch(longueur)
4871: {
4872: case 4:
4873: {
4874: break;
4875: }
4876:
4877: default:
4878: case 8:
4879: {
4880: chaine[0] |= 0x01;
4881: break;
4882: }
4883: }
4884:
4885: chaine[0] |= 0xC0;
4886: break;
4887: }
4888:
4889: case 'C':
4890: {
4891: switch(longueur)
4892: {
4893: case 8:
4894: {
4895: break;
4896: }
4897:
4898: default:
4899: case 16:
4900: {
4901: chaine[0] |= 0x01;
4902: break;
4903: }
4904: }
4905:
4906: chaine[0] |= 0xD0;
4907: break;
4908: }
4909: }
4910:
4911: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
4912: .nombre_lignes; i++)
4913: {
4914: for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
4915: .nombre_colonnes; j++)
4916: {
4917: if ((chaine_tampon = formateur_fichier_binaire_nombre(
4918: s_etat_processus, &(((integer8 **)
4919: (*((struct_matrice *) (*s_objet).objet)).tableau)
4920: [i][j]), 'I', format_sortie,
4921: longueur, &longueur_element)) == NULL)
4922: {
4923: free(chaine);
4924: return(NULL);
4925: }
4926:
4927: memcpy(chaine_offset + (((i * (*((struct_matrice *)
4928: (*s_objet).objet)).nombre_colonnes) + j) *
4929: longueur), chaine_tampon + 1, (size_t) longueur);
4930: free(chaine_tampon);
4931: }
4932: }
4933: }
4934: else if ((*s_objet).type == MRL)
4935: {
4936:
4937: /*
4938: --------------------------------------------------------------------------------
4939: Matrice réelle
4940: --------------------------------------------------------------------------------
4941: */
4942: if (format_sortie == 'N')
4943: {
4944: format_sortie = 'R';
4945: longueur = 8;
4946: }
4947:
4948: if ((format_sortie != 'R') && (format_sortie != 'C'))
4949: {
4950: (*s_etat_processus).erreur_execution =
4951: d_ex_erreur_format_fichier;
4952: return(NULL);
4953: }
4954:
4955: longueur_objet = (*((struct_matrice *) (*s_objet).objet))
4956: .nombre_lignes * (*((struct_matrice *) (*s_objet).objet))
4957: .nombre_colonnes;
4958:
4959: if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
4960: < (1LL << 8)) && ((*((struct_matrice *) (*s_objet).objet))
4961: .nombre_colonnes < (1LL << 8)))
4962: {
4963: // Taille sur un octet
4964: if ((chaine = malloc((size_t) ((*longueur_effective) =
4965: (3 + (longueur_objet * longueur)))
4966: * sizeof(unsigned char))) == NULL)
4967: {
4968: (*s_etat_processus).erreur_systeme =
4969: d_es_allocation_memoire;
4970: return(NULL);
4971: }
4972:
4973: chaine[0] = 0xC2;
4974: chaine[1] = (unsigned char) ((*((struct_matrice *)
4975: (*s_objet).objet)).nombre_lignes & 0xFF);
4976: chaine[2] = (unsigned char) ((*((struct_matrice *)
4977: (*s_objet).objet)).nombre_colonnes & 0xFF);
4978: chaine_offset = chaine + 3;
4979: }
4980: else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
4981: < (1LL << 16)) && ((*((struct_matrice *) (*s_objet).objet))
4982: .nombre_colonnes < (1LL << 16)))
4983: {
4984: // Taille sur deux octets
4985: if ((chaine = malloc((size_t) ((*longueur_effective) =
4986: (5 + (longueur_objet * longueur)))
4987: * sizeof(unsigned char))) == NULL)
4988: {
4989: (*s_etat_processus).erreur_systeme =
4990: d_es_allocation_memoire;
4991: return(NULL);
4992: }
4993:
4994: chaine[0] = 0xC6;
4995: chaine[1] = (unsigned char) (((*((struct_matrice *)
4996: (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
4997: chaine[2] = (unsigned char) ((*((struct_matrice *)
4998: (*s_objet).objet)).nombre_lignes & 0xFF);
4999: chaine[3] = (unsigned char) (((*((struct_matrice *)
5000: (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
5001: chaine[4] = (unsigned char) ((*((struct_matrice *)
5002: (*s_objet).objet)).nombre_colonnes & 0xFF);
5003: chaine_offset = chaine + 5;
5004: }
5005: else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
5006: < (1LL << 32)) && ((*((struct_matrice *) (*s_objet).objet))
5007: .nombre_colonnes < (1LL << 32)))
5008: {
5009: // Taille sur quatre octets
5010: if ((chaine = malloc((size_t) (((*longueur_effective) =
5011: 9 + (longueur_objet * longueur)))
5012: * sizeof(unsigned char))) == NULL)
5013: {
5014: (*s_etat_processus).erreur_systeme =
5015: d_es_allocation_memoire;
5016: return(NULL);
5017: }
5018:
5019: chaine[0] = 0xCA;
5020: chaine[1] = (unsigned char) (((*((struct_matrice *)
5021: (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
5022: chaine[2] = (unsigned char) (((*((struct_matrice *)
5023: (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
5024: chaine[3] = (unsigned char) (((*((struct_matrice *)
5025: (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
5026: chaine[4] = (unsigned char) ((*((struct_matrice *)
5027: (*s_objet).objet)).nombre_lignes & 0xFF);
5028: chaine[5] = (unsigned char) (((*((struct_matrice *)
5029: (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
5030: chaine[6] = (unsigned char) (((*((struct_matrice *)
5031: (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
5032: chaine[7] = (unsigned char) (((*((struct_matrice *)
5033: (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
5034: chaine[8] = (unsigned char) ((*((struct_matrice *)
5035: (*s_objet).objet)).nombre_colonnes & 0xFF);
5036: chaine_offset = chaine + 9;
5037: }
5038: else
5039: {
5040: // Taille sur huit octets
5041: if ((chaine = malloc((size_t) ((*longueur_effective) =
5042: (17 + (longueur_objet * longueur)))
5043: * sizeof(unsigned char))) == NULL)
5044: {
5045: (*s_etat_processus).erreur_systeme =
5046: d_es_allocation_memoire;
5047: return(NULL);
5048: }
5049:
5050: chaine[0] = 0xCE;
5051: chaine[1] = (unsigned char) (((*((struct_matrice *)
5052: (*s_objet).objet)).nombre_lignes >> 56) & 0xFF);
5053: chaine[2] = (unsigned char) (((*((struct_matrice *)
5054: (*s_objet).objet)).nombre_lignes >> 48) & 0xFF);
5055: chaine[3] = (unsigned char) (((*((struct_matrice *)
5056: (*s_objet).objet)).nombre_lignes >> 40) & 0xFF);
5057: chaine[4] = (unsigned char) (((*((struct_matrice *)
5058: (*s_objet).objet)).nombre_lignes >> 32) & 0xFF);
5059: chaine[5] = (unsigned char) (((*((struct_matrice *)
5060: (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
5061: chaine[6] = (unsigned char) (((*((struct_matrice *)
5062: (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
5063: chaine[7] = (unsigned char) (((*((struct_matrice *)
5064: (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
5065: chaine[8] = (unsigned char) ((*((struct_matrice *)
5066: (*s_objet).objet)).nombre_lignes & 0xFF);
5067: chaine[9] = (unsigned char) (((*((struct_matrice *)
5068: (*s_objet).objet)).nombre_colonnes >> 56) & 0xFF);
5069: chaine[10] = (unsigned char) (((*((struct_matrice *)
5070: (*s_objet).objet)).nombre_colonnes >> 48) & 0xFF);
5071: chaine[11] = (unsigned char) (((*((struct_matrice *)
5072: (*s_objet).objet)).nombre_colonnes >> 40) & 0xFF);
5073: chaine[12] = (unsigned char) (((*((struct_matrice *)
5074: (*s_objet).objet)).nombre_colonnes >> 32) & 0xFF);
5075: chaine[13] = (unsigned char) (((*((struct_matrice *)
5076: (*s_objet).objet)).nombre_colonnes >> 24) & 0xFF);
5077: chaine[14] = (unsigned char) (((*((struct_matrice *)
5078: (*s_objet).objet)).nombre_colonnes >> 16) & 0xFF);
5079: chaine[15] = (unsigned char) (((*((struct_matrice *)
5080: (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
5081: chaine[16] = (unsigned char) ((*((struct_matrice *)
5082: (*s_objet).objet)).nombre_colonnes & 0xFF);
5083: chaine_offset = chaine + 17;
5084: }
5085:
5086: switch(format_sortie)
5087: {
5088: default:
5089: case 'R':
5090: {
5091: switch(longueur)
5092: {
5093: case 4:
5094: {
5095: break;
5096: }
5097:
5098: default:
5099: case 8:
5100: {
5101: chaine[0] |= 0x01;
5102: break;
5103: }
5104: }
5105:
5106: break;
5107: }
5108:
5109: case 'C':
5110: {
5111: switch(longueur)
5112: {
5113: case 8:
5114: {
5115: break;
5116: }
5117:
5118: default:
5119: case 16:
5120: {
5121: chaine[0] |= 0x01;
5122: break;
5123: }
5124: }
5125:
5126: chaine[0] |= 0x10;
5127: break;
5128: }
5129: }
5130:
5131: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
5132: .nombre_lignes; i++)
5133: {
5134: for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
5135: .nombre_colonnes; j++)
5136: {
5137: if ((chaine_tampon = formateur_fichier_binaire_nombre(
5138: s_etat_processus, &(((real8 **)
5139: (*((struct_matrice *) (*s_objet).objet)).tableau)
5140: [i][j]), 'R', format_sortie,
5141: longueur, &longueur_element)) == NULL)
5142: {
5143: free(chaine);
5144: return(NULL);
5145: }
5146:
5147: memcpy(chaine_offset + (((i * (*((struct_matrice *)
5148: (*s_objet).objet)).nombre_colonnes) + j) *
5149: longueur), chaine_tampon + 1, (size_t) longueur);
5150: free(chaine_tampon);
5151: }
5152: }
5153: }
5154: else if ((*s_objet).type == NOM)
5155: {
5156:
5157: /*
5158: --------------------------------------------------------------------------------
5159: Nom
5160: Poids fort 0101
5161: --------------------------------------------------------------------------------
5162: */
5163: if (format_sortie != 'N')
5164: {
5165: (*s_etat_processus).erreur_execution =
5166: d_ex_erreur_format_fichier;
5167: return(NULL);
5168: }
5169:
5170: longueur_fonction = (integer8) strlen((*((struct_nom *)
5171: (*s_objet).objet)).nom);
5172:
5173: if (longueur_fonction < (1LL << 3))
5174: {
5175: if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 1)
5176: * sizeof(unsigned char)))== NULL)
5177: {
5178: (*s_etat_processus).erreur_systeme =
5179: d_es_allocation_memoire;
5180: return(NULL);
5181: }
5182:
5183: chaine[0] = (unsigned char) (0x50 | (longueur_fonction & 0x7));
5184:
5185: strcpy(chaine + 1, (*((struct_nom *) (*s_objet).objet)).nom);
5186: (*longueur_effective) = longueur_fonction + 2;
5187: }
5188: else if (longueur_fonction < (1LL << 8))
5189: {
5190: if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 1)
5191: * sizeof(unsigned char)))== NULL)
5192: {
5193: (*s_etat_processus).erreur_systeme =
5194: d_es_allocation_memoire;
5195: return(NULL);
5196: }
5197:
5198: chaine[0] = (unsigned char) (0x50 | 0x08);
5199: chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
5200:
5201: strcpy(chaine + 2, (*((struct_nom *) (*s_objet).objet)).nom);
5202: (*longueur_effective) = longueur_fonction + 3;
5203: }
5204: else if (longueur_fonction < (1LL << 16))
5205: {
5206: if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 1)
5207: * sizeof(unsigned char)))== NULL)
5208: {
5209: (*s_etat_processus).erreur_systeme =
5210: d_es_allocation_memoire;
5211: return(NULL);
5212: }
5213:
5214: chaine[0] = (unsigned char) (0x50 | 0x09);
5215: chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
5216: chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
5217:
5218: strcpy(chaine + 3, (*((struct_nom *) (*s_objet).objet)).nom);
5219: (*longueur_effective) = longueur_fonction + 4;
5220: }
5221: else if (longueur_fonction < (1LL << 32))
5222: {
5223: if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 1)
5224: * sizeof(unsigned char)))== NULL)
5225: {
5226: (*s_etat_processus).erreur_systeme =
5227: d_es_allocation_memoire;
5228: return(NULL);
5229: }
5230:
5231: chaine[0] = (unsigned char) (0xE0 | 0x0A);
5232: chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
5233: chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
5234: chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
5235: chaine[4] = (unsigned char) (longueur_fonction & 0xFF);
5236:
5237: strcpy(chaine + 5, (*((struct_nom *) (*s_objet).objet)).nom);
5238: (*longueur_effective) = longueur_fonction + 6;
5239: }
5240: else
5241: {
5242: if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 1)
5243: * sizeof(unsigned char)))== NULL)
5244: {
5245: (*s_etat_processus).erreur_systeme =
5246: d_es_allocation_memoire;
5247: return(NULL);
5248: }
5249:
5250: chaine[0] = (unsigned char) (0xE0 | 0x0B);
5251: chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
5252: chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
5253: chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
5254: chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF);
5255: chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
5256: chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
5257: chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
5258: chaine[8] = (unsigned char) (longueur_fonction & 0xFF);
5259:
5260: strcpy(chaine + 9, (*((struct_nom *) (*s_objet).objet)).nom);
5261: (*longueur_effective) = longueur_fonction + 10;
5262: }
5263:
5264: chaine[(*longueur_effective) - 1] = ((*((struct_nom *)
5265: (*s_objet).objet)).symbole == d_vrai) ? 0xFF : 0x00;
5266: }
5267: else if ((*s_objet).type == REL)
5268: {
5269:
5270: /*
5271: --------------------------------------------------------------------------------
5272: Réel
5273: Poids fort 0001 01
5274: --------------------------------------------------------------------------------
5275: */
5276:
5277: if (format_sortie == 'N')
5278: {
5279: format_sortie = 'R';
5280: longueur = 8;
5281: }
5282:
5283: if ((format_sortie != 'R') && (format_sortie != 'C'))
5284: {
5285: (*s_etat_processus).erreur_execution =
5286: d_ex_erreur_format_fichier;
5287: return(NULL);
5288: }
5289:
5290: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
5291: (*s_objet).objet, 'R', format_sortie,
5292: longueur, longueur_effective)) == NULL)
5293: {
5294: return(NULL);
5295: }
5296: }
5297: else if ((*s_objet).type == VCX)
5298: {
5299:
5300: /*
5301: --------------------------------------------------------------------------------
5302: Vecteur complexe
5303: --------------------------------------------------------------------------------
5304: */
5305:
5306: if (format_sortie == 'N')
5307: {
5308: format_sortie = 'C';
5309: longueur = 16;
5310: }
5311:
5312: if (format_sortie != 'C')
5313: {
5314: (*s_etat_processus).erreur_execution =
5315: d_ex_erreur_format_fichier;
5316: return(NULL);
5317: }
5318:
5319: longueur_objet = (*((struct_vecteur *) (*s_objet).objet)).taille;
5320:
5321: if (longueur_objet < (1LL << 8))
5322: {
5323: // Taille sur un octet
5324: if ((chaine = malloc((size_t) ((*longueur_effective) =
5325: (2 + (longueur_objet * longueur)))
5326: * sizeof(unsigned char))) == NULL)
5327: {
5328: (*s_etat_processus).erreur_systeme =
5329: d_es_allocation_memoire;
5330: return(NULL);
5331: }
5332:
5333: chaine[0] = 0xB2;
5334: chaine[1] = (unsigned char) (longueur_objet & 0xFF);
5335: chaine_offset = chaine + 2;
5336: }
5337: else if (longueur_objet < (1LL << 16))
5338: {
5339: // Taille sur deux octets
5340: if ((chaine = malloc((size_t) ((*longueur_effective) =
5341: (3 + (longueur_objet * longueur)))
5342: * sizeof(unsigned char))) == NULL)
5343: {
5344: (*s_etat_processus).erreur_systeme =
5345: d_es_allocation_memoire;
5346: return(NULL);
5347: }
5348:
5349: chaine[0] = 0xB6;
5350: chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
5351: chaine[2] = (unsigned char) (longueur_objet & 0xFF);
5352: chaine_offset = chaine + 3;
5353: }
5354: else if (longueur_objet < (1LL << 32))
5355: {
5356: // Taille sur quatre octets
5357: if ((chaine = malloc((size_t) (((*longueur_effective) =
5358: 5 + (longueur_objet * longueur)))
5359: * sizeof(unsigned char))) == NULL)
5360: {
5361: (*s_etat_processus).erreur_systeme =
5362: d_es_allocation_memoire;
5363: return(NULL);
5364: }
5365:
5366: chaine[0] = 0xBA;
5367: chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
5368: chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
5369: chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
5370: chaine[4] = (unsigned char) (longueur_objet & 0xFF);
5371: chaine_offset = chaine + 5;
5372: }
5373: else
5374: {
5375: // Taille sur huit octets
5376: if ((chaine = malloc((size_t) ((*longueur_effective) =
5377: (9 + (longueur_objet * longueur)))
5378: * sizeof(unsigned char))) == NULL)
5379: {
5380: (*s_etat_processus).erreur_systeme =
5381: d_es_allocation_memoire;
5382: return(NULL);
5383: }
5384:
5385: chaine[0] = 0xBE;
5386: chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
5387: chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
5388: chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
5389: chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
5390: chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
5391: chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
5392: chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
5393: chaine[8] = (unsigned char) (longueur_objet & 0xFF);
5394: chaine_offset = chaine + 9;
5395: }
5396:
5397: switch(longueur)
5398: {
5399: case 8:
5400: {
5401: break;
5402: }
5403:
5404: default:
5405: case 16:
5406: {
5407: chaine[0] |= 0x01;
5408: break;
5409: }
5410: }
5411:
5412: for(i = 0; i < longueur_objet; i++)
5413: {
5414: if ((chaine_tampon = formateur_fichier_binaire_nombre(
5415: s_etat_processus, &(((complex16 *) (*((struct_vecteur *)
5416: (*s_objet).objet)).tableau)[i]), 'C', format_sortie,
5417: longueur, &longueur_element)) == NULL)
5418: {
5419: free(chaine);
5420: return(NULL);
5421: }
5422:
5423: memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
5424: (size_t) longueur);
5425: free(chaine_tampon);
5426: }
5427: }
5428: else if ((*s_objet).type == VIN)
5429: {
5430:
5431: /*
5432: --------------------------------------------------------------------------------
5433: Vecteur entier
5434: --------------------------------------------------------------------------------
5435: */
5436:
5437: if (format_sortie == 'N')
5438: {
5439: format_sortie = 'I';
5440: longueur = 8;
5441: }
5442:
5443: if ((format_sortie != 'I') && (format_sortie != 'R')
5444: && (format_sortie != 'C'))
5445: {
5446: (*s_etat_processus).erreur_execution =
5447: d_ex_erreur_format_fichier;
5448: return(NULL);
5449: }
5450:
5451: longueur_objet = (*((struct_vecteur *) (*s_objet).objet)).taille;
5452:
5453: if (longueur_objet < (1LL << 8))
5454: {
5455: // Taille sur un octet
5456: if ((chaine = malloc((size_t) ((*longueur_effective) =
5457: (2 + (longueur_objet * longueur)))
5458: * sizeof(unsigned char))) == NULL)
5459: {
5460: (*s_etat_processus).erreur_systeme =
5461: d_es_allocation_memoire;
5462: return(NULL);
5463: }
5464:
5465: chaine[0] = 0x20;
5466: chaine[1] = (unsigned char) (longueur_objet & 0xFF);
5467: chaine_offset = chaine + 2;
5468: }
5469: else if (longueur_objet < (1LL << 16))
5470: {
5471: // Taille sur deux octets
5472: if ((chaine = malloc((size_t) ((*longueur_effective) =
5473: (3 + (longueur_objet * longueur)))
5474: * sizeof(unsigned char))) == NULL)
5475: {
5476: (*s_etat_processus).erreur_systeme =
5477: d_es_allocation_memoire;
5478: return(NULL);
5479: }
5480:
5481: chaine[0] = 0x24;
5482: chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
5483: chaine[2] = (unsigned char) (longueur_objet & 0xFF);
5484: chaine_offset = chaine + 3;
5485: }
5486: else if (longueur_objet < (1LL << 32))
5487: {
5488: // Taille sur quatre octets
5489: if ((chaine = malloc((size_t) (((*longueur_effective) =
5490: 5 + (longueur_objet * longueur)))
5491: * sizeof(unsigned char))) == NULL)
5492: {
5493: (*s_etat_processus).erreur_systeme =
5494: d_es_allocation_memoire;
5495: return(NULL);
5496: }
5497:
5498: chaine[0] = 0x28;
5499: chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
5500: chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
5501: chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
5502: chaine[4] = (unsigned char) (longueur_objet & 0xFF);
5503: chaine_offset = chaine + 5;
5504: }
5505: else
5506: {
5507: // Taille sur huit octets
5508: if ((chaine = malloc((size_t) ((*longueur_effective) =
5509: (9 + (longueur_objet * longueur)))
5510: * sizeof(unsigned char))) == NULL)
5511: {
5512: (*s_etat_processus).erreur_systeme =
5513: d_es_allocation_memoire;
5514: return(NULL);
5515: }
5516:
5517: chaine[0] = 0x2C;
5518: chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
5519: chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
5520: chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
5521: chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
5522: chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
5523: chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
5524: chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
5525: chaine[8] = (unsigned char) (longueur_objet & 0xFF);
5526: chaine_offset = chaine + 9;
5527: }
5528:
5529: switch(format_sortie)
5530: {
5531: default:
5532: case 'I':
5533: {
5534: switch(longueur)
5535: {
5536: case 1:
5537: {
5538: break;
5539: }
5540:
5541: case 2:
5542: {
5543: chaine[0] |= 0x01;
5544: break;
5545: }
5546:
5547: case 4:
5548: {
5549: chaine[0] |= 0x02;
5550: break;
5551: }
5552:
5553: default:
5554: case 8:
5555: {
5556: chaine[0] |= 0x03;
5557: break;
5558: }
5559: }
5560:
5561: break;
5562: }
5563:
5564: case 'R':
5565: {
5566: switch(longueur)
5567: {
5568: case 4:
5569: {
5570: break;
5571: }
5572:
5573: default:
5574: case 8:
5575: {
5576: chaine[0] |= 0x01;
5577: break;
5578: }
5579: }
5580:
5581: chaine[0] |= 0x80;
5582: break;
5583: }
5584:
5585: case 'C':
5586: {
5587: switch(longueur)
5588: {
5589: case 8:
5590: {
5591: break;
5592: }
5593:
5594: default:
5595: case 16:
5596: {
5597: chaine[0] |= 0x01;
5598: break;
5599: }
5600: }
5601:
5602: chaine[0] |= 0x90;
5603: break;
5604: }
5605: }
5606:
5607: for(i = 0; i < longueur_objet; i++)
5608: {
5609: if ((chaine_tampon = formateur_fichier_binaire_nombre(
5610: s_etat_processus, &(((integer8 *) (*((struct_vecteur *)
5611: (*s_objet).objet)).tableau)[i]), 'I', format_sortie,
5612: longueur, &longueur_element)) == NULL)
5613: {
5614: free(chaine);
5615: return(NULL);
5616: }
5617:
5618: memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
5619: (size_t) longueur);
5620: free(chaine_tampon);
5621: }
5622: }
5623: else if ((*s_objet).type == VRL)
5624: {
5625:
5626: /*
5627: --------------------------------------------------------------------------------
5628: Vecteur réel
5629: --------------------------------------------------------------------------------
5630: */
5631:
5632: if (format_sortie == 'N')
5633: {
5634: format_sortie = 'R';
5635: longueur = 8;
5636: }
5637:
5638: if ((format_sortie != 'R') && (format_sortie != 'C'))
5639: {
5640: (*s_etat_processus).erreur_execution =
5641: d_ex_erreur_format_fichier;
5642: return(NULL);
5643: }
5644:
5645: longueur_objet = (*((struct_vecteur *) (*s_objet).objet)).taille;
5646:
5647: if (longueur_objet < (1LL << 8))
5648: {
5649: // Taille sur un octet
5650: if ((chaine = malloc((size_t) ((*longueur_effective) =
5651: (2 + (longueur_objet * longueur)))
5652: * sizeof(unsigned char))) == NULL)
5653: {
5654: (*s_etat_processus).erreur_systeme =
5655: d_es_allocation_memoire;
5656: return(NULL);
5657: }
5658:
5659: chaine[0] = 0xA2;
5660: chaine[1] = (unsigned char) (longueur_objet & 0xFF);
5661: chaine_offset = chaine + 2;
5662: }
5663: else if (longueur_objet < (1LL << 16))
5664: {
5665: // Taille sur deux octets
5666: if ((chaine = malloc((size_t) ((*longueur_effective) =
5667: (3 + (longueur_objet * longueur)))
5668: * sizeof(unsigned char))) == NULL)
5669: {
5670: (*s_etat_processus).erreur_systeme =
5671: d_es_allocation_memoire;
5672: return(NULL);
5673: }
5674:
5675: chaine[0] = 0xA6;
5676: chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
5677: chaine[2] = (unsigned char) (longueur_objet & 0xFF);
5678: chaine_offset = chaine + 3;
5679: }
5680: else if (longueur_objet < (1LL << 32))
5681: {
5682: // Taille sur quatre octets
5683: if ((chaine = malloc((size_t) (((*longueur_effective) =
5684: 5 + (longueur_objet * longueur)))
5685: * sizeof(unsigned char))) == NULL)
5686: {
5687: (*s_etat_processus).erreur_systeme =
5688: d_es_allocation_memoire;
5689: return(NULL);
5690: }
5691:
5692: chaine[0] = 0xAA;
5693: chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
5694: chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
5695: chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
5696: chaine[4] = (unsigned char) (longueur_objet & 0xFF);
5697: chaine_offset = chaine + 5;
5698: }
5699: else
5700: {
5701: // Taille sur huit octets
5702: if ((chaine = malloc((size_t) ((*longueur_effective) =
5703: (9 + (longueur_objet * longueur)))
5704: * sizeof(unsigned char))) == NULL)
5705: {
5706: (*s_etat_processus).erreur_systeme =
5707: d_es_allocation_memoire;
5708: return(NULL);
5709: }
5710:
5711: chaine[0] = 0xAE;
5712: chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
5713: chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
5714: chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
5715: chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
5716: chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
5717: chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
5718: chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
5719: chaine[8] = (unsigned char) (longueur_objet & 0xFF);
5720: chaine_offset = chaine + 9;
5721: }
5722:
5723: switch(format_sortie)
5724: {
5725: default:
5726: case 'R':
5727: {
5728: break;
5729: }
5730:
5731: case 'C':
5732: {
5733: chaine[0] |= 0x10;
5734: break;
5735: }
5736: }
5737:
5738: switch(longueur)
5739: {
5740: case 4:
5741: {
5742: break;
5743: }
5744:
5745: default:
5746: case 8:
5747: {
5748: chaine[0] |= 0x01;
5749: break;
5750: }
5751: }
5752:
5753: for(i = 0; i < longueur_objet; i++)
5754: {
5755: if ((chaine_tampon = formateur_fichier_binaire_nombre(
5756: s_etat_processus, &(((real8 *) (*((struct_vecteur *)
5757: (*s_objet).objet)).tableau)[i]), 'R', format_sortie,
5758: longueur, &longueur_element)) == NULL)
5759: {
5760: free(chaine);
5761: return(NULL);
5762: }
5763:
5764: memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
5765: (size_t) longueur);
5766: free(chaine_tampon);
5767: }
5768: }
5769: else
5770: {
5771: // Type non exportable
5772:
5773: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
5774: free(chaine);
5775:
5776: return(NULL);
5777: }
5778:
5779: // On n'ajoute la longueur de l'enregistrement que dans le cas
5780: // où le format est utilisé dans un fichier.
5781:
5782: if (((*recursivite) == 1) && (export_fichier == d_vrai))
5783: {
5784: // Ajout de la longueur totale en fin d'enregistrement.
5785:
5786: longueur_totale = (*longueur_effective);
5787:
5788: if (longueur_totale < (((integer8) 1) << 7))
5789: {
5790: tampon[0] = (unsigned char) (((longueur_totale + 1) << 1)
5791: & 0xFF);
5792:
5793: if ((chaine = realloc(chaine, (((size_t) longueur_totale) + 1)
5794: * sizeof(unsigned char))) == NULL)
5795: {
5796: (*s_etat_processus).erreur_systeme =
5797: d_es_allocation_memoire;
5798: return(NULL);
5799: }
5800:
5801: // XXXX XXX0
5802: memcpy(&(chaine[longueur_totale]), tampon, 1);
5803: longueur_totale += 1;
5804: }
5805: else
5806: {
5807: longueur_totale++;
5808:
5809: // i = { 0 (16 bits) 2 (32 bits) 6 (64 bits) }
5810:
5811: i = 0;
5812:
5813: for(;;)
5814: {
5815: if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))
5816: || (i == 6))
5817: {
5818: // LSB (4 bits de poids fort)
5819: tampon[0] = (unsigned char) ((longueur_totale & 0xF0)
5820: | 0x1 /* longueur supérieure à 7 bits */
5821: | ((i + 1) << 1));
5822:
5823: for(j = 0; j <= i; j++)
5824: {
5825: tampon[(i - j) + 1] = (unsigned char)
5826: ((longueur_totale >> (8 * (j + 1)))
5827: & 0xFF);
5828: }
5829:
5830: // LSB (4 bits de poids faible)
5831: tampon[i + 2] = (unsigned char)
5832: (((longueur_totale & 0x0F) << 4)
5833: | 0x1 /* longueur supérieure à 7 bits */
5834: | ((i + 1) << 1));
5835: break;
5836: }
5837:
5838: switch(i)
5839: {
5840: case 0 :
5841: {
5842: i = 2;
5843: break;
5844: }
5845:
5846: case 2 :
5847: {
5848: i = 6;
5849: break;
5850: }
5851: }
5852: }
5853:
5854: // i = 0 => +3 (16 bits)
5855: // i = 2 => +5 (32 bits)
5856: // i = 6 => +9 (64 bits)
5857:
5858: if ((chaine = realloc(chaine, (((size_t) longueur_totale)
5859: + ((i == 0) ? 3 : ((i == 2) ? 5 : 9)))
5860: * sizeof(unsigned char))) == NULL)
5861: {
5862: (*s_etat_processus).erreur_systeme =
5863: d_es_allocation_memoire;
5864: return(NULL);
5865: }
5866:
5867: memcpy(&(chaine[longueur_totale]), tampon, 3);
5868: longueur_totale += 3;
5869: }
5870:
5871: __zone();
5872: (*longueur_effective) = longueur_totale;
5873: }
5874: }
5875:
5876: (*recursivite)--;
5877:
5878: return(chaine);
5879: }
5880:
5881:
5882: /*
5883: ================================================================================
5884: Routines qui transforment un nombre entier, réel ou complexe en chaîne de
5885: caractères suivant le format courant
5886: ================================================================================
5887: Entrées : pointeur générique sur la donnée numérique à convertir,
5888: type de l'entité (I, R ou C).
5889: --------------------------------------------------------------------------------
5890: Sorties : chaîne de caractères allouée dans la routine
5891: --------------------------------------------------------------------------------
5892: Effets de bord : néant
5893: ================================================================================
5894: */
5895:
5896: /*
5897: --------------------------------------------------------------------------------
5898: Formatage des complexes, réels et entiers
5899: --------------------------------------------------------------------------------
5900: */
5901:
5902: unsigned char *
5903: formateur_fichier_nombre(struct_processus *s_etat_processus,
5904: void *valeur_numerique, unsigned char type,
5905: integer8 longueur, integer8 longueur_champ, unsigned char format)
5906: {
5907: unsigned char *chaine;
5908: unsigned char *construction_chaine;
5909: unsigned char *sauvegarde;
5910: unsigned char *tampon;
5911:
5912: chaine = NULL;
5913:
5914: switch(type)
5915: {
5916: case 'C' :
5917: {
5918: construction_chaine = (unsigned char *) malloc(
5919: 2 * sizeof(unsigned char));
5920:
5921: if (construction_chaine == NULL)
5922: {
5923: (*s_etat_processus).erreur_systeme =
5924: d_es_allocation_memoire;
5925: return(NULL);
5926: }
5927:
5928: strcpy(construction_chaine, "(");
5929:
5930: tampon = formateur_fichier_reel(s_etat_processus,
5931: (void *) &((*((struct_complexe16 *)
5932: valeur_numerique)).partie_reelle), 'R',
5933: longueur, longueur_champ, format);
5934:
5935: if (tampon == NULL)
5936: {
5937: (*s_etat_processus).erreur_systeme =
5938: d_es_allocation_memoire;
5939: return(NULL);
5940: }
5941:
5942: sauvegarde = construction_chaine;
5943:
5944: construction_chaine = (unsigned char *) malloc(
5945: (strlen(sauvegarde) + strlen(tampon) + 2)
5946: * sizeof(unsigned char));
5947:
5948: if (construction_chaine == NULL)
5949: {
5950: (*s_etat_processus).erreur_systeme =
5951: d_es_allocation_memoire;
5952: return(NULL);
5953: }
5954:
5955: strcpy(construction_chaine, sauvegarde);
5956: free(sauvegarde);
5957: strcat(construction_chaine, tampon);
5958: free(tampon);
5959:
5960: strcat(construction_chaine, ",");
5961:
5962: tampon = formateur_fichier_reel(s_etat_processus,
5963: (void *) &((*((struct_complexe16 *)
5964: valeur_numerique)).partie_imaginaire), 'R',
5965: longueur, longueur_champ, format);
5966:
5967: if (tampon == NULL)
5968: {
5969: (*s_etat_processus).erreur_systeme =
5970: d_es_allocation_memoire;
5971: return(NULL);
5972: }
5973:
5974: sauvegarde = construction_chaine;
5975:
5976: construction_chaine = (unsigned char *) malloc(
5977: (strlen(sauvegarde) + strlen(tampon) + 2)
5978: * sizeof(unsigned char));
5979:
5980: if (construction_chaine == NULL)
5981: {
5982: (*s_etat_processus).erreur_systeme =
5983: d_es_allocation_memoire;
5984: return(NULL);
5985: }
5986:
5987: strcpy(construction_chaine, sauvegarde);
5988: free(sauvegarde);
5989: strcat(construction_chaine, tampon);
5990: free(tampon);
5991: strcat(construction_chaine, ")");
5992:
5993: chaine = construction_chaine;
5994:
5995: break;
5996: }
5997:
5998: case 'R' :
5999: {
6000: chaine = formateur_fichier_reel(s_etat_processus,
6001: valeur_numerique, 'R', longueur, longueur_champ,
6002: format);
6003:
6004: if (chaine == NULL)
6005: {
6006: (*s_etat_processus).erreur_systeme =
6007: d_es_allocation_memoire;
6008: return(NULL);
6009: }
6010:
6011: break;
6012: }
6013:
6014: default :
6015: case 'I' :
6016: {
6017: chaine = formateur_fichier_reel(s_etat_processus,
6018: valeur_numerique, 'I', longueur, longueur_champ,
6019: format);
6020:
6021: if (chaine == NULL)
6022: {
6023: (*s_etat_processus).erreur_systeme =
6024: d_es_allocation_memoire;
6025: return(NULL);
6026: }
6027:
6028: break;
6029: }
6030: }
6031:
6032: return(chaine);
6033: }
6034:
6035:
6036: /*
6037: --------------------------------------------------------------------------------
6038: Formateur des réels et entiers
6039: --------------------------------------------------------------------------------
6040: */
6041:
6042: unsigned char *
6043: formateur_fichier_reel(struct_processus *s_etat_processus,
6044: void *valeur_numerique, unsigned char type,
6045: integer8 longueur, integer8 longueur_champ,
6046: unsigned char format_sortie)
6047: {
6048: real8 mantisse;
6049: real8 tampon_reel;
6050:
6051: integer8 i;
6052: integer8 tampon_entier;
6053:
6054: long correction;
6055: long exposant;
6056: long longueur_utile;
6057: long longueur_utile_limite;
6058:
6059: unsigned char *chaine;
6060: unsigned char format[16 + 1];
6061: unsigned char mode[3 + 1];
6062: unsigned char tampon[16 + 1];
6063:
6064: chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
6065:
6066: if (chaine == NULL)
6067: {
6068: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
6069: return(NULL);
6070: }
6071:
6072: if (type == 'R')
6073: {
6074: tampon_reel = *((real8 *) valeur_numerique);
6075:
6076: if (tampon_reel > ((real8) 0))
6077: {
6078: exposant = (long) floor(log10(tampon_reel));
6079: }
6080: else if (tampon_reel < ((real8) 0))
6081: {
6082: exposant = (long) floor(log10(-tampon_reel));
6083: }
6084: else
6085: {
6086: exposant = 0;
6087: }
6088:
6089: mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
6090: }
6091: else
6092: {
6093: tampon_entier = *((integer8 *) valeur_numerique);
6094:
6095: if (tampon_entier > ((integer8) 0))
6096: {
6097: exposant = (long) floor(log10((double) tampon_entier));
6098: }
6099: else if (tampon_entier < ((integer8) 0))
6100: {
6101: exposant = (long) floor(log10((double) -tampon_entier));
6102: }
6103: else
6104: {
6105: exposant = 0;
6106: }
6107:
6108: mantisse = ((real8) (*((integer8 *) valeur_numerique))) /
6109: pow(10, (double) exposant);
6110: }
6111:
6112: longueur_utile = (long) longueur;
6113: longueur_utile_limite = 15;
6114:
6115: if (longueur_utile > longueur_utile_limite)
6116: {
6117: longueur_utile = longueur_utile_limite;
6118: }
6119:
6120: if (format_sortie == 'S')
6121: {
6122: strcpy(mode, "STD");
6123: }
6124: else if (format_sortie == 'C')
6125: {
6126: strcpy(mode, "SCI");
6127: }
6128: else if (format_sortie == 'F')
6129: {
6130: strcpy(mode, "FIX");
6131: }
6132: else
6133: {
6134: strcpy(mode, "ENG");
6135: }
6136:
6137: if ((strcmp(mode, "SCI") == 0) ||
6138: ((strcmp(mode, "STD") == 0) && ((exposant >
6139: longueur_utile_limite) ||
6140: (exposant < -longueur_utile_limite))) ||
6141: ((strcmp(mode, "FIX") == 0) &&
6142: ((exposant >= longueur_utile_limite) ||
6143: (exposant < -longueur_utile))))
6144: {
6145: chaine[0] = 0;
6146: format[0] = 0;
6147:
6148: if (strcmp(mode, "STD") == 0)
6149: {
6150: longueur_utile = longueur_utile_limite - 1;
6151: }
6152:
6153: sprintf(format, "%%.%luf", longueur_utile);
6154:
6155: sprintf(tampon, format, mantisse);
6156: strcpy(chaine, tampon);
6157: strcat(chaine, "E");
6158: sprintf(tampon, "%ld", exposant);
6159: strcat(chaine, tampon);
6160: }
6161: else if (strcmp(mode, "FIX") == 0)
6162: {
6163: chaine[0] = 0;
6164: format[0] = 0;
6165:
6166: if (longueur_utile + exposant >= longueur_utile_limite)
6167: {
6168: longueur_utile = longueur_utile_limite - (exposant + 1);
6169: }
6170:
6171: sprintf(format, "%%.%luf", longueur_utile);
6172:
6173: sprintf(tampon, format, (mantisse * pow(10, (double) exposant)));
6174: strcpy(chaine, tampon);
6175: }
6176: else if (strcmp(mode, "ENG") == 0)
6177: {
6178: chaine[0] = 0;
6179: format[0] = 0;
6180:
6181: correction = labs(exposant) % 3;
6182:
6183: if (exposant < 0)
6184: {
6185: if (correction == 0)
6186: {
6187: correction = 3;
6188: }
6189:
6190: correction = 3 - correction;
6191: }
6192:
6193: longueur_utile -= correction;
6194: sprintf(format, "%%.%luf", longueur_utile);
6195:
6196: sprintf(tampon, format, (mantisse * pow(10, (double) correction)));
6197: strcpy(chaine, tampon);
6198: strcat(chaine, "E");
6199: sprintf(tampon, "%ld", (exposant - correction));
6200: strcat(chaine, tampon);
6201: }
6202: else
6203: {
6204: if (type == 'I')
6205: {
6206: chaine[0] = 0;
6207: sprintf(tampon, "%lld", *((integer8 *) valeur_numerique));
6208: }
6209: else
6210: {
6211: chaine[0] = 0;
6212: format[0] = 0;
6213:
6214: if (exposant >= 0)
6215: {
6216: sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
6217: - 1));
6218: }
6219: else
6220: {
6221: sprintf(format, "%%.%luf", longueur_utile_limite);
6222: }
6223:
6224: sprintf(tampon, format, *((real8 *) valeur_numerique));
6225:
6226: i = (integer8) (strlen(tampon)) - 1;
6227: while(tampon[i] == '0')
6228: {
6229: tampon[i] = 0;
6230: i--;
6231: }
6232:
6233: if (ds_imposition_separateur_decimal == d_faux)
6234: {
6235: i = ((integer8) strlen(tampon)) - 1;
6236: if (tampon[i] == '.')
6237: {
6238: tampon[i] = 0;
6239: }
6240: }
6241: }
6242:
6243: strcpy(chaine, tampon);
6244: }
6245:
6246: if (longueur_champ >= 0)
6247: {
6248: if (strlen(chaine) > (size_t) longueur_champ)
6249: {
6250: for(i = 0; i < longueur_champ; i++)
6251: {
6252: chaine[i] = '*';
6253: }
6254:
6255: chaine[i] = d_code_fin_chaine;
6256: }
6257: }
6258:
6259: return(chaine);
6260: }
6261:
6262:
6263: /*
6264: --------------------------------------------------------------------------------
6265: Mêmes fonctions mais pour les fichiers binaires
6266: --------------------------------------------------------------------------------
6267: */
6268:
6269: unsigned char *
6270: formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,
6271: void *valeur_numerique, unsigned char type_entree,
6272: unsigned char type, integer8 longueur, integer8 *longueur_conversion)
6273: {
6274: unsigned char *chaine;
6275:
6276: switch(type)
6277: {
6278: case 'I' :
6279: {
6280: if (type_entree != type)
6281: {
6282: (*s_etat_processus).erreur_execution = d_ex_representation;
6283: return(NULL);
6284: }
6285:
6286: switch(longueur)
6287: {
6288: case 1:
6289: {
6290: if ((*((integer8 *) valeur_numerique)) !=
6291: ((integer1) (*((integer8 *) valeur_numerique))))
6292: {
6293: (*s_etat_processus).erreur_execution =
6294: d_ex_representation;
6295: return(NULL);
6296: }
6297:
6298: if ((chaine = malloc(2 * sizeof(unsigned char))) == NULL)
6299: {
6300: (*s_etat_processus).erreur_systeme =
6301: d_es_allocation_memoire;
6302: return(NULL);
6303: }
6304:
6305: (*longueur_conversion) = 2;
6306: chaine[0] = (unsigned char) 0x10;
6307: chaine[1] = (unsigned char) ((*((integer8 *)
6308: valeur_numerique)) & 0xFF);
6309: break;
6310: }
6311:
6312: case 2:
6313: {
6314: if ((*((integer8 *) valeur_numerique)) !=
6315: ((integer2) (*((integer8 *) valeur_numerique))))
6316: {
6317: (*s_etat_processus).erreur_execution =
6318: d_ex_representation;
6319: return(NULL);
6320: }
6321:
6322: if ((chaine = malloc(3 * sizeof(unsigned char))) == NULL)
6323: {
6324: (*s_etat_processus).erreur_systeme =
6325: d_es_allocation_memoire;
6326: return(NULL);
6327: }
6328:
6329: (*longueur_conversion) = 3;
6330: chaine[0] = (unsigned char) 0x11;
6331: chaine[1] = ((unsigned char) ((*((integer8 *)
6332: valeur_numerique)) >> 8) & 0xFF);
6333: chaine[2] = (unsigned char) ((*((integer8 *)
6334: valeur_numerique)) & 0xFF);
6335: break;
6336: }
6337:
6338: case 4:
6339: {
6340: if ((*((integer8 *) valeur_numerique)) !=
6341: ((integer4) (*((integer8 *) valeur_numerique))))
6342: {
6343: (*s_etat_processus).erreur_execution =
6344: d_ex_representation;
6345: return(NULL);
6346: }
6347:
6348: if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
6349: {
6350: (*s_etat_processus).erreur_systeme =
6351: d_es_allocation_memoire;
6352: return(NULL);
6353: }
6354:
6355: (*longueur_conversion) = 5;
6356: chaine[0] = (unsigned char) 0x12;
6357: chaine[1] = (unsigned char) (((*((integer8 *)
6358: valeur_numerique)) >> 24) & 0xFF);
6359: chaine[2] = (unsigned char) (((*((integer8 *)
6360: valeur_numerique)) >> 16) & 0xFF);
6361: chaine[3] = (unsigned char) (((*((integer8 *)
6362: valeur_numerique)) >> 8) & 0xFF);
6363: chaine[4] = (unsigned char) ((*((integer8 *)
6364: valeur_numerique)) & 0xFF);
6365: break;
6366: }
6367:
6368: case 8:
6369: {
6370: if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
6371: {
6372: (*s_etat_processus).erreur_systeme =
6373: d_es_allocation_memoire;
6374: return(NULL);
6375: }
6376:
6377: (*longueur_conversion) = 9;
6378: chaine[0] = (unsigned char) 0x13;
6379: chaine[1] = (unsigned char) (((*((integer8 *)
6380: valeur_numerique)) >> 56) & 0xFF);
6381: chaine[2] = (unsigned char) (((*((integer8 *)
6382: valeur_numerique)) >> 48) & 0xFF);
6383: chaine[3] = (unsigned char) (((*((integer8 *)
6384: valeur_numerique)) >> 40) & 0xFF);
6385: chaine[4] = (unsigned char) (((*((integer8 *)
6386: valeur_numerique)) >> 32) & 0xFF);
6387: chaine[5] = (unsigned char) (((*((integer8 *)
6388: valeur_numerique)) >> 24) & 0xFF);
6389: chaine[6] = (unsigned char) (((*((integer8 *)
6390: valeur_numerique)) >> 16) & 0xFF);
6391: chaine[7] = (unsigned char) (((*((integer8 *)
6392: valeur_numerique)) >> 8) & 0xFF);
6393: chaine[8] = (unsigned char) ((*((integer8 *)
6394: valeur_numerique)) & 0xFF);
6395: break;
6396: }
6397:
6398: default :
6399: {
6400: (*s_etat_processus).erreur_execution =
6401: d_ex_erreur_format_fichier;
6402: return(NULL);
6403: }
6404: }
6405:
6406: break;
6407: }
6408:
6409: case 'R' :
6410: {
6411: switch(longueur)
6412: {
6413: case 4:
6414: {
6415: real8 valeur;
6416: real8 vinf;
6417: real8 vsup;
6418:
6419: union
6420: {
6421: real4 r4;
6422: integer4 i4;
6423: } eq4;
6424:
6425: if (type_entree == 'R')
6426: {
6427: valeur = (*((real8 *) valeur_numerique));
6428: }
6429: else if (type_entree == 'I')
6430: {
6431: valeur = (real8) (*((integer8 *) valeur_numerique));
6432: }
6433: else
6434: {
6435: (*s_etat_processus).erreur_execution =
6436: d_ex_representation;
6437: return(NULL);
6438: }
6439:
6440: if (valeur > 0)
6441: {
6442: vinf = nextafter(valeur, 0);
6443: vsup = nextafter(valeur, valeur * 2);
6444: }
6445: else if (valeur < 0)
6446: {
6447: vinf = nextafter(valeur, valeur * 2);
6448: vsup = nextafter(valeur, 0);
6449: }
6450: else
6451: {
6452: vinf = valeur;
6453: vsup = valeur;
6454: }
6455:
6456: if (!((((real4) vinf) <= ((real4) valeur)) &&
6457: (((real4) valeur) <= ((real4) vsup))))
6458: {
6459: (*s_etat_processus).erreur_execution =
6460: d_ex_representation;
6461: return(NULL);
6462: }
6463:
6464: if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
6465: {
6466: (*s_etat_processus).erreur_systeme =
6467: d_es_allocation_memoire;
6468: return(NULL);
6469: }
6470:
6471: eq4.r4 = (real4) valeur;
6472: (*longueur_conversion) = 5;
6473: chaine[0] = (unsigned char) 0x14;
6474: chaine[1] = (unsigned char) ((eq4.i4 >> 24) & 0xFF);
6475: chaine[2] = (unsigned char) ((eq4.i4 >> 16) & 0xFF);
6476: chaine[3] = (unsigned char) ((eq4.i4 >> 8) & 0xFF);
6477: chaine[4] = (unsigned char) (eq4.i4 & 0xFF);
6478: break;
6479: }
6480:
6481: case 8:
6482: {
6483: union
6484: {
6485: real8 r8;
6486: integer8 i8;
6487: } eq8;
6488:
6489: if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
6490: {
6491: (*s_etat_processus).erreur_systeme =
6492: d_es_allocation_memoire;
6493: return(NULL);
6494: }
6495:
6496: if (type_entree == 'I')
6497: {
6498: eq8.r8 = (real8) (*((integer8 *) valeur_numerique));
6499: }
6500: else if (type_entree == 'R')
6501: {
6502: eq8.r8 = (*((real8 *) valeur_numerique));
6503: }
6504: else
6505: {
6506: (*s_etat_processus).erreur_execution =
6507: d_ex_representation;
6508: return(NULL);
6509: }
6510:
6511: (*longueur_conversion) = 9;
6512: chaine[0] = (unsigned char) (0x15);
6513: chaine[1] = (unsigned char) ((eq8.i8 >> 56) & 0xFF);
6514: chaine[2] = (unsigned char) ((eq8.i8 >> 48) & 0xFF);
6515: chaine[3] = (unsigned char) ((eq8.i8 >> 40) & 0xFF);
6516: chaine[4] = (unsigned char) ((eq8.i8 >> 32) & 0xFF);
6517: chaine[5] = (unsigned char) ((eq8.i8 >> 24) & 0xFF);
6518: chaine[6] = (unsigned char) ((eq8.i8 >> 16) & 0xFF);
6519: chaine[7] = (unsigned char) ((eq8.i8 >> 8) & 0xFF);
6520: chaine[8] = (unsigned char) (eq8.i8 & 0xFF);
6521: break;
6522: }
6523:
6524: default :
6525: {
6526: (*s_etat_processus).erreur_execution =
6527: d_ex_erreur_format_fichier;
6528: return(NULL);
6529: }
6530: }
6531:
6532: break;
6533: }
6534:
6535: case 'C' :
6536: {
6537: switch(longueur)
6538: {
6539: case 8:
6540: {
6541: unsigned char *partie_reelle;
6542: unsigned char *partie_imaginaire;
6543:
6544: integer8 limag;
6545: integer8 lreel;
6546:
6547: real8 zero;
6548:
6549: if (type_entree == 'I')
6550: {
6551: if ((partie_reelle = formateur_fichier_binaire_nombre(
6552: s_etat_processus, &(*((integer8 *)
6553: valeur_numerique)), 'I', 'R', 4,
6554: &lreel)) == NULL)
6555: {
6556: return(NULL);
6557: }
6558:
6559: zero = 0;
6560:
6561: if ((partie_imaginaire =
6562: formateur_fichier_binaire_nombre(
6563: s_etat_processus, &zero, 'R', 'R', 4,
6564: &limag)) == NULL)
6565: {
6566: free(partie_reelle);
6567: return(NULL);
6568: }
6569: }
6570: else if (type_entree == 'R')
6571: {
6572: if ((partie_reelle = formateur_fichier_binaire_nombre(
6573: s_etat_processus, &(*((real8 *)
6574: valeur_numerique)), 'R', 'R', 4,
6575: &lreel)) == NULL)
6576: {
6577: return(NULL);
6578: }
6579:
6580: zero = 0;
6581:
6582: if ((partie_imaginaire =
6583: formateur_fichier_binaire_nombre(
6584: s_etat_processus, &zero, 'R', 'R', 4,
6585: &limag)) == NULL)
6586: {
6587: free(partie_reelle);
6588: return(NULL);
6589: }
6590: }
6591: else if (type_entree == 'C')
6592: {
6593: if ((partie_reelle = formateur_fichier_binaire_nombre(
6594: s_etat_processus, &((*((complex16 *)
6595: valeur_numerique)).partie_reelle), 'R', 'R', 4,
6596: &lreel)) == NULL)
6597: {
6598: return(NULL);
6599: }
6600:
6601: if ((partie_imaginaire =
6602: formateur_fichier_binaire_nombre(
6603: s_etat_processus, &((*((complex16 *)
6604: valeur_numerique)).partie_imaginaire),
6605: 'R', 'R', 4, &limag)) == NULL)
6606: {
6607: free(partie_reelle);
6608: return(NULL);
6609: }
6610: }
6611: else
6612: {
6613: (*s_etat_processus).erreur_execution =
6614: d_ex_erreur_format_fichier;
6615: return(NULL);
6616: }
6617:
6618: if ((chaine = malloc((((size_t) lreel) + ((size_t) limag)
6619: - 1) * sizeof(unsigned char))) == NULL)
6620: {
6621: free(partie_reelle);
6622: free(partie_imaginaire);
6623:
6624: (*s_etat_processus).erreur_systeme =
6625: d_es_allocation_memoire;
6626: return(NULL);
6627: }
6628:
6629: chaine[0] = (unsigned char) 0x18;
6630: memcpy(chaine + 1, partie_reelle + 1,
6631: ((size_t) lreel) - 1);
6632: memcpy(chaine + lreel, partie_imaginaire + 1,
6633: ((size_t) limag) - 1);
6634: (*longueur_conversion) = lreel + limag - 1;
6635:
6636: free(partie_reelle);
6637: free(partie_imaginaire);
6638: break;
6639: }
6640:
6641: case 16:
6642: {
6643: unsigned char *partie_reelle;
6644: unsigned char *partie_imaginaire;
6645:
6646: integer8 limag;
6647: integer8 lreel;
6648:
6649: real8 zero;
6650:
6651: if (type_entree == 'I')
6652: {
6653: if ((partie_reelle = formateur_fichier_binaire_nombre(
6654: s_etat_processus, &(*((integer8 *)
6655: valeur_numerique)), 'I', 'R', 8,
6656: &lreel)) == NULL)
6657: {
6658: return(NULL);
6659: }
6660:
6661: zero = 0;
6662:
6663: if ((partie_imaginaire =
6664: formateur_fichier_binaire_nombre(
6665: s_etat_processus, &zero, 'R', 'R', 8,
6666: &limag)) == NULL)
6667: {
6668: free(partie_reelle);
6669: return(NULL);
6670: }
6671: }
6672: else if (type_entree == 'R')
6673: {
6674: if ((partie_reelle = formateur_fichier_binaire_nombre(
6675: s_etat_processus, &(*((real8 *)
6676: valeur_numerique)), 'R', 'R', 8,
6677: &lreel)) == NULL)
6678: {
6679: return(NULL);
6680: }
6681:
6682: zero = 0;
6683:
6684: if ((partie_imaginaire =
6685: formateur_fichier_binaire_nombre(
6686: s_etat_processus, &zero, 'R', 'R', 8,
6687: &limag)) == NULL)
6688: {
6689: free(partie_reelle);
6690: return(NULL);
6691: }
6692: }
6693: else if (type_entree == 'C')
6694: {
6695: if ((partie_reelle = formateur_fichier_binaire_nombre(
6696: s_etat_processus, &((*((complex16 *)
6697: valeur_numerique)).partie_reelle), 'R', 'R', 8,
6698: &lreel)) == NULL)
6699: {
6700: return(NULL);
6701: }
6702:
6703: if ((partie_imaginaire =
6704: formateur_fichier_binaire_nombre(
6705: s_etat_processus, &((*((complex16 *)
6706: valeur_numerique)).partie_imaginaire),
6707: 'R', 'R', 8, &limag)) == NULL)
6708: {
6709: free(partie_reelle);
6710: return(NULL);
6711: }
6712: }
6713: else
6714: {
6715: (*s_etat_processus).erreur_execution =
6716: d_ex_erreur_format_fichier;
6717: return(NULL);
6718: }
6719:
6720: if ((chaine = malloc((((size_t) lreel) + ((size_t) limag)
6721: - 1) * sizeof(unsigned char))) == NULL)
6722: {
6723: free(partie_reelle);
6724: free(partie_imaginaire);
6725:
6726: (*s_etat_processus).erreur_systeme =
6727: d_es_allocation_memoire;
6728: return(NULL);
6729: }
6730:
6731: chaine[0] = (unsigned char) 0x19;
6732: memcpy(chaine + 1, partie_reelle + 1,
6733: ((size_t) lreel) - 1);
6734: memcpy(chaine + lreel, partie_imaginaire + 1,
6735: ((size_t) limag) - 1);
6736: (*longueur_conversion) = lreel + limag - 1;
6737:
6738: free(partie_reelle);
6739: free(partie_imaginaire);
6740: break;
6741: }
6742:
6743: default :
6744: {
6745: (*s_etat_processus).erreur_execution =
6746: d_ex_erreur_format_fichier;
6747: return(NULL);
6748: }
6749: }
6750:
6751: break;
6752: }
6753:
6754: default :
6755: {
6756: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
6757: return(NULL);
6758: }
6759: }
6760:
6761: return(chaine);
6762: }
6763:
6764:
6765: /*
6766: ================================================================================
6767: Routines de conversion d'un objet binaire en struct_objet *
6768: ================================================================================
6769: Entrées : pointeur sur un void *. Si longueur_buffer est strictement inférieur
6770: à zéro, il s'agit d'un file * sinon d'un buffer de type unsigned
6771: char *.
6772: --------------------------------------------------------------------------------
6773: Sorties : pointeur sur un struct_objet nouvellement alloué
6774: --------------------------------------------------------------------------------
6775: Effets de bord : néant
6776: ================================================================================
6777: */
6778:
6779: struct_objet *
6780: lecture_fichier_non_formate(struct_processus *s_etat_processus,
6781: void *argument, integer8 longueur_buffer, logical1 recursivite)
6782: {
6783: file *fichier;
6784:
6785: int j;
6786:
6787: integer8 i;
6788: integer8 longueur;
6789:
6790: struct_liste_chainee *l_element_courant;
6791:
6792: struct_objet *s_objet;
6793: struct_objet *s_objet_elementaire;
6794:
6795: unsigned char octets[8];
6796: unsigned char *buffer;
6797: unsigned char *flux;
6798: unsigned char *ptr;
6799: unsigned char type_objet;
6800:
6801: size_t deplacement;
6802:
6803: if (longueur_buffer < 0)
6804: {
6805: fichier = argument;
6806: buffer = NULL;
6807: ptr = NULL;
6808: }
6809: else
6810: {
6811: buffer = (*((unsigned char **) argument));
6812: ptr = buffer;
6813: fichier = NULL;
6814: }
6815:
6816: if (longueur_buffer < 0)
6817: {
6818: if (fread(octets, (size_t) sizeof(unsigned char),
6819: 1, fichier) != 1)
6820: {
6821: if (feof(fichier))
6822: {
6823: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
6824: }
6825: else
6826: {
6827: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
6828: }
6829:
6830: return(NULL);
6831: }
6832: }
6833: else
6834: {
6835: if ((longueur_buffer - (ptr - buffer)) >= 1)
6836: {
6837: octets[0] = *ptr++;
6838: }
6839: else
6840: {
6841: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
6842: return(NULL);
6843: }
6844: }
6845:
6846: switch(type_objet = (octets[0] & 0xF0))
6847: {
6848: case 0x00: // Binaire
6849: {
6850: switch(octets[0] & 0x0F)
6851: {
6852: case 0x01: // logical*1
6853: {
6854: deplacement = 1;
6855: break;
6856: }
6857:
6858: case 0x02: // logical*2
6859: {
6860: deplacement = 2;
6861: break;
6862: }
6863:
6864: case 0x04: // logical*4
6865: {
6866: deplacement = 4;
6867: break;
6868: }
6869:
6870: case 0x08: // logical*8
6871: {
6872: deplacement = 8;
6873: break;
6874: }
6875:
6876: default:
6877: {
6878: (*s_etat_processus).erreur_execution =
6879: d_ex_syntaxe;
6880: return(NULL);
6881: }
6882: }
6883:
6884: if (longueur_buffer < 0)
6885: {
6886: if (fread(octets, (size_t) sizeof(unsigned char),
6887: deplacement, fichier) != deplacement)
6888: {
6889: if (feof(fichier))
6890: {
6891: (*s_etat_processus).erreur_execution =
6892: d_ex_syntaxe;
6893: }
6894: else
6895: {
6896: (*s_etat_processus).erreur_systeme =
6897: d_es_erreur_fichier;
6898: }
6899:
6900: return(NULL);
6901: }
6902: }
6903: else
6904: {
6905: if ((longueur_buffer - (ptr - buffer)) >=
6906: (ssize_t) deplacement)
6907: {
6908: for(i = 0; i < (signed) deplacement; i++)
6909: {
6910: octets[i] = *ptr++;
6911: }
6912: }
6913: else
6914: {
6915: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
6916: return(NULL);
6917: }
6918: }
6919:
6920: if ((s_objet = allocation(s_etat_processus, BIN)) == NULL)
6921: {
6922: return(NULL);
6923: }
6924:
6925: (*((logical8 *) (*s_objet).objet)) = 0;
6926:
6927: for(i = 0; i < (signed) deplacement; i++)
6928: {
6929: (*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i])
6930: << (8 * ((((signed) deplacement) - 1) - i));
6931: }
6932:
6933: break;
6934: }
6935:
6936: case 0x10: // Scalaire
6937: {
6938: switch(octets[0] & 0x0C)
6939: {
6940: case 0x00: // Entier
6941: {
6942: switch(octets[0] & 0x03)
6943: {
6944: case 0x00: // integer*1
6945: {
6946: deplacement = 1;
6947: break;
6948: }
6949:
6950: case 0x01: // integer*2
6951: {
6952: deplacement = 2;
6953: break;
6954: }
6955:
6956: case 0x02: // integer*4
6957: {
6958: deplacement = 4;
6959: break;
6960: }
6961:
6962: case 0x03: // integer*8
6963: {
6964: deplacement = 8;
6965: break;
6966: }
6967: }
6968:
6969: if (longueur_buffer < 0)
6970: {
6971: if (fread(octets, (size_t) sizeof(unsigned char),
6972: deplacement, fichier) != deplacement)
6973: {
6974: if (feof(fichier))
6975: {
6976: (*s_etat_processus).erreur_execution =
6977: d_ex_syntaxe;
6978: }
6979: else
6980: {
6981: (*s_etat_processus).erreur_systeme =
6982: d_es_erreur_fichier;
6983: }
6984:
6985: return(NULL);
6986: }
6987: }
6988: else
6989: {
6990: if ((longueur_buffer - (ptr - buffer)) >=
6991: (ssize_t) deplacement)
6992: {
6993: for(i = 0; i < (signed) deplacement; i++)
6994: {
6995: octets[i] = *ptr++;
6996: }
6997: }
6998: else
6999: {
7000: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
7001: return(NULL);
7002: }
7003: }
7004:
7005: if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
7006: {
7007: return(NULL);
7008: }
7009:
7010: // Récupération des données avec extension de signe.
7011:
7012: {
7013: integer1 i1;
7014: integer2 i2;
7015: integer4 i4;
7016: integer8 i8;
7017:
7018: i1 = 0;
7019: i2 = 0;
7020: i4 = 0;
7021: i8 = 0;
7022:
7023: for(i = 0; i < (signed) deplacement; i++)
7024: {
7025: switch(deplacement)
7026: {
7027: case 1:
7028: i1 = (integer1) octets[0];
7029: break;
7030:
7031: case 2:
7032: i2 |= (integer2) (((integer8) octets[i]) <<
7033: (8 * ((((signed) deplacement) - 1)
7034: - i)));
7035: break;
7036:
7037: case 4:
7038: i4 |= (integer4) (((integer8) octets[i]) <<
7039: (8 * ((((signed) deplacement) - 1)
7040: - i)));
7041: break;
7042:
7043: case 8:
7044: i8 |= (integer8) (((integer8) octets[i]) <<
7045: (8 * ((((signed) deplacement) - 1)
7046: - i)));
7047: break;
7048: }
7049: }
7050:
7051: switch(deplacement)
7052: {
7053: case 1:
7054: (*((integer8 *) (*s_objet).objet)) =
7055: (integer8) i1;
7056: break;
7057:
7058: case 2:
7059: (*((integer8 *) (*s_objet).objet)) =
7060: (integer8) i2;
7061: break;
7062:
7063: case 4:
7064: (*((integer8 *) (*s_objet).objet)) =
7065: (integer8) i4;
7066: break;
7067:
7068: case 8:
7069: (*((integer8 *) (*s_objet).objet)) =
7070: (integer8) i8;
7071: break;
7072: }
7073: }
7074:
7075: break;
7076: }
7077:
7078: case 0x04: // Réel
7079: {
7080: switch(octets[0] & 0x03)
7081: {
7082: case 0x00: // real*4
7083: {
7084: deplacement = 4;
7085: break;
7086: }
7087:
7088: case 0x01: // real*8
7089: {
7090: deplacement = 8;
7091: break;
7092: }
7093:
7094: default:
7095: {
7096: (*s_etat_processus).erreur_execution =
7097: d_ex_syntaxe;
7098: return(NULL);
7099: }
7100: }
7101:
7102: if (longueur_buffer < 0)
7103: {
7104: if (fread(octets, (size_t) sizeof(unsigned char),
7105: deplacement, fichier) != deplacement)
7106: {
7107: if (feof(fichier))
7108: {
7109: (*s_etat_processus).erreur_execution =
7110: d_ex_syntaxe;
7111: }
7112: else
7113: {
7114: (*s_etat_processus).erreur_systeme =
7115: d_es_erreur_fichier;
7116: }
7117:
7118: return(NULL);
7119: }
7120: }
7121: else
7122: {
7123: if ((longueur_buffer - (ptr - buffer)) >=
7124: (ssize_t) deplacement)
7125: {
7126: for(i = 0; i < (signed) deplacement; i++)
7127: {
7128: octets[i] = *ptr++;
7129: }
7130: }
7131: else
7132: {
7133: (*s_etat_processus).erreur_execution =
7134: d_ex_syntaxe;
7135: return(NULL);
7136: }
7137: }
7138:
7139: if ((s_objet = allocation(s_etat_processus, REL)) == NULL)
7140: {
7141: return(NULL);
7142: }
7143:
7144: if (deplacement == 4)
7145: {
7146: union
7147: {
7148: real4 r4;
7149: integer4 i4;
7150: } eq4;
7151:
7152: eq4.i4 = 0;
7153:
7154: for(i = 0; i < (signed) deplacement; i++)
7155: {
7156: eq4.i4 |= ((integer4) octets[i]) <<
7157: (8 * ((((signed) deplacement) - 1) - i));
7158: }
7159:
7160: (*((real8 *) (*s_objet).objet)) = (real8) eq4.r4;
7161: }
7162: else
7163: {
7164: union
7165: {
7166: real8 r8;
7167: integer8 i8;
7168: } eq8;
7169:
7170: eq8.i8 = 0;
7171:
7172: for(i = 0; i < (signed) deplacement; i++)
7173: {
7174: eq8.i8 |= ((integer8) octets[i]) <<
7175: (8 * ((((signed) deplacement) - 1) - i));
7176: }
7177:
7178: (*((real8 *) (*s_objet).objet)) = (real8) eq8.r8;
7179: }
7180:
7181: break;
7182: }
7183:
7184: case 0x08: // Complexe
7185: {
7186: switch(octets[0] & 0x03)
7187: {
7188: case 0x00: // complex*8
7189: {
7190: deplacement = 4;
7191: break;
7192: }
7193:
7194: case 0x01: // complex*16
7195: {
7196: deplacement = 8;
7197: break;
7198: }
7199:
7200: default:
7201: {
7202: (*s_etat_processus).erreur_execution =
7203: d_ex_syntaxe;
7204: return(NULL);
7205: }
7206: }
7207:
7208: if ((s_objet = allocation(s_etat_processus, CPL)) == NULL)
7209: {
7210: return(NULL);
7211: }
7212:
7213: for(j = 0; j < 2; j++)
7214: {
7215: if (longueur_buffer < 0)
7216: {
7217: if (fread(octets, (size_t) sizeof(unsigned char),
7218: deplacement, fichier) != deplacement)
7219: {
7220: liberation(s_etat_processus, s_objet);
7221:
7222: if (feof(fichier))
7223: {
7224: (*s_etat_processus).erreur_execution =
7225: d_ex_syntaxe;
7226: }
7227: else
7228: {
7229: (*s_etat_processus).erreur_systeme =
7230: d_es_erreur_fichier;
7231: }
7232:
7233: return(NULL);
7234: }
7235: }
7236: else
7237: {
7238: if ((longueur_buffer - (ptr - buffer)) >=
7239: (ssize_t) deplacement)
7240: {
7241: for(i = 0; i < (signed) deplacement; i++)
7242: {
7243: octets[i] = *ptr++;
7244: }
7245: }
7246: else
7247: {
7248: liberation(s_etat_processus, s_objet);
7249: (*s_etat_processus).erreur_execution =
7250: d_ex_syntaxe;
7251: return(NULL);
7252: }
7253: }
7254:
7255: if (deplacement == 4)
7256: {
7257: union
7258: {
7259: real4 r4;
7260: integer4 i4;
7261: } eq4;
7262:
7263: eq4.i4 = 0;
7264:
7265: for(i = 0; i < (signed) deplacement; i++)
7266: {
7267: eq4.i4 |= ((integer4) octets[i]) <<
7268: (8 * ((((signed) deplacement) - 1)
7269: - i));
7270: }
7271:
7272: if (j == 0)
7273: {
7274: (*((complex16 *) (*s_objet).objet))
7275: .partie_reelle = (real8) eq4.r4;
7276: }
7277: else
7278: {
7279: (*((complex16 *) (*s_objet).objet))
7280: .partie_imaginaire = (real8) eq4.r4;
7281: }
7282: }
7283: else
7284: {
7285: union
7286: {
7287: real8 r8;
7288: integer8 i8;
7289: } eq8;
7290:
7291: eq8.i8 = 0;
7292:
7293: for(i = 0; i < (signed) deplacement; i++)
7294: {
7295: eq8.i8 |= ((integer8) octets[i]) <<
7296: (8 * ((((signed) deplacement) - 1)
7297: - i));
7298: }
7299:
7300: if (j == 0)
7301: {
7302: (*((complex16 *) (*s_objet).objet))
7303: .partie_reelle = (real8) eq8.r8;
7304: }
7305: else
7306: {
7307: (*((complex16 *) (*s_objet).objet))
7308: .partie_imaginaire = (real8) eq8.r8;
7309: }
7310: }
7311: }
7312:
7313: break;
7314: }
7315:
7316: default:
7317: {
7318: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
7319: return(NULL);
7320: }
7321: }
7322:
7323: break;
7324: }
7325:
7326: case 0x40: // Liste
7327: case 0x60: // Expression
7328: case 0x70: // Expression algébrique
7329: {
7330: if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits
7331: {
7332: longueur = (octets[0] & 0x07);
7333: }
7334: else
7335: {
7336: switch(octets[0] & 0x07)
7337: {
7338: case 0x00: // Longueur sur 8 bits
7339: {
7340: if (longueur_buffer < 0)
7341: {
7342: if (fread(octets, (size_t) sizeof(unsigned char),
7343: 1, fichier) != 1)
7344: {
7345: if (feof(fichier))
7346: {
7347: (*s_etat_processus).erreur_execution =
7348: d_ex_syntaxe;
7349: }
7350: else
7351: {
7352: (*s_etat_processus).erreur_systeme =
7353: d_es_erreur_fichier;
7354: }
7355:
7356: return(NULL);
7357: }
7358: }
7359: else
7360: {
7361: if ((longueur_buffer - (ptr - buffer)) >= 1)
7362: {
7363: octets[0] = *ptr++;
7364: }
7365: else
7366: {
7367: (*s_etat_processus).erreur_execution =
7368: d_ex_syntaxe;
7369: return(NULL);
7370: }
7371: }
7372:
7373: longueur = octets[0];
7374: break;
7375: }
7376:
7377: case 0x01: // Longueur sur 16 bits
7378: {
7379: if (longueur_buffer < 0)
7380: {
7381: if (fread(octets, (size_t) sizeof(unsigned char),
7382: 2, fichier) != 2)
7383: {
7384: if (feof(fichier))
7385: {
7386: (*s_etat_processus).erreur_execution =
7387: d_ex_syntaxe;
7388: }
7389: else
7390: {
7391: (*s_etat_processus).erreur_systeme =
7392: d_es_erreur_fichier;
7393: }
7394:
7395: return(NULL);
7396: }
7397: }
7398: else
7399: {
7400: if ((longueur_buffer - (ptr - buffer)) >= 2)
7401: {
7402: for(j = 0; j < 2; octets[j++] = *ptr++);
7403: }
7404: else
7405: {
7406: (*s_etat_processus).erreur_execution =
7407: d_ex_syntaxe;
7408: return(NULL);
7409: }
7410: }
7411:
7412: longueur = (((integer8) (octets[0])) << 8)
7413: | ((integer8) (octets[1]));
7414: break;
7415: }
7416:
7417: case 0x02: // Longueur sur 32 bits
7418: {
7419: if (longueur_buffer < 0)
7420: {
7421: if (fread(octets, (size_t) sizeof(unsigned char),
7422: 4, fichier) != 4)
7423: {
7424: if (feof(fichier))
7425: {
7426: (*s_etat_processus).erreur_execution =
7427: d_ex_syntaxe;
7428: }
7429: else
7430: {
7431: (*s_etat_processus).erreur_systeme =
7432: d_es_erreur_fichier;
7433: }
7434:
7435: return(NULL);
7436: }
7437: }
7438: else
7439: {
7440: if ((longueur_buffer - (ptr - buffer)) >= 4)
7441: {
7442: for(j = 0; j < 4; octets[j++] = *ptr++);
7443: }
7444: else
7445: {
7446: (*s_etat_processus).erreur_execution =
7447: d_ex_syntaxe;
7448: return(NULL);
7449: }
7450: }
7451:
7452: longueur = (((integer8) (octets[0])) << 24)
7453: | (((integer8) (octets[1])) << 16)
7454: | (((integer8) (octets[2])) << 8)
7455: | ((integer8) (octets[3]));
7456: break;
7457: }
7458:
7459: case 0x03: // Longueur sur 64 bits
7460: {
7461: if (longueur_buffer < 0)
7462: {
7463: if (fread(octets, (size_t) sizeof(unsigned char),
7464: 8, fichier) != 8)
7465: {
7466: if (feof(fichier))
7467: {
7468: (*s_etat_processus).erreur_execution =
7469: d_ex_syntaxe;
7470: }
7471: else
7472: {
7473: (*s_etat_processus).erreur_systeme =
7474: d_es_erreur_fichier;
7475: }
7476:
7477: return(NULL);
7478: }
7479: }
7480: else
7481: {
7482: if ((longueur_buffer - (ptr - buffer)) >= 8)
7483: {
7484: for(j = 0; j < 8; octets[j++] = *ptr++);
7485: }
7486: else
7487: {
7488: (*s_etat_processus).erreur_execution =
7489: d_ex_syntaxe;
7490: return(NULL);
7491: }
7492: }
7493:
7494: longueur = (((integer8) (octets[0])) << 56)
7495: | (((integer8) (octets[1])) << 48)
7496: | (((integer8) (octets[2])) << 40)
7497: | (((integer8) (octets[3])) << 32)
7498: | (((integer8) (octets[4])) << 24)
7499: | (((integer8) (octets[5])) << 16)
7500: | (((integer8) (octets[6])) << 8)
7501: | ((integer8) (octets[7]));
7502: break;
7503: }
7504:
7505: default:
7506: {
7507: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
7508: return(NULL);
7509: }
7510: }
7511: }
7512:
7513: if (type_objet == 0x40)
7514: {
7515: if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
7516: {
7517: return(NULL);
7518: }
7519: }
7520: else if (type_objet == 0x60)
7521: {
7522: if ((s_objet = allocation(s_etat_processus, RPN)) == NULL)
7523: {
7524: return(NULL);
7525: }
7526: }
7527: else
7528: {
7529: if ((s_objet = allocation(s_etat_processus, ALG)) == NULL)
7530: {
7531: return(NULL);
7532: }
7533: }
7534:
7535: l_element_courant = NULL;
7536:
7537: for(i = 0; i < longueur; i++)
7538: {
7539: // Lecture des éléments de la liste.
7540:
7541: if (longueur_buffer < 0)
7542: {
7543: if ((s_objet_elementaire = lecture_fichier_non_formate(
7544: s_etat_processus, fichier, longueur_buffer, d_vrai))
7545: == NULL)
7546: {
7547: liberation(s_etat_processus, s_objet);
7548: return(NULL);
7549: }
7550: }
7551: else
7552: {
7553: if ((s_objet_elementaire = lecture_fichier_non_formate(
7554: s_etat_processus, &ptr,
7555: longueur_buffer - (ptr - buffer), d_vrai)) == NULL)
7556: {
7557: liberation(s_etat_processus, s_objet);
7558: return(NULL);
7559: }
7560: }
7561:
7562: if (l_element_courant == NULL)
7563: {
7564: if (((*s_objet).objet = allocation_maillon(
7565: s_etat_processus)) == NULL)
7566: {
7567: liberation(s_etat_processus, s_objet_elementaire);
7568: liberation(s_etat_processus, s_objet);
7569: return(NULL);
7570: }
7571:
7572: l_element_courant = (*s_objet).objet;
7573: }
7574: else
7575: {
7576: if (((*l_element_courant).suivant = allocation_maillon(
7577: s_etat_processus)) == NULL)
7578: {
7579: liberation(s_etat_processus, s_objet_elementaire);
7580: liberation(s_etat_processus, s_objet);
7581: return(NULL);
7582: }
7583:
7584: l_element_courant = (*l_element_courant).suivant;
7585: }
7586:
7587: (*l_element_courant).donnee = s_objet_elementaire;
7588: (*l_element_courant).suivant = NULL;
7589: }
7590:
7591: break;
7592: }
7593:
7594: case 0x80: // Chaîne de caractères
7595: {
7596: if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits
7597: {
7598: longueur = (octets[0] & 0x07);
7599: }
7600: else
7601: {
7602: switch(octets[0] & 0x07)
7603: {
7604: case 0x00: // Longueur sur 8 bits
7605: {
7606: if (longueur_buffer < 0)
7607: {
7608: if (fread(octets, (size_t) sizeof(unsigned char),
7609: 1, fichier) != 1)
7610: {
7611: if (feof(fichier))
7612: {
7613: (*s_etat_processus).erreur_execution =
7614: d_ex_syntaxe;
7615: }
7616: else
7617: {
7618: (*s_etat_processus).erreur_systeme =
7619: d_es_erreur_fichier;
7620: }
7621:
7622: return(NULL);
7623: }
7624: }
7625: else
7626: {
7627: if ((longueur_buffer - (ptr - buffer)) >= 1)
7628: {
7629: octets[0] = *ptr++;
7630: }
7631: else
7632: {
7633: (*s_etat_processus).erreur_execution =
7634: d_ex_syntaxe;
7635: return(NULL);
7636: }
7637: }
7638:
7639: longueur = octets[0];
7640: break;
7641: }
7642:
7643: case 0x01: // Longueur sur 16 bits
7644: {
7645: if (longueur_buffer < 0)
7646: {
7647: if (fread(octets, (size_t) sizeof(unsigned char),
7648: 2, fichier) != 2)
7649: {
7650: if (feof(fichier))
7651: {
7652: (*s_etat_processus).erreur_execution =
7653: d_ex_syntaxe;
7654: }
7655: else
7656: {
7657: (*s_etat_processus).erreur_systeme =
7658: d_es_erreur_fichier;
7659: }
7660:
7661: return(NULL);
7662: }
7663: }
7664: else
7665: {
7666: if ((longueur_buffer - (ptr - buffer)) >= 2)
7667: {
7668: for(j = 0; j < 2; octets[j++] = *ptr++);
7669: }
7670: else
7671: {
7672: (*s_etat_processus).erreur_execution =
7673: d_ex_syntaxe;
7674: return(NULL);
7675: }
7676: }
7677:
7678: longueur = (((integer8) (octets[0])) << 8)
7679: | ((integer8) (octets[1]));
7680: break;
7681: }
7682:
7683: case 0x02: // Longueur sur 32 bits
7684: {
7685: if (longueur_buffer < 0)
7686: {
7687: if (fread(octets, (size_t) sizeof(unsigned char),
7688: 4, fichier) != 4)
7689: {
7690: if (feof(fichier))
7691: {
7692: (*s_etat_processus).erreur_execution =
7693: d_ex_syntaxe;
7694: }
7695: else
7696: {
7697: (*s_etat_processus).erreur_systeme =
7698: d_es_erreur_fichier;
7699: }
7700:
7701: return(NULL);
7702: }
7703: }
7704: else
7705: {
7706: if ((longueur_buffer - (ptr - buffer)) >= 4)
7707: {
7708: for(j = 0; j < 4; octets[j++] = *ptr++);
7709: }
7710: else
7711: {
7712: (*s_etat_processus).erreur_execution =
7713: d_ex_syntaxe;
7714: return(NULL);
7715: }
7716: }
7717:
7718: longueur = (((integer8) (octets[0])) << 24)
7719: | (((integer8) (octets[1])) << 16)
7720: | (((integer8) (octets[2])) << 8)
7721: | ((integer8) (octets[3]));
7722: break;
7723: }
7724:
7725: case 0x03: // Longueur sur 64 bits
7726: {
7727: if (longueur_buffer < 0)
7728: {
7729: if (fread(octets, (size_t) sizeof(unsigned char),
7730: 8, fichier) != 8)
7731: {
7732: if (feof(fichier))
7733: {
7734: (*s_etat_processus).erreur_execution =
7735: d_ex_syntaxe;
7736: }
7737: else
7738: {
7739: (*s_etat_processus).erreur_systeme =
7740: d_es_erreur_fichier;
7741: }
7742:
7743: return(NULL);
7744: }
7745: }
7746: else
7747: {
7748: if ((longueur_buffer - (ptr - buffer)) >= 8)
7749: {
7750: for(j = 0; j < 8; octets[j++] = *ptr++);
7751: }
7752: else
7753: {
7754: (*s_etat_processus).erreur_execution =
7755: d_ex_syntaxe;
7756: return(NULL);
7757: }
7758: }
7759:
7760: longueur = (((integer8) (octets[0])) << 56)
7761: | (((integer8) (octets[1])) << 48)
7762: | (((integer8) (octets[2])) << 40)
7763: | (((integer8) (octets[3])) << 32)
7764: | (((integer8) (octets[4])) << 24)
7765: | (((integer8) (octets[5])) << 16)
7766: | (((integer8) (octets[6])) << 8)
7767: | ((integer8) (octets[7]));
7768: break;
7769: }
7770:
7771: default:
7772: {
7773: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
7774: return(NULL);
7775: }
7776: }
7777: }
7778:
7779: if (longueur_buffer < 0)
7780: {
7781: if ((flux = malloc(((size_t) longueur) * sizeof(unsigned char)))
7782: == NULL)
7783: {
7784: (*s_etat_processus).erreur_systeme =
7785: d_es_allocation_memoire;
7786: return(NULL);
7787: }
7788:
7789: if (fread(flux, (size_t) sizeof(unsigned char),
7790: (size_t) longueur, fichier) != (size_t) longueur)
7791: {
7792: if (feof(fichier))
7793: {
7794: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
7795: }
7796: else
7797: {
7798: (*s_etat_processus).erreur_systeme =
7799: d_es_erreur_fichier;
7800: }
7801:
7802: return(NULL);
7803: }
7804: }
7805: else
7806: {
7807: if ((longueur_buffer - (ptr - buffer)) < longueur)
7808: {
7809: (*s_etat_processus).erreur_execution =
7810: d_ex_syntaxe;
7811: return(NULL);
7812: }
7813:
7814: flux = ptr;
7815: ptr += longueur;
7816: }
7817:
7818: if ((s_objet = allocation(s_etat_processus, CHN)) == NULL)
7819: {
7820: if (longueur_buffer < 0)
7821: {
7822: free(flux);
7823: }
7824:
7825: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
7826: return(NULL);
7827: }
7828:
7829: if (((*s_objet).objet = analyse_flux(s_etat_processus, flux,
7830: longueur)) == NULL)
7831: {
7832: return(NULL);
7833: }
7834:
7835: if (longueur_buffer < 0)
7836: {
7837: free(flux);
7838: }
7839:
7840: break;
7841: }
7842:
7843: case 0x50: // Nom
7844: {
7845: if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits
7846: {
7847: longueur = (octets[0] & 0x07);
7848: }
7849: else
7850: {
7851: switch(octets[0] & 0x07)
7852: {
7853: case 0x00: // Longueur sur 8 bits
7854: {
7855: if (longueur_buffer < 0)
7856: {
7857: if (fread(octets, (size_t) sizeof(unsigned char),
7858: 1, fichier) != 1)
7859: {
7860: if (feof(fichier))
7861: {
7862: (*s_etat_processus).erreur_execution =
7863: d_ex_syntaxe;
7864: }
7865: else
7866: {
7867: (*s_etat_processus).erreur_systeme =
7868: d_es_erreur_fichier;
7869: }
7870:
7871: return(NULL);
7872: }
7873: }
7874: else
7875: {
7876: if ((longueur_buffer - (ptr - buffer)) >= 1)
7877: {
7878: octets[0] = *ptr++;
7879: }
7880: else
7881: {
7882: (*s_etat_processus).erreur_execution =
7883: d_ex_syntaxe;
7884: return(NULL);
7885: }
7886: }
7887:
7888: longueur = octets[0];
7889: break;
7890: }
7891:
7892: case 0x01: // Longueur sur 16 bits
7893: {
7894: if (longueur_buffer < 0)
7895: {
7896: if (fread(octets, (size_t) sizeof(unsigned char),
7897: 2, fichier) != 2)
7898: {
7899: if (feof(fichier))
7900: {
7901: (*s_etat_processus).erreur_execution =
7902: d_ex_syntaxe;
7903: }
7904: else
7905: {
7906: (*s_etat_processus).erreur_systeme =
7907: d_es_erreur_fichier;
7908: }
7909:
7910: return(NULL);
7911: }
7912: }
7913: else
7914: {
7915: if ((longueur_buffer - (ptr - buffer)) >= 2)
7916: {
7917: for(j = 0; j < 2; octets[j++] = *ptr++);
7918: }
7919: else
7920: {
7921: (*s_etat_processus).erreur_execution =
7922: d_ex_syntaxe;
7923: return(NULL);
7924: }
7925: }
7926:
7927: longueur = (((integer8) (octets[0])) << 8)
7928: | ((integer8) (octets[1]));
7929: break;
7930: }
7931:
7932: case 0x02: // Longueur sur 32 bits
7933: {
7934: if (longueur_buffer < 0)
7935: {
7936: if (fread(octets, (size_t) sizeof(unsigned char),
7937: 4, fichier) != 4)
7938: {
7939: if (feof(fichier))
7940: {
7941: (*s_etat_processus).erreur_execution =
7942: d_ex_syntaxe;
7943: }
7944: else
7945: {
7946: (*s_etat_processus).erreur_systeme =
7947: d_es_erreur_fichier;
7948: }
7949:
7950: return(NULL);
7951: }
7952: }
7953: else
7954: {
7955: if ((longueur_buffer - (ptr - buffer)) >= 4)
7956: {
7957: for(j = 0; j < 4; octets[j++] = *ptr++);
7958: }
7959: else
7960: {
7961: (*s_etat_processus).erreur_execution =
7962: d_ex_syntaxe;
7963: return(NULL);
7964: }
7965: }
7966:
7967: longueur = (((integer8) (octets[0])) << 24)
7968: | (((integer8) (octets[1])) << 16)
7969: | (((integer8) (octets[2])) << 8)
7970: | ((integer8) (octets[3]));
7971: break;
7972: }
7973:
7974: case 0x03: // Longueur sur 64 bits
7975: {
7976: if (longueur_buffer < 0)
7977: {
7978: if (fread(octets, (size_t) sizeof(unsigned char),
7979: 8, fichier) != 8)
7980: {
7981: if (feof(fichier))
7982: {
7983: (*s_etat_processus).erreur_execution =
7984: d_ex_syntaxe;
7985: }
7986: else
7987: {
7988: (*s_etat_processus).erreur_systeme =
7989: d_es_erreur_fichier;
7990: }
7991:
7992: return(NULL);
7993: }
7994: }
7995: else
7996: {
7997: if ((longueur_buffer - (ptr - buffer)) >= 8)
7998: {
7999: for(j = 0; j < 8; octets[j++] = *ptr++);
8000: }
8001: else
8002: {
8003: (*s_etat_processus).erreur_execution =
8004: d_ex_syntaxe;
8005: return(NULL);
8006: }
8007: }
8008:
8009: longueur = (((integer8) (octets[0])) << 56)
8010: | (((integer8) (octets[1])) << 48)
8011: | (((integer8) (octets[2])) << 40)
8012: | (((integer8) (octets[3])) << 32)
8013: | (((integer8) (octets[4])) << 24)
8014: | (((integer8) (octets[5])) << 16)
8015: | (((integer8) (octets[6])) << 8)
8016: | ((integer8) (octets[7]));
8017: break;
8018: }
8019:
8020: default:
8021: {
8022: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
8023: return(NULL);
8024: }
8025: }
8026: }
8027:
8028: if ((s_objet = allocation(s_etat_processus, NOM)) == NULL)
8029: {
8030: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
8031: return(NULL);
8032: }
8033:
8034: if (((*((struct_nom *) (*s_objet).objet)).nom =
8035: malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
8036: == NULL)
8037: {
8038: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
8039: return(NULL);
8040: }
8041:
8042: if (longueur_buffer < 0)
8043: {
8044: if (fread((unsigned char *) (*((struct_nom *) (*s_objet)
8045: .objet)).nom, (size_t) sizeof(unsigned char),
8046: (size_t) longueur, fichier) != (unsigned) longueur)
8047: {
8048: if (feof(fichier))
8049: {
8050: (*s_etat_processus).erreur_execution =
8051: d_ex_syntaxe;
8052: }
8053: else
8054: {
8055: (*s_etat_processus).erreur_systeme =
8056: d_es_erreur_fichier;
8057: }
8058:
8059: liberation(s_etat_processus, s_objet);
8060: return(NULL);
8061: }
8062:
8063: if (fread(octets, (size_t) sizeof(unsigned char),
8064: 1, fichier) != 1)
8065: {
8066: if (feof(fichier))
8067: {
8068: (*s_etat_processus).erreur_execution =
8069: d_ex_syntaxe;
8070: }
8071: else
8072: {
8073: (*s_etat_processus).erreur_systeme =
8074: d_es_erreur_fichier;
8075: }
8076:
8077: liberation(s_etat_processus, s_objet);
8078: return(NULL);
8079: }
8080: }
8081: else
8082: {
8083: if ((longueur_buffer - (ptr - buffer)) >= (longueur + 1))
8084: {
8085: for(j = 0; j < longueur; (*((struct_nom *)
8086: (*s_objet).objet)).nom[j] = *ptr++);
8087: octets[0] = *ptr++;
8088: }
8089: else
8090: {
8091: liberation(s_etat_processus, s_objet);
8092: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
8093: return(NULL);
8094: }
8095: }
8096:
8097: (*((struct_nom *) (*s_objet).objet)).nom[longueur] =
8098: d_code_fin_chaine;
8099: (*((struct_nom *) (*s_objet).objet)).symbole =
8100: (octets[0] == 0xFF) ? d_vrai : d_faux;
8101: break;
8102: }
8103:
8104: case 0xE0: // Fonction
8105: {
8106: if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits
8107: {
8108: longueur = (octets[0] & 0x07);
8109: }
8110: else
8111: {
8112: switch(octets[0] & 0x07)
8113: {
8114: case 0x00: // Longueur sur 8 bits
8115: {
8116: if (longueur_buffer < 0)
8117: {
8118: if (fread(octets, (size_t) sizeof(unsigned char),
8119: 1, fichier) != 1)
8120: {
8121: if (feof(fichier))
8122: {
8123: (*s_etat_processus).erreur_execution =
8124: d_ex_syntaxe;
8125: }
8126: else
8127: {
8128: (*s_etat_processus).erreur_systeme =
8129: d_es_erreur_fichier;
8130: }
8131:
8132: return(NULL);
8133: }
8134: }
8135: else
8136: {
8137: if ((longueur_buffer - (ptr - buffer)) >= 1)
8138: {
8139: octets[0] = *ptr++;
8140: }
8141: else
8142: {
8143: (*s_etat_processus).erreur_execution =
8144: d_ex_syntaxe;
8145: return(NULL);
8146: }
8147: }
8148:
8149: longueur = octets[0];
8150: break;
8151: }
8152:
8153: case 0x01: // Longueur sur 16 bits
8154: {
8155: if (longueur_buffer < 0)
8156: {
8157: if (fread(octets, (size_t) sizeof(unsigned char),
8158: 2, fichier) != 2)
8159: {
8160: if (feof(fichier))
8161: {
8162: (*s_etat_processus).erreur_execution =
8163: d_ex_syntaxe;
8164: }
8165: else
8166: {
8167: (*s_etat_processus).erreur_systeme =
8168: d_es_erreur_fichier;
8169: }
8170:
8171: return(NULL);
8172: }
8173: }
8174: else
8175: {
8176: if ((longueur_buffer - (ptr - buffer)) >= 2)
8177: {
8178: for(j = 0; j < 2; octets[j++] = *ptr++);
8179: }
8180: else
8181: {
8182: (*s_etat_processus).erreur_execution =
8183: d_ex_syntaxe;
8184: return(NULL);
8185: }
8186: }
8187:
8188: longueur = (((integer8) (octets[0])) << 8)
8189: | ((integer8) (octets[1]));
8190: break;
8191: }
8192:
8193: case 0x02: // Longueur sur 32 bits
8194: {
8195: if (longueur_buffer < 0)
8196: {
8197: if (fread(octets, (size_t) sizeof(unsigned char),
8198: 4, fichier) != 4)
8199: {
8200: if (feof(fichier))
8201: {
8202: (*s_etat_processus).erreur_execution =
8203: d_ex_syntaxe;
8204: }
8205: else
8206: {
8207: (*s_etat_processus).erreur_systeme =
8208: d_es_erreur_fichier;
8209: }
8210:
8211: return(NULL);
8212: }
8213: }
8214: else
8215: {
8216: if ((longueur_buffer - (ptr - buffer)) >= 4)
8217: {
8218: for(j = 0; j < 4; octets[j++] = *ptr++);
8219: }
8220: else
8221: {
8222: (*s_etat_processus).erreur_execution =
8223: d_ex_syntaxe;
8224: return(NULL);
8225: }
8226: }
8227:
8228: longueur = (((integer8) (octets[0])) << 24)
8229: | (((integer8) (octets[1])) << 16)
8230: | (((integer8) (octets[2])) << 8)
8231: | ((integer8) (octets[3]));
8232: break;
8233: }
8234:
8235: case 0x03: // Longueur sur 64 bits
8236: {
8237: if (longueur_buffer < 0)
8238: {
8239: if (fread(octets, (size_t) sizeof(unsigned char),
8240: 8, fichier) != 8)
8241: {
8242: if (feof(fichier))
8243: {
8244: (*s_etat_processus).erreur_execution =
8245: d_ex_syntaxe;
8246: }
8247: else
8248: {
8249: (*s_etat_processus).erreur_systeme =
8250: d_es_erreur_fichier;
8251: }
8252:
8253: return(NULL);
8254: }
8255: }
8256: else
8257: {
8258: if ((longueur_buffer - (ptr - buffer)) >= 8)
8259: {
8260: for(j = 0; j < 8; octets[j++] = *ptr++);
8261: }
8262: else
8263: {
8264: (*s_etat_processus).erreur_execution =
8265: d_ex_syntaxe;
8266: return(NULL);
8267: }
8268: }
8269:
8270: longueur = (((integer8) (octets[0])) << 56)
8271: | (((integer8) (octets[1])) << 48)
8272: | (((integer8) (octets[2])) << 40)
8273: | (((integer8) (octets[3])) << 32)
8274: | (((integer8) (octets[4])) << 24)
8275: | (((integer8) (octets[5])) << 16)
8276: | (((integer8) (octets[6])) << 8)
8277: | ((integer8) (octets[7]));
8278: break;
8279: }
8280:
8281: default:
8282: {
8283: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
8284: return(NULL);
8285: }
8286: }
8287: }
8288:
8289: if ((s_objet = allocation(s_etat_processus, FCT)) == NULL)
8290: {
8291: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
8292: return(NULL);
8293: }
8294:
8295: if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
8296: malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
8297: == NULL)
8298: {
8299: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
8300: return(NULL);
8301: }
8302:
8303: if (longueur_buffer < 0)
8304: {
8305: if (fread((unsigned char *) (*((struct_fonction *) (*s_objet)
8306: .objet)).nom_fonction, (size_t) sizeof(unsigned char),
8307: (size_t) longueur, fichier) != (unsigned) longueur)
8308: {
8309: if (feof(fichier))
8310: {
8311: (*s_etat_processus).erreur_execution =
8312: d_ex_syntaxe;
8313: }
8314: else
8315: {
8316: (*s_etat_processus).erreur_systeme =
8317: d_es_erreur_fichier;
8318: }
8319:
8320: liberation(s_etat_processus, s_objet);
8321: return(NULL);
8322: }
8323:
8324: if (fread(octets, (size_t) sizeof(unsigned char),
8325: 8, fichier) != 8)
8326: {
8327: if (feof(fichier))
8328: {
8329: (*s_etat_processus).erreur_execution =
8330: d_ex_syntaxe;
8331: }
8332: else
8333: {
8334: (*s_etat_processus).erreur_systeme =
8335: d_es_erreur_fichier;
8336: }
8337:
8338: liberation(s_etat_processus, s_objet);
8339: return(NULL);
8340: }
8341: }
8342: else
8343: {
8344: if ((longueur_buffer - (ptr - buffer)) >= (longueur + 8))
8345: {
8346: for(j = 0; j < longueur; (*((struct_fonction *)
8347: (*s_objet).objet)).nom_fonction[j] = *ptr++);
8348: for(j = 0; j < 8; octets[j++] = *ptr++);
8349: }
8350: else
8351: {
8352: liberation(s_etat_processus, s_objet);
8353: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
8354: return(NULL);
8355: }
8356: }
8357:
8358: (*((struct_fonction *) (*s_objet).objet)).nom_fonction[longueur] =
8359: d_code_fin_chaine;
8360: (*((struct_fonction *) (*s_objet).objet)).nombre_arguments =
8361: (((integer8) (octets[0])) << 56)
8362: | (((integer8) (octets[1])) << 48)
8363: | (((integer8) (octets[2])) << 40)
8364: | (((integer8) (octets[3])) << 32)
8365: | (((integer8) (octets[4])) << 24)
8366: | (((integer8) (octets[5])) << 16)
8367: | (((integer8) (octets[6])) << 8)
8368: | ((integer8) (octets[7]));
8369: break;
8370: }
8371:
8372: default:
8373: {
8374: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
8375: return(NULL);
8376: }
8377: }
8378:
8379: if ((longueur_buffer < 0) && (recursivite == d_faux))
8380: {
8381: // Lecture depuis un fichier, on saute le champ de queue qui contient
8382: // la longueur de l'enregistrement.
8383:
8384: if (fread(octets, (size_t) sizeof(unsigned char), 1, fichier) != 1)
8385: {
8386: liberation(s_etat_processus, s_objet);
8387:
8388: if (feof(fichier))
8389: {
8390: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
8391: }
8392: else
8393: {
8394: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
8395: }
8396:
8397: return(NULL);
8398: }
8399:
8400: if ((octets[0] & 0x01) != 0)
8401: {
8402: deplacement = (size_t) (((octets[0] & 0x0F) >> 1) + 1);
8403:
8404: if (fread(octets, (size_t) sizeof(unsigned char), deplacement,
8405: fichier) != deplacement)
8406: {
8407: liberation(s_etat_processus, s_objet);
8408:
8409: if (feof(fichier))
8410: {
8411: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
8412: }
8413: else
8414: {
8415: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
8416: }
8417:
8418: return(NULL);
8419: }
8420: }
8421: }
8422:
8423: if (longueur_buffer >= 0)
8424: {
8425: (*((unsigned char **) argument)) = ptr;
8426: }
8427:
8428: return(s_objet);
8429: }
8430:
8431: // 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