![[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|
Return to formateur_fichiers.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.83 bertrand 3: RPL/2 (R) version 4.1.21
1.80 bertrand 4: Copyright (C) 1989-2015 Dr. BERTRAND Joël
1.1 bertrand 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:
1.68 bertrand 22:
1.14 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 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)
1.20 bertrand 33: Type = 'F/U' (formaté, non formaté)
1.1 bertrand 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,
1.61 bertrand 43: struct_objet *s_format, integer8 longueur, integer8 longueur_champ,
1.1 bertrand 44: unsigned char format_sortie, unsigned char type,
1.61 bertrand 45: integer8 *longueur_effective, integer8 *recursivite,
46: logical1 export_fichier)
1.1 bertrand 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*(*)"
1.56 bertrand 66: * "character*(Y)"
67: * "native*(*)" }
1.1 bertrand 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",
1.56 bertrand 75: * "character*n" "character*(*)" "native*(*)" }
1.1 bertrand 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:
1.72 bertrand 88: struct_objet *s_format_tmp;
1.1 bertrand 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;
1.84 bertrand 98: unsigned char *chaine_offset;
1.1 bertrand 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];
1.54 bertrand 105: unsigned char type_binaire;
1.1 bertrand 106:
1.61 bertrand 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;
1.1 bertrand 114:
1.61 bertrand 115: integer8 longueur_chaine_traitee;
1.84 bertrand 116: integer8 longueur_element;
1.58 bertrand 117: integer8 longueur_fonction;
1.1 bertrand 118: integer8 longueur_liste;
1.84 bertrand 119: integer8 longueur_objet;
1.52 bertrand 120: integer8 longueur_reelle_chaine;
1.1 bertrand 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:
1.56 bertrand 149: if (format_sortie != 'N')
150: {
151: (*s_etat_processus).erreur_execution =
152: d_ex_erreur_format_fichier;
153: return(NULL);
154: }
155:
1.1 bertrand 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:
1.79 bertrand 240: (*s_etat_processus).type_en_cours = NON;
1.1 bertrand 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")
1.80 bertrand 300: == 0) || (strcmp(chaine_fonction,
301: "EQV") == 0))
1.1 bertrand 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(
1.80 bertrand 328: chaine_fonction, "OR") == 0) ||
329: (strcmp(chaine_fonction, "EQV")
330: == 0))
1.1 bertrand 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:
1.79 bertrand 411: (*s_etat_processus).type_en_cours = NON;
1.1 bertrand 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")
1.80 bertrand 469: == 0) || (strcmp(chaine_fonction,
470: "EQV") == 0))
1.1 bertrand 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(
1.80 bertrand 487: chaine_fonction, "OR") == 0) ||
488: (strcmp(chaine_fonction, "EQV")
489: == 0))
1.1 bertrand 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,
1.80 bertrand 730: "AND") == 0) || (strcmp((*((struct_fonction *)
731: (*(*l_element_courant).donnee).objet))
732: .nom_fonction, "EQV") == 0))
1.1 bertrand 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,
1.52 bertrand 888: CHN)) == NULL)
1.1 bertrand 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,
1.52 bertrand 919: type, longueur_effective, recursivite,
920: export_fichier)) == NULL)
1.1 bertrand 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:
1.61 bertrand 945: for(ptrl++, i = ((integer8) strlen(chaine_sauvegarde))
946: - 2; i > 0; i--, *ptre++ = *ptrl++);
1.1 bertrand 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:
1.57 bertrand 1008: if ((format_sortie != 'B') && (format_sortie != 'N'))
1.1 bertrand 1009: {
1010: (*s_etat_processus).erreur_execution =
1011: d_ex_erreur_format_fichier;
1012: return(NULL);
1013: }
1014:
1.56 bertrand 1015: if (format_sortie == 'N')
1016: {
1.70 bertrand 1017: sprintf(tampon, "%llX", (unsigned long long) (*((logical8 *)
1.56 bertrand 1018: ((*s_objet).objet))));
1019: strcpy(base, "h");
1020: }
1021: else
1022: {
1023: switch(longueur)
1024: {
1025: case 2:
1026: {
1.70 bertrand 1027: sprintf(tampon, "%llX", (unsigned long long)
1028: (*((logical8 *) ((*s_objet).objet))));
1.1 bertrand 1029:
1.56 bertrand 1030: chaine = (unsigned char *) malloc((strlen(tampon) + 1)
1031: * sizeof(unsigned char));
1.1 bertrand 1032:
1.56 bertrand 1033: if (chaine == NULL)
1034: {
1035: (*s_etat_processus).erreur_systeme =
1036: d_es_allocation_memoire;
1037: return(NULL);
1038: }
1.1 bertrand 1039:
1.56 bertrand 1040: strcpy(chaine, tampon);
1041: tampon[0] = 0;
1.1 bertrand 1042:
1.61 bertrand 1043: for(i = 0; i < ((integer8) strlen(chaine)); i++)
1.56 bertrand 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: }
1.1 bertrand 1129:
1.56 bertrand 1130: free(chaine);
1131: strcpy(base, "b");
1132: break;
1133: }
1.1 bertrand 1134:
1.56 bertrand 1135: case 8:
1136: {
1.69 bertrand 1137: sprintf(tampon, "%llo", (*((unsigned long long *)
1.56 bertrand 1138: ((*s_objet).objet))));
1139: strcpy(base, "o");
1140: break;
1141: }
1.1 bertrand 1142:
1.56 bertrand 1143: case 10:
1144: {
1.69 bertrand 1145: sprintf(tampon, "%llu", (*((unsigned long long *)
1.56 bertrand 1146: ((*s_objet).objet))));
1147: strcpy(base, "d");
1148: break;
1149: }
1.1 bertrand 1150:
1.56 bertrand 1151: case 16:
1152: {
1.70 bertrand 1153: sprintf(tampon, "%llX", (unsigned long long)
1154: (*((logical8 *) ((*s_objet).objet))));
1.56 bertrand 1155: strcpy(base, "h");
1156: break;
1157: }
1.1 bertrand 1158:
1.56 bertrand 1159: default:
1.1 bertrand 1160: {
1.56 bertrand 1161: (*s_etat_processus).erreur_execution =
1162: d_ex_erreur_format_fichier;
1.1 bertrand 1163: return(NULL);
1164: }
1.56 bertrand 1165: }
1166: }
1.1 bertrand 1167:
1.56 bertrand 1168: if (format_sortie == 'B')
1169: {
1170: if ((longueur_champ > 0) && (longueur_champ
1171: < (signed) strlen(tampon)))
1172: {
1.61 bertrand 1173: ptrl = &(tampon[((integer8) strlen(tampon))
1174: - longueur_champ]);
1.56 bertrand 1175: ptre = tampon;
1.1 bertrand 1176:
1.56 bertrand 1177: do
1.1 bertrand 1178: {
1.56 bertrand 1179: *ptre++ = *ptrl++;
1180: } while((*ptrl) != d_code_fin_chaine);
1.1 bertrand 1181:
1.56 bertrand 1182: (*ptre) = d_code_fin_chaine;
1.1 bertrand 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:
1.57 bertrand 1209: if ((format_sortie != 'C') && (format_sortie != 'N'))
1.1 bertrand 1210: {
1211: (*s_etat_processus).erreur_execution =
1212: d_ex_erreur_format_fichier;
1213: return(NULL);
1214: }
1215:
1.52 bertrand 1216: longueur_reelle_chaine = longueur_chaine(s_etat_processus,
1217: (unsigned char *) (*s_objet).objet);
1218:
1.56 bertrand 1219: if (format_sortie == 'N')
1220: {
1221: longueur_champ = -1;
1222: }
1223:
1.52 bertrand 1224: if ((longueur_champ == -1) || (longueur_reelle_chaine <
1225: longueur_champ))
1.7 bertrand 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: }
1.1 bertrand 1236:
1.7 bertrand 1237: strcpy(chaine, (unsigned char *) ((*s_objet).objet));
1238: }
1239: else
1.1 bertrand 1240: {
1.52 bertrand 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);
1.7 bertrand 1245:
1.61 bertrand 1246: if ((chaine = malloc((((size_t) longueur_reelle_chaine) + 1) *
1.52 bertrand 1247: sizeof(unsigned char))) == NULL)
1.7 bertrand 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),
1.61 bertrand 1255: (size_t) longueur_reelle_chaine);
1.52 bertrand 1256: chaine[longueur_reelle_chaine] = d_code_fin_chaine;
1.1 bertrand 1257: }
1258: }
1259: else if ((*s_objet).type == CPL)
1260: {
1261:
1262: /*
1263: --------------------------------------------------------------------------------
1264: Complexe
1265: --------------------------------------------------------------------------------
1266: */
1267:
1.56 bertrand 1268: if (format_sortie == 'N')
1269: {
1270: format_sortie = 'S';
1271: }
1272:
1.1 bertrand 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:
1.56 bertrand 1310: if (format_sortie != 'N')
1311: {
1312: (*s_etat_processus).erreur_execution =
1313: d_ex_erreur_format_fichier;
1314: return(NULL);
1315: }
1316:
1.1 bertrand 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,
1.52 bertrand 1325: longueur_effective, recursivite, export_fichier))
1326: == NULL)
1.1 bertrand 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:
1.56 bertrand 1399: if (format_sortie == 'N')
1400: {
1401: format_sortie = 'S';
1402: }
1403:
1.1 bertrand 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:
1.56 bertrand 1441: if (format_sortie != 'N')
1442: {
1443: (*s_etat_processus).erreur_execution =
1444: d_ex_erreur_format_fichier;
1445: return(NULL);
1446: }
1447:
1.1 bertrand 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:
1.56 bertrand 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
1.1 bertrand 1508: {
1.56 bertrand 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: }
1.1 bertrand 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: {
1.82 bertrand 1547: if ((format_chaine = conversion_majuscule(
1548: s_etat_processus, (unsigned char *)
1.1 bertrand 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: }
1.56 bertrand 1591: else if (strcmp("NATIVE*(*)", format_chaine) == 0)
1592: {
1593: format_sortie = 'N';
1594: position_1 = 7;
1595: format_degenere = d_vrai;
1596: }
1.1 bertrand 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:
1.61 bertrand 1607: position_3 = ((integer8) strlen(format_chaine)) - 1;
1.43 bertrand 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:
1.44 bertrand 1619: format_chaine[position_3] = d_code_fin_chaine;
1.1 bertrand 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: {
1.61 bertrand 1642: if (sscanf(&(format_chaine[position_1]), "%lld",
1.1 bertrand 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: {
1.61 bertrand 1660: if (sscanf(&(format_chaine[position_2]), "%lld",
1.1 bertrand 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 >
1.56 bertrand 1677: longueur_champ) && (format_sortie != 'B'))
1.1 bertrand 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:
1.72 bertrand 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:
1.1 bertrand 1742: if ((chaine_formatee = formateur_fichier(s_etat_processus,
1743: (*l_element_courant).donnee, s_format,
1744: longueur, longueur_champ, format_sortie, type,
1.52 bertrand 1745: longueur_effective, recursivite, export_fichier))
1746: == NULL)
1.1 bertrand 1747: {
1.72 bertrand 1748: liberation(s_etat_processus, s_format_tmp);
1.5 bertrand 1749: free(chaine);
1.1 bertrand 1750: return(NULL);
1751: }
1752:
1.72 bertrand 1753: liberation(s_etat_processus, s_format_tmp);
1754:
1.1 bertrand 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;
1.56 bertrand 1818:
1819: if (format_sortie != 'N')
1820: {
1821: l_element_courant_format =
1822: (*l_element_courant_format).suivant;
1823: }
1.1 bertrand 1824: }
1825:
1.56 bertrand 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')
1.1 bertrand 1831: {
1.56 bertrand 1832: if ((l_element_courant != NULL) ||
1833: (l_element_courant_format != NULL))
1834: {
1835: free(chaine);
1.1 bertrand 1836:
1.56 bertrand 1837: (*s_etat_processus).erreur_execution =
1838: d_ex_erreur_format_fichier;
1839: return(NULL);
1840: }
1.1 bertrand 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:
1.56 bertrand 1866: if (((*s_format).type != TBL) && (format_sortie != 'N'))
1.1 bertrand 1867: {
1868: (*s_etat_processus).erreur_execution =
1869: d_ex_erreur_format_fichier;
1870: return(NULL);
1871: }
1872:
1.56 bertrand 1873: if (format_sortie != 'N')
1.1 bertrand 1874: {
1.56 bertrand 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: }
1.1 bertrand 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: {
1.56 bertrand 1898: if (format_sortie != 'N')
1.1 bertrand 1899: {
1.56 bertrand 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;
1.1 bertrand 1910:
1.56 bertrand 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: }
1.1 bertrand 1922:
1.56 bertrand 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: }
1.1 bertrand 1931:
1.56 bertrand 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)
1.1 bertrand 1940: {
1.56 bertrand 1941: free(chaine);
1942:
1943: (*s_etat_processus).erreur_execution =
1944: d_ex_erreur_format_fichier;
1.1 bertrand 1945: return(NULL);
1946: }
1.56 bertrand 1947: else
1948: {
1949: if ((format_chaine = conversion_majuscule(
1.82 bertrand 1950: s_etat_processus,
1.56 bertrand 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: }
1.1 bertrand 1959:
1.56 bertrand 1960: format_degenere = d_faux;
1.1 bertrand 1961:
1.56 bertrand 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
1.1 bertrand 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:
1.61 bertrand 2010: position_3 = (integer8) strlen(format_chaine);
1.56 bertrand 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: {
1.61 bertrand 2034: if (sscanf(&(format_chaine[position_1]), "%lld",
1.56 bertrand 2035: &longueur) != 1)
2036: {
2037: free(chaine);
2038: free(format_chaine);
1.1 bertrand 2039:
1.56 bertrand 2040: (*s_etat_processus).erreur_execution =
2041: d_ex_erreur_format_fichier;
2042: return(NULL);
2043: }
2044: }
2045: else
2046: {
2047: longueur = -1;
2048: }
1.1 bertrand 2049:
1.56 bertrand 2050: if (strcmp(&(format_chaine[position_2]), "*") != 0)
1.1 bertrand 2051: {
1.61 bertrand 2052: if (sscanf(&(format_chaine[position_2]), "%lld",
1.56 bertrand 2053: &longueur_champ) != 1)
2054: {
2055: free(chaine);
2056: free(format_chaine);
1.1 bertrand 2057:
1.56 bertrand 2058: (*s_etat_processus).erreur_execution =
2059: d_ex_erreur_format_fichier;
2060: return(NULL);
2061: }
2062: }
2063: else
2064: {
2065: longueur_champ = -1;
1.1 bertrand 2066: }
2067:
1.56 bertrand 2068: if ((longueur >= 0) && (longueur_champ >= 0) &&
2069: (longueur > longueur_champ))
1.1 bertrand 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);
1.56 bertrand 2080:
2081: chaine_sauvegarde = chaine;
1.1 bertrand 2082:
1.56 bertrand 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: }
1.1 bertrand 2092: }
1.56 bertrand 2093: }
2094: else // NATIVE*(*)
2095: {
1.1 bertrand 2096: chaine_sauvegarde = chaine;
2097:
1.56 bertrand 2098: if ((chaine_formatee = formateur_fichier(
2099: s_etat_processus, (*((struct_tableau *)
2100: (*s_objet).objet)).elements[i], s_format,
1.1 bertrand 2101: longueur, longueur_champ, format_sortie, type,
1.56 bertrand 2102: longueur_effective, recursivite,
2103: export_fichier)) == NULL)
1.1 bertrand 2104: {
2105: return(NULL);
2106: }
1.56 bertrand 2107: }
1.1 bertrand 2108:
1.56 bertrand 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)
1.1 bertrand 2118: {
1.56 bertrand 2119: (*s_etat_processus).erreur_systeme =
2120: d_es_allocation_memoire;
2121: return(NULL);
2122: }
1.1 bertrand 2123:
1.56 bertrand 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));
1.1 bertrand 2138:
1.56 bertrand 2139: if (chaine == NULL)
2140: {
2141: (*s_etat_processus).erreur_systeme =
2142: d_es_allocation_memoire;
2143: return(NULL);
1.1 bertrand 2144: }
2145:
1.56 bertrand 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));
1.1 bertrand 2156:
1.56 bertrand 2157: if (chaine == NULL)
2158: {
2159: (*s_etat_processus).erreur_systeme =
2160: d_es_allocation_memoire;
2161: return(NULL);
1.1 bertrand 2162: }
2163:
1.56 bertrand 2164: strcpy(chaine, chaine_sauvegarde);
2165: free(chaine_sauvegarde);
2166: strcat(chaine, " ");
2167: strcat(chaine, chaine_formatee);
2168: free(chaine_formatee);
1.1 bertrand 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:
1.56 bertrand 2195: if (format_sortie == 'N')
2196: {
2197: format_sortie = 'S';
2198: }
2199:
1.1 bertrand 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:
1.56 bertrand 2343: if (format_sortie == 'N')
2344: {
2345: format_sortie = 'S';
2346: }
2347:
1.1 bertrand 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:
1.56 bertrand 2490: if (format_sortie == 'N')
2491: {
2492: format_sortie = 'S';
2493: }
2494:
1.1 bertrand 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:
1.56 bertrand 2637: if (format_sortie != 'N')
2638: {
2639: (*s_etat_processus).erreur_execution =
2640: d_ex_erreur_format_fichier;
2641: return(NULL);
2642: }
2643:
1.1 bertrand 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:
1.56 bertrand 2664: if (format_sortie == 'N')
2665: {
2666: format_sortie = 'S';
2667: }
2668:
1.1 bertrand 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:
1.56 bertrand 2706: if (format_sortie == 'N')
2707: {
2708: format_sortie = 'S';
2709: }
2710:
1.1 bertrand 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:
1.56 bertrand 2787: if (format_sortie == 'N')
2788: {
2789: format_sortie = 'S';
2790: }
2791:
1.1 bertrand 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:
1.56 bertrand 2867: if (format_sortie == 'N')
2868: {
2869: format_sortie = 'S';
2870: }
2871:
1.1 bertrand 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:
1.61 bertrand 2948: (*longueur_effective) = ((integer8) strlen(chaine)) + 1;
1.1 bertrand 2949: }
2950: else
2951: {
2952: /*
2953: * Fichiers non formatés
2954: */
2955:
2956: #define __zone() \
1.34 bertrand 2957: do { int _i; \
2958: for(_i = 0; _i < longueur_totale; _i++) \
2959: printf("%02X ", chaine[_i]); printf("\b\n"); } while(0)
1.1 bertrand 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: *
1.52 bertrand 2976: * XXXXXXX0 longueur sur 7 bits
2977: * XXXX0011 XXXXXXXX XXXX0011 longueur sur 16 bits
1.53 bertrand 2978: * LSB(1/2) MSB LSB(2/2)
1.52 bertrand 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
1.1 bertrand 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: *
1.34 bertrand 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: *
1.58 bertrand 3106: * 1110 0 XXX fonction de longueur XXX
3107: * 1110 10 LL fonction de longueur integer*LL
3108: *
1.85 ! bertrand 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: *
1.1 bertrand 3114: * Les longueurs indiquées par le champ LL suivent l'en-tête :
1.34 bertrand 3115: * 00 : integer*1
3116: * 01 : integer*2
3117: * 10 : integer*4
3118: * 11 : integer*8
3119: *
1.1 bertrand 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:
1.54 bertrand 3130: if ((*s_objet).type == BIN)
1.52 bertrand 3131: {
3132:
3133: /*
3134: --------------------------------------------------------------------------------
1.54 bertrand 3135: Entier binaire en base 2, 8, 10 ou 16
3136: Poids fort 0000
1.52 bertrand 3137: --------------------------------------------------------------------------------
3138: */
3139:
1.57 bertrand 3140: if (format_sortie == 'N')
3141: {
3142: format_sortie = 'L';
3143: longueur_champ = 8;
3144: }
3145:
1.54 bertrand 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:
1.61 bertrand 3166: if ((chaine = malloc(((size_t) (*longueur_effective))
3167: * sizeof(unsigned char))) == NULL)
1.54 bertrand 3168: {
3169: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3170: return(NULL);
3171: }
1.1 bertrand 3172:
1.61 bertrand 3173: chaine[0] = (unsigned char) longueur_champ;
1.1 bertrand 3174:
1.61 bertrand 3175: for(i = 1; i <= (*longueur_effective); i++)
1.54 bertrand 3176: {
3177: chaine[i] = ((*((logical8 *) (*s_objet).objet)) >>
3178: (8 * (longueur_champ - i))) & 0xFF;
3179: }
1.52 bertrand 3180: }
3181: else if ((*s_objet).type == CHN)
1.1 bertrand 3182: {
3183:
3184: /*
3185: --------------------------------------------------------------------------------
1.52 bertrand 3186: Chaîne de caractères
3187: Poids fort 1000 0XXX (longueur inférieure à 2**3-1
3188: 1000 10LL (autres longueurs)
1.1 bertrand 3189: --------------------------------------------------------------------------------
3190: */
3191:
1.57 bertrand 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:
1.52 bertrand 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:
1.61 bertrand 3231: if ((chaine = malloc(((size_t) longueur_champ)
3232: * sizeof(unsigned char))) == NULL)
1.52 bertrand 3233: {
3234: (*s_etat_processus).erreur_systeme =
3235: d_es_allocation_memoire;
3236: return(NULL);
3237: }
3238:
1.61 bertrand 3239: memcpy(chaine, chaine_sauvegarde, (size_t) longueur_champ);
1.52 bertrand 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: {
1.61 bertrand 3248: if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 1)
1.52 bertrand 3249: * sizeof(unsigned char))) == NULL)
3250: {
3251: (*s_etat_processus).erreur_systeme =
3252: d_es_allocation_memoire;
3253: return(NULL);
3254: }
3255:
1.61 bertrand 3256: chaine[0] = (unsigned char) (0x80 |
3257: (longueur_chaine_traitee & 0x7));
1.1 bertrand 3258:
1.61 bertrand 3259: memcpy(chaine + 1, chaine_sauvegarde,
3260: (size_t) longueur_chaine_traitee);
1.52 bertrand 3261: longueur_totale = longueur_chaine_traitee + 1;
3262: }
3263: else if (longueur_chaine_traitee < (1LL << 8))
1.1 bertrand 3264: {
1.61 bertrand 3265: if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 2)
1.52 bertrand 3266: * sizeof(unsigned char))) == NULL)
1.1 bertrand 3267: {
1.52 bertrand 3268: (*s_etat_processus).erreur_systeme =
3269: d_es_allocation_memoire;
3270: return(NULL);
3271: }
1.1 bertrand 3272:
1.61 bertrand 3273: chaine[0] = (unsigned char) 0x88;
1.52 bertrand 3274: chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF);
1.1 bertrand 3275:
1.61 bertrand 3276: memcpy(chaine + 2, chaine_sauvegarde,
3277: (size_t) longueur_chaine_traitee);
1.52 bertrand 3278: longueur_totale = longueur_chaine_traitee + 2;
3279: }
3280: else if (longueur_chaine_traitee < (1LL << 16))
3281: {
1.61 bertrand 3282: if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 3)
1.52 bertrand 3283: * sizeof(unsigned char))) == NULL)
3284: {
3285: (*s_etat_processus).erreur_systeme =
3286: d_es_allocation_memoire;
3287: return(NULL);
3288: }
1.1 bertrand 3289:
1.61 bertrand 3290: chaine[0] = (unsigned char) 0x89;
1.52 bertrand 3291: chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8)
3292: & 0xFF);
3293: chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF);
1.1 bertrand 3294:
1.61 bertrand 3295: memcpy(chaine + 3, chaine_sauvegarde,
3296: (size_t) longueur_chaine_traitee);
1.52 bertrand 3297: longueur_totale = longueur_chaine_traitee + 3;
3298: }
3299: else if (longueur_chaine_traitee < (1LL << 32))
3300: {
1.61 bertrand 3301: if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 5)
1.52 bertrand 3302: * sizeof(unsigned char))) == NULL)
3303: {
3304: (*s_etat_processus).erreur_systeme =
3305: d_es_allocation_memoire;
3306: return(NULL);
3307: }
1.1 bertrand 3308:
1.61 bertrand 3309: chaine[0] = (unsigned char) 0x8A;
1.52 bertrand 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);
1.1 bertrand 3317:
1.61 bertrand 3318: memcpy(chaine + 5, chaine_sauvegarde,
3319: (size_t) longueur_chaine_traitee);
1.52 bertrand 3320: longueur_totale = longueur_chaine_traitee + 5;
3321: }
3322: else
3323: {
1.61 bertrand 3324: if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 9)
1.52 bertrand 3325: * sizeof(unsigned char))) == NULL)
3326: {
3327: (*s_etat_processus).erreur_systeme =
3328: d_es_allocation_memoire;
3329: return(NULL);
3330: }
1.1 bertrand 3331:
1.61 bertrand 3332: chaine[0] = (unsigned char) 0x8B;
1.52 bertrand 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);
1.1 bertrand 3348:
1.61 bertrand 3349: memcpy(chaine + 9, chaine_sauvegarde,
3350: (size_t) longueur_chaine_traitee);
1.52 bertrand 3351: longueur_totale = longueur_chaine_traitee + 9;
3352: }
1.1 bertrand 3353:
1.52 bertrand 3354: (*longueur_effective) = longueur_totale;
3355: }
3356: else if ((*s_objet).type == CPL)
3357: {
1.1 bertrand 3358:
1.52 bertrand 3359: /*
3360: --------------------------------------------------------------------------------
3361: Complexe
3362: Poids fort 0001 10
3363: --------------------------------------------------------------------------------
3364: */
1.1 bertrand 3365:
1.57 bertrand 3366: if (format_sortie == 'N')
3367: {
3368: format_sortie = 'C';
3369: longueur = 8;
3370: }
3371:
1.52 bertrand 3372: if (format_sortie != 'C')
3373: {
3374: (*s_etat_processus).erreur_execution =
3375: d_ex_erreur_format_fichier;
3376: return(NULL);
3377: }
1.1 bertrand 3378:
1.52 bertrand 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: {
1.1 bertrand 3388:
1.52 bertrand 3389: /*
3390: --------------------------------------------------------------------------------
3391: Entier
3392: Poids fort 0001 00
3393: --------------------------------------------------------------------------------
3394: */
1.1 bertrand 3395:
1.57 bertrand 3396: if (format_sortie == 'N')
3397: {
3398: format_sortie = 'I';
3399: longueur = 8;
3400: }
3401:
1.52 bertrand 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);
1.1 bertrand 3408: }
3409:
1.34 bertrand 3410: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
1.52 bertrand 3411: (*s_objet).objet, 'I', format_sortie, longueur,
3412: longueur_effective)) == NULL)
1.1 bertrand 3413: {
1.34 bertrand 3414: return(NULL);
1.1 bertrand 3415: }
3416: }
3417: else if ((*s_objet).type == FCT)
3418: {
3419:
3420: /*
3421: --------------------------------------------------------------------------------
3422: Fonction
1.58 bertrand 3423: Poids fort 1110
1.1 bertrand 3424: --------------------------------------------------------------------------------
3425: */
3426:
1.58 bertrand 3427: if (format_sortie != 'N')
3428: {
3429: (*s_etat_processus).erreur_execution =
3430: d_ex_erreur_format_fichier;
3431: return(NULL);
3432: }
3433:
1.61 bertrand 3434: longueur_fonction = (integer8) strlen((*((struct_fonction *)
3435: (*s_objet).objet)).nom_fonction);
1.58 bertrand 3436:
3437: if (longueur_fonction < (1LL << 3))
3438: {
1.61 bertrand 3439: if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 8)
1.58 bertrand 3440: * sizeof(unsigned char)))== NULL)
3441: {
3442: (*s_etat_processus).erreur_systeme =
3443: d_es_allocation_memoire;
3444: return(NULL);
3445: }
3446:
1.61 bertrand 3447: chaine[0] = (unsigned char) (0xE0 | (longueur_fonction & 0x7));
1.58 bertrand 3448:
3449: strcpy(chaine + 1, (*((struct_fonction *) (*s_objet).objet))
3450: .nom_fonction);
1.60 bertrand 3451: (*longueur_effective) = 1 + longueur_fonction + 8;
1.58 bertrand 3452: }
3453: else if (longueur_fonction < (1LL << 8))
3454: {
1.61 bertrand 3455: if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 8)
1.58 bertrand 3456: * sizeof(unsigned char)))== NULL)
3457: {
3458: (*s_etat_processus).erreur_systeme =
3459: d_es_allocation_memoire;
3460: return(NULL);
3461: }
3462:
1.61 bertrand 3463: chaine[0] = (unsigned char) (0xE0 | 0x08);
1.58 bertrand 3464: chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
3465:
3466: strcpy(chaine + 2, (*((struct_fonction *) (*s_objet).objet))
3467: .nom_fonction);
1.60 bertrand 3468: (*longueur_effective) = 2 + longueur_fonction + 8;
1.58 bertrand 3469: }
3470: else if (longueur_fonction < (1LL << 16))
3471: {
1.61 bertrand 3472: if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 8)
1.58 bertrand 3473: * sizeof(unsigned char)))== NULL)
3474: {
3475: (*s_etat_processus).erreur_systeme =
3476: d_es_allocation_memoire;
3477: return(NULL);
3478: }
3479:
1.61 bertrand 3480: chaine[0] = (unsigned char ) (0xE0 | 0x09);
1.58 bertrand 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);
1.60 bertrand 3486: (*longueur_effective) = 3 + longueur_fonction + 9;
1.58 bertrand 3487: }
3488: else if (longueur_fonction < (1LL << 32))
3489: {
1.61 bertrand 3490: if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 8)
1.58 bertrand 3491: * sizeof(unsigned char)))== NULL)
3492: {
3493: (*s_etat_processus).erreur_systeme =
3494: d_es_allocation_memoire;
3495: return(NULL);
3496: }
3497:
1.61 bertrand 3498: chaine[0] = (unsigned char) (0xE0 | 0x0A);
1.58 bertrand 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);
1.60 bertrand 3506: (*longueur_effective) = 5 + longueur_fonction + 8;
1.58 bertrand 3507: }
3508: else
3509: {
1.61 bertrand 3510: if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 8)
1.58 bertrand 3511: * sizeof(unsigned char)))== NULL)
3512: {
3513: (*s_etat_processus).erreur_systeme =
3514: d_es_allocation_memoire;
3515: return(NULL);
3516: }
3517:
1.61 bertrand 3518: chaine[0] = (unsigned char) (0xE0 | 0x0B);
1.58 bertrand 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);
1.60 bertrand 3530: (*longueur_effective) = 9 + longueur_fonction + 8;
1.58 bertrand 3531: }
3532:
3533: for(i = 1; i <= 8; i++)
3534: {
1.60 bertrand 3535: chaine[(*longueur_effective) - i] = (unsigned char)
1.58 bertrand 3536: (((*((struct_fonction *) (*s_objet).objet))
3537: .nombre_arguments >> ((8 - i) * 8)) & 0xFF);
3538: }
1.1 bertrand 3539: }
1.54 bertrand 3540: else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)
3541: || ((*s_objet).type == RPN))
1.1 bertrand 3542: {
3543:
3544: /*
3545: --------------------------------------------------------------------------------
3546: Liste
3547: Poids fort 0100
1.54 bertrand 3548:
3549: Expression algébrique
3550: Poids fort 0111
3551:
3552: Définition
3553: Poids fort 0110
1.1 bertrand 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:
1.54 bertrand 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:
1.1 bertrand 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: {
1.61 bertrand 3591: chaine[0] = (unsigned char) (type_binaire |
3592: (longueur_liste & 0x7));
1.1 bertrand 3593: }
3594: else if (longueur_liste < (1LL << 8))
3595: {
1.61 bertrand 3596: chaine[0] = (unsigned char) (type_binaire | 0x08);
1.1 bertrand 3597: }
3598: else if (longueur_liste < (1LL << 16))
3599: {
1.61 bertrand 3600: chaine[0] = (unsigned char ) (type_binaire | 0x09);
1.1 bertrand 3601: }
3602: else if (longueur_liste < (1LL << 32))
3603: {
1.61 bertrand 3604: chaine[0] = (unsigned char) (type_binaire | 0x0A);
1.1 bertrand 3605: }
3606: else
3607: {
1.61 bertrand 3608: chaine[0] = (unsigned char) (type_binaire | 0x0B);
1.1 bertrand 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:
1.61 bertrand 3621: if ((chaine = realloc(chaine,
3622: ((size_t) longueur_totale) *
1.1 bertrand 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:
1.61 bertrand 3639: if ((chaine = realloc(chaine,
3640: ((size_t) longueur_totale) *
1.52 bertrand 3641: sizeof(unsigned char))) == NULL)
3642: {
3643: (*s_etat_processus).erreur_systeme =
3644: d_es_allocation_memoire;
3645: return(NULL);
3646: }
1.1 bertrand 3647:
1.52 bertrand 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: }
1.1 bertrand 3654:
1.52 bertrand 3655: case 0x02 :
3656: {
3657: longueur_totale += 4;
1.1 bertrand 3658:
1.61 bertrand 3659: if ((chaine = realloc(chaine,
3660: ((size_t) longueur_totale) *
1.52 bertrand 3661: sizeof(unsigned char))) == NULL)
3662: {
3663: (*s_etat_processus).erreur_systeme =
3664: d_es_allocation_memoire;
3665: return(NULL);
3666: }
1.1 bertrand 3667:
1.52 bertrand 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;
1.1 bertrand 3677: }
3678:
1.52 bertrand 3679: case 0x03 :
1.1 bertrand 3680: {
1.52 bertrand 3681: longueur_totale += 8;
1.1 bertrand 3682:
1.61 bertrand 3683: if ((chaine = realloc(chaine,
3684: ((size_t) longueur_totale) *
1.52 bertrand 3685: sizeof(unsigned char))) == NULL)
3686: {
3687: (*s_etat_processus).erreur_systeme =
3688: d_es_allocation_memoire;
3689: return(NULL);
3690: }
1.1 bertrand 3691:
1.52 bertrand 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;
1.1 bertrand 3709: }
3710:
1.52 bertrand 3711: default :
1.1 bertrand 3712: {
1.52 bertrand 3713: BUG(1, printf("Internal format error\n"));
1.1 bertrand 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;
1.52 bertrand 3721: nombre_elements = 0;
1.1 bertrand 3722:
1.52 bertrand 3723: while((l_element_courant != NULL) &&
3724: (l_element_courant_format != NULL))
1.1 bertrand 3725: {
1.52 bertrand 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)))
1.1 bertrand 3730: {
1.59 bertrand 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: {
1.85 ! bertrand 3740: free(chaine);
1.59 bertrand 3741: return(NULL);
3742: }
3743: }
3744: else
1.1 bertrand 3745: {
1.59 bertrand 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: {
1.85 ! bertrand 3753: free(chaine);
1.59 bertrand 3754: return(NULL);
3755: }
1.1 bertrand 3756: }
3757:
1.61 bertrand 3758: if ((chaine = realloc(chaine, ((size_t) (longueur_totale +
3759: (*longueur_effective))) * sizeof(unsigned char)))
1.52 bertrand 3760: == NULL)
1.1 bertrand 3761: {
3762: (*s_etat_processus).erreur_systeme =
3763: d_es_allocation_memoire;
3764: return(NULL);
3765: }
3766:
1.52 bertrand 3767: memcpy(&(chaine[longueur_totale]), chaine_formatee,
1.61 bertrand 3768: (size_t) (*longueur_effective));
1.52 bertrand 3769: longueur_totale += (*longueur_effective);
1.1 bertrand 3770: free(chaine_formatee);
3771: }
1.52 bertrand 3772: else if ((*(*l_element_courant_format).donnee).type != CHN)
1.1 bertrand 3773: {
3774: free(chaine);
3775:
3776: (*s_etat_processus).erreur_execution =
3777: d_ex_erreur_format_fichier;
3778: return(NULL);
3779: }
3780: else
3781: {
1.85 ! bertrand 3782: format_degenere = d_faux;
! 3783:
1.82 bertrand 3784: if ((format_chaine = conversion_majuscule(
3785: s_etat_processus, (unsigned char *)
1.52 bertrand 3786: (*(*l_element_courant_format).donnee).objet))
3787: == NULL)
1.1 bertrand 3788: {
3789: (*s_etat_processus).erreur_systeme =
3790: d_es_allocation_memoire;
3791: return(NULL);
3792: }
3793:
1.52 bertrand 3794: if (strncmp("INTEGER*", format_chaine, 8) == 0)
1.1 bertrand 3795: {
1.52 bertrand 3796: format_sortie = 'I';
3797: position_1 = 8;
1.1 bertrand 3798: }
1.52 bertrand 3799: else if (strncmp("LOGICAL*", format_chaine, 8) == 0)
1.1 bertrand 3800: {
1.52 bertrand 3801: format_sortie = 'L';
3802: position_1 = 8;
1.1 bertrand 3803: }
1.52 bertrand 3804: else if (strncmp("REAL*", format_chaine, 5) == 0)
1.1 bertrand 3805: {
1.52 bertrand 3806: format_sortie = 'R';
3807: position_1 = 5;
1.1 bertrand 3808: }
1.52 bertrand 3809: else if (strncmp("COMPLEX*", format_chaine, 8) == 0)
1.1 bertrand 3810: {
1.52 bertrand 3811: format_sortie = 'C';
3812: position_1 = 8;
1.1 bertrand 3813: }
3814: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
3815: {
1.52 bertrand 3816: format_sortie = 'S';
1.1 bertrand 3817: position_1 = 10;
3818: format_degenere = d_vrai;
3819: }
1.57 bertrand 3820: else if (strcmp("NATIVE*(*)", format_chaine) == 0)
3821: {
3822: format_sortie = 'N';
3823: position_1 = 7;
3824: format_degenere = d_vrai;
3825: }
1.1 bertrand 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:
1.52 bertrand 3836: if (format_chaine[position_1] == d_code_fin_chaine)
1.1 bertrand 3837: {
1.52 bertrand 3838: free(chaine);
3839: free(format_chaine);
1.1 bertrand 3840:
1.52 bertrand 3841: (*s_etat_processus).erreur_execution =
3842: d_ex_erreur_format_fichier;
3843: return(NULL);
1.1 bertrand 3844: }
3845:
1.52 bertrand 3846: if (strcmp(&(format_chaine[position_1]), "(*)") != 0)
1.1 bertrand 3847: {
1.61 bertrand 3848: if (sscanf(&(format_chaine[position_1]), "%lld",
1.1 bertrand 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: }
1.52 bertrand 3858:
3859: longueur_champ = longueur;
1.1 bertrand 3860: }
3861: else
3862: {
3863: longueur_champ = -1;
1.52 bertrand 3864: longueur = -1;
1.1 bertrand 3865: }
3866:
3867: free(format_chaine);
1.72 bertrand 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:
1.1 bertrand 3920: if ((chaine_formatee = formateur_fichier(s_etat_processus,
1.72 bertrand 3921: (*l_element_courant).donnee, s_format_tmp,
1.1 bertrand 3922: longueur, longueur_champ, format_sortie, type,
1.52 bertrand 3923: longueur_effective, recursivite, export_fichier))
3924: == NULL)
1.1 bertrand 3925: {
1.72 bertrand 3926: liberation(s_etat_processus, s_format_tmp);
1.52 bertrand 3927: free(chaine);
1.1 bertrand 3928: return(NULL);
3929: }
3930:
1.72 bertrand 3931: liberation(s_etat_processus, s_format_tmp);
3932:
1.52 bertrand 3933: if ((chaine = realloc(chaine,
1.61 bertrand 3934: ((size_t) (longueur_totale + (*longueur_effective)))
1.52 bertrand 3935: * sizeof(unsigned char))) == NULL)
1.1 bertrand 3936: {
1.52 bertrand 3937: (*s_etat_processus).erreur_systeme =
3938: d_es_allocation_memoire;
3939: return(NULL);
1.1 bertrand 3940: }
3941:
1.52 bertrand 3942: memcpy(&(chaine[longueur_totale]), chaine_formatee,
1.61 bertrand 3943: (size_t) (*longueur_effective));
1.52 bertrand 3944: longueur_totale += (*longueur_effective);
3945: free(chaine_formatee);
3946: }
1.1 bertrand 3947:
1.59 bertrand 3948: if (format_sortie != 'N')
3949: {
3950: l_element_courant_format =
3951: (*l_element_courant_format).suivant;
3952: }
1.72 bertrand 3953:
3954: nombre_elements++;
3955: l_element_courant = (*l_element_courant).suivant;
1.1 bertrand 3956: }
3957:
1.59 bertrand 3958: if (format_sortie != 'N')
1.52 bertrand 3959: {
1.59 bertrand 3960: if ((l_element_courant != NULL) ||
3961: (l_element_courant_format != NULL))
3962: {
3963: free(chaine);
1.1 bertrand 3964:
1.59 bertrand 3965: (*s_etat_processus).erreur_execution =
3966: d_ex_erreur_format_fichier;
3967: return(NULL);
3968: }
1.1 bertrand 3969: }
3970:
1.52 bertrand 3971: (*longueur_effective) = longueur_totale;
3972: }
3973: else if ((*s_objet).type == TBL)
3974: {
3975:
3976: /*
3977: --------------------------------------------------------------------------------
3978: Table
1.85 ! bertrand 3979: Bits de poids fort : 1001
1.52 bertrand 3980: --------------------------------------------------------------------------------
3981: */
1.1 bertrand 3982:
1.85 ! bertrand 3983: chaine = malloc(sizeof(unsigned char));
1.1 bertrand 3984:
1.85 ! bertrand 3985: if (chaine == NULL)
! 3986: {
! 3987: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3988: return(NULL);
! 3989: }
1.1 bertrand 3990:
1.85 ! bertrand 3991: type_binaire = 0x90;
! 3992: longueur_liste = (*((struct_tableau *) (*s_objet).objet))
! 3993: .nombre_elements;
1.1 bertrand 3994:
1.85 ! bertrand 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
1.60 bertrand 4013: {
1.85 ! bertrand 4014: chaine[0] = (unsigned char) (type_binaire | 0x0B);
1.60 bertrand 4015: }
4016:
1.85 ! bertrand 4017: longueur_totale = 1;
1.60 bertrand 4018:
1.85 ! bertrand 4019: if ((chaine[0] & 0x8) != 0)
! 4020: { // Longueur sur un entier distinct de l'en-tête
! 4021: switch(chaine[0] & 0x03)
1.60 bertrand 4022: {
1.85 ! bertrand 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: }
1.60 bertrand 4097:
1.85 ! bertrand 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: }
1.60 bertrand 4116:
1.85 ! bertrand 4117: default :
! 4118: {
! 4119: BUG(1, printf("Internal format error\n"));
! 4120: }
! 4121: }
1.60 bertrand 4122: }
1.85 ! bertrand 4123:
! 4124: if ((*s_format).type == CHN)
1.60 bertrand 4125: {
1.85 ! bertrand 4126: if ((format_chaine = conversion_majuscule(
! 4127: s_etat_processus, (unsigned char *)
! 4128: (*s_format).objet)) == NULL)
1.60 bertrand 4129: {
4130: (*s_etat_processus).erreur_systeme =
4131: d_es_allocation_memoire;
4132: return(NULL);
4133: }
4134:
1.85 ! bertrand 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: }
1.60 bertrand 4176:
1.85 ! bertrand 4177: if (format_chaine[position_1] == d_code_fin_chaine)
1.60 bertrand 4178: {
1.85 ! bertrand 4179: free(chaine);
! 4180: free(format_chaine);
! 4181:
! 4182: (*s_etat_processus).erreur_execution =
! 4183: d_ex_erreur_format_fichier;
1.60 bertrand 4184: return(NULL);
4185: }
4186:
1.85 ! bertrand 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: }
1.60 bertrand 4199:
1.85 ! bertrand 4200: longueur_champ = longueur;
! 4201: }
! 4202: else
1.60 bertrand 4203: {
1.85 ! bertrand 4204: longueur_champ = -1;
! 4205: longueur = -1;
1.60 bertrand 4206: }
4207:
1.85 ! bertrand 4208: free(format_chaine);
1.60 bertrand 4209:
1.85 ! bertrand 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)
1.60 bertrand 5244: {
5245: (*s_etat_processus).erreur_systeme =
5246: d_es_allocation_memoire;
5247: return(NULL);
5248: }
5249:
1.61 bertrand 5250: chaine[0] = (unsigned char) (0xE0 | 0x0B);
1.60 bertrand 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;
1.1 bertrand 5266: }
1.52 bertrand 5267: else if ((*s_objet).type == REL)
1.1 bertrand 5268: {
5269:
5270: /*
5271: --------------------------------------------------------------------------------
1.52 bertrand 5272: Réel
5273: Poids fort 0001 01
1.1 bertrand 5274: --------------------------------------------------------------------------------
5275: */
5276:
1.57 bertrand 5277: if (format_sortie == 'N')
5278: {
5279: format_sortie = 'R';
5280: longueur = 8;
5281: }
5282:
1.52 bertrand 5283: if ((format_sortie != 'R') && (format_sortie != 'C'))
1.1 bertrand 5284: {
5285: (*s_etat_processus).erreur_execution =
5286: d_ex_erreur_format_fichier;
5287: return(NULL);
5288: }
5289:
1.52 bertrand 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: */
1.84 bertrand 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);
1.85 ! bertrand 5425: free(chaine_tampon);
1.84 bertrand 5426: }
1.52 bertrand 5427: }
5428: else if ((*s_objet).type == VIN)
5429: {
5430:
5431: /*
5432: --------------------------------------------------------------------------------
5433: Vecteur entier
5434: --------------------------------------------------------------------------------
5435: */
1.84 bertrand 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: {
1.85 ! bertrand 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:
1.84 bertrand 5561: break;
5562: }
5563:
5564: case 'R':
5565: {
1.85 ! bertrand 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:
1.84 bertrand 5581: chaine[0] |= 0x80;
5582: break;
5583: }
5584:
5585: case 'C':
5586: {
1.85 ! bertrand 5587: switch(longueur)
! 5588: {
! 5589: case 8:
! 5590: {
! 5591: break;
! 5592: }
1.84 bertrand 5593:
1.85 ! bertrand 5594: default:
! 5595: case 16:
! 5596: {
! 5597: chaine[0] |= 0x01;
! 5598: break;
! 5599: }
! 5600: }
1.84 bertrand 5601:
1.85 ! bertrand 5602: chaine[0] |= 0x90;
1.84 bertrand 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);
1.85 ! bertrand 5620: free(chaine_tampon);
1.84 bertrand 5621: }
1.52 bertrand 5622: }
5623: else if ((*s_objet).type == VRL)
5624: {
5625:
5626: /*
5627: --------------------------------------------------------------------------------
5628: Vecteur réel
5629: --------------------------------------------------------------------------------
5630: */
1.84 bertrand 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);
1.85 ! bertrand 5766: free(chaine_tampon);
1.84 bertrand 5767: }
1.52 bertrand 5768: }
5769: else
5770: {
5771: // Type non exportable
1.1 bertrand 5772:
1.52 bertrand 5773: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
5774: free(chaine);
1.1 bertrand 5775:
1.52 bertrand 5776: return(NULL);
5777: }
1.1 bertrand 5778:
1.52 bertrand 5779: // On n'ajoute la longueur de l'enregistrement que dans le cas
5780: // où le format est utilisé dans un fichier.
1.1 bertrand 5781:
1.52 bertrand 5782: if (((*recursivite) == 1) && (export_fichier == d_vrai))
5783: {
5784: // Ajout de la longueur totale en fin d'enregistrement.
1.1 bertrand 5785:
1.52 bertrand 5786: longueur_totale = (*longueur_effective);
1.1 bertrand 5787:
1.52 bertrand 5788: if (longueur_totale < (((integer8) 1) << 7))
5789: {
1.61 bertrand 5790: tampon[0] = (unsigned char) (((longueur_totale + 1) << 1)
5791: & 0xFF);
1.1 bertrand 5792:
1.61 bertrand 5793: if ((chaine = realloc(chaine, (((size_t) longueur_totale) + 1)
1.52 bertrand 5794: * sizeof(unsigned char))) == NULL)
5795: {
5796: (*s_etat_processus).erreur_systeme =
5797: d_es_allocation_memoire;
5798: return(NULL);
5799: }
1.1 bertrand 5800:
1.52 bertrand 5801: // XXXX XXX0
5802: memcpy(&(chaine[longueur_totale]), tampon, 1);
5803: longueur_totale += 1;
5804: }
1.67 bertrand 5805: else
1.52 bertrand 5806: {
5807: longueur_totale++;
1.1 bertrand 5808:
1.67 bertrand 5809: // i = { 0 (16 bits) 2 (32 bits) 6 (64 bits) }
5810:
5811: i = 0;
5812:
5813: for(;;)
1.52 bertrand 5814: {
5815: if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))
5816: || (i == 6))
1.1 bertrand 5817: {
1.53 bertrand 5818: // LSB (4 bits de poids fort)
1.61 bertrand 5819: tampon[0] = (unsigned char) ((longueur_totale & 0xF0)
1.52 bertrand 5820: | 0x1 /* longueur supérieure à 7 bits */
1.61 bertrand 5821: | ((i + 1) << 1));
1.1 bertrand 5822:
1.52 bertrand 5823: for(j = 0; j <= i; j++)
1.1 bertrand 5824: {
1.61 bertrand 5825: tampon[(i - j) + 1] = (unsigned char)
5826: ((longueur_totale >> (8 * (j + 1)))
5827: & 0xFF);
1.1 bertrand 5828: }
5829:
1.53 bertrand 5830: // LSB (4 bits de poids faible)
1.61 bertrand 5831: tampon[i + 2] = (unsigned char)
5832: (((longueur_totale & 0x0F) << 4)
1.52 bertrand 5833: | 0x1 /* longueur supérieure à 7 bits */
1.61 bertrand 5834: | ((i + 1) << 1));
1.52 bertrand 5835: break;
1.1 bertrand 5836: }
1.67 bertrand 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: }
1.1 bertrand 5852: }
5853:
1.67 bertrand 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)))
1.52 bertrand 5860: * sizeof(unsigned char))) == NULL)
1.1 bertrand 5861: {
1.52 bertrand 5862: (*s_etat_processus).erreur_systeme =
5863: d_es_allocation_memoire;
5864: return(NULL);
5865: }
1.1 bertrand 5866:
1.52 bertrand 5867: memcpy(&(chaine[longueur_totale]), tampon, 3);
5868: longueur_totale += 3;
5869: }
1.1 bertrand 5870:
1.52 bertrand 5871: __zone();
5872: (*longueur_effective) = longueur_totale;
5873: }
5874: }
1.1 bertrand 5875:
1.52 bertrand 5876: (*recursivite)--;
1.1 bertrand 5877:
1.52 bertrand 5878: return(chaine);
5879: }
1.1 bertrand 5880:
5881:
1.52 bertrand 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: */
1.1 bertrand 5895:
5896: /*
5897: --------------------------------------------------------------------------------
1.52 bertrand 5898: Formatage des complexes, réels et entiers
1.1 bertrand 5899: --------------------------------------------------------------------------------
5900: */
5901:
1.52 bertrand 5902: unsigned char *
5903: formateur_fichier_nombre(struct_processus *s_etat_processus,
5904: void *valeur_numerique, unsigned char type,
1.61 bertrand 5905: integer8 longueur, integer8 longueur_champ, unsigned char format)
1.52 bertrand 5906: {
5907: unsigned char *chaine;
5908: unsigned char *construction_chaine;
5909: unsigned char *sauvegarde;
5910: unsigned char *tampon;
1.1 bertrand 5911:
1.52 bertrand 5912: chaine = NULL;
1.1 bertrand 5913:
1.52 bertrand 5914: switch(type)
5915: {
5916: case 'C' :
5917: {
5918: construction_chaine = (unsigned char *) malloc(
5919: 2 * sizeof(unsigned char));
1.1 bertrand 5920:
1.52 bertrand 5921: if (construction_chaine == NULL)
1.1 bertrand 5922: {
1.52 bertrand 5923: (*s_etat_processus).erreur_systeme =
5924: d_es_allocation_memoire;
5925: return(NULL);
5926: }
1.1 bertrand 5927:
1.52 bertrand 5928: strcpy(construction_chaine, "(");
1.1 bertrand 5929:
1.52 bertrand 5930: tampon = formateur_fichier_reel(s_etat_processus,
5931: (void *) &((*((struct_complexe16 *)
5932: valeur_numerique)).partie_reelle), 'R',
5933: longueur, longueur_champ, format);
1.1 bertrand 5934:
1.52 bertrand 5935: if (tampon == NULL)
5936: {
5937: (*s_etat_processus).erreur_systeme =
5938: d_es_allocation_memoire;
5939: return(NULL);
5940: }
1.1 bertrand 5941:
1.52 bertrand 5942: sauvegarde = construction_chaine;
1.1 bertrand 5943:
1.52 bertrand 5944: construction_chaine = (unsigned char *) malloc(
5945: (strlen(sauvegarde) + strlen(tampon) + 2)
5946: * sizeof(unsigned char));
1.1 bertrand 5947:
1.52 bertrand 5948: if (construction_chaine == NULL)
5949: {
5950: (*s_etat_processus).erreur_systeme =
5951: d_es_allocation_memoire;
5952: return(NULL);
5953: }
1.1 bertrand 5954:
1.52 bertrand 5955: strcpy(construction_chaine, sauvegarde);
5956: free(sauvegarde);
5957: strcat(construction_chaine, tampon);
5958: free(tampon);
1.1 bertrand 5959:
1.52 bertrand 5960: strcat(construction_chaine, ",");
1.1 bertrand 5961:
1.52 bertrand 5962: tampon = formateur_fichier_reel(s_etat_processus,
5963: (void *) &((*((struct_complexe16 *)
5964: valeur_numerique)).partie_imaginaire), 'R',
5965: longueur, longueur_champ, format);
1.1 bertrand 5966:
1.52 bertrand 5967: if (tampon == NULL)
5968: {
5969: (*s_etat_processus).erreur_systeme =
5970: d_es_allocation_memoire;
5971: return(NULL);
5972: }
1.1 bertrand 5973:
1.52 bertrand 5974: sauvegarde = construction_chaine;
1.1 bertrand 5975:
1.52 bertrand 5976: construction_chaine = (unsigned char *) malloc(
5977: (strlen(sauvegarde) + strlen(tampon) + 2)
5978: * sizeof(unsigned char));
1.1 bertrand 5979:
1.52 bertrand 5980: if (construction_chaine == NULL)
5981: {
5982: (*s_etat_processus).erreur_systeme =
5983: d_es_allocation_memoire;
5984: return(NULL);
5985: }
1.1 bertrand 5986:
1.52 bertrand 5987: strcpy(construction_chaine, sauvegarde);
5988: free(sauvegarde);
5989: strcat(construction_chaine, tampon);
5990: free(tampon);
5991: strcat(construction_chaine, ")");
1.1 bertrand 5992:
1.52 bertrand 5993: chaine = construction_chaine;
1.1 bertrand 5994:
1.52 bertrand 5995: break;
1.1 bertrand 5996: }
1.52 bertrand 5997:
5998: case 'R' :
1.1 bertrand 5999: {
1.52 bertrand 6000: chaine = formateur_fichier_reel(s_etat_processus,
6001: valeur_numerique, 'R', longueur, longueur_champ,
6002: format);
1.1 bertrand 6003:
6004: if (chaine == NULL)
6005: {
1.52 bertrand 6006: (*s_etat_processus).erreur_systeme =
6007: d_es_allocation_memoire;
1.1 bertrand 6008: return(NULL);
6009: }
6010:
1.52 bertrand 6011: break;
1.1 bertrand 6012: }
1.52 bertrand 6013:
6014: default :
6015: case 'I' :
1.1 bertrand 6016: {
1.52 bertrand 6017: chaine = formateur_fichier_reel(s_etat_processus,
6018: valeur_numerique, 'I', longueur, longueur_champ,
6019: format);
1.1 bertrand 6020:
1.52 bertrand 6021: if (chaine == NULL)
1.1 bertrand 6022: {
1.52 bertrand 6023: (*s_etat_processus).erreur_systeme =
6024: d_es_allocation_memoire;
1.1 bertrand 6025: return(NULL);
6026: }
6027:
1.52 bertrand 6028: break;
1.1 bertrand 6029: }
1.52 bertrand 6030: }
6031:
6032: return(chaine);
6033: }
6034:
1.1 bertrand 6035:
6036: /*
6037: --------------------------------------------------------------------------------
1.52 bertrand 6038: Formateur des réels et entiers
1.1 bertrand 6039: --------------------------------------------------------------------------------
6040: */
6041:
1.52 bertrand 6042: unsigned char *
6043: formateur_fichier_reel(struct_processus *s_etat_processus,
6044: void *valeur_numerique, unsigned char type,
1.61 bertrand 6045: integer8 longueur, integer8 longueur_champ,
1.52 bertrand 6046: unsigned char format_sortie)
6047: {
6048: real8 mantisse;
6049: real8 tampon_reel;
1.1 bertrand 6050:
1.62 bertrand 6051: integer8 i;
1.52 bertrand 6052: integer8 tampon_entier;
1.1 bertrand 6053:
1.52 bertrand 6054: long correction;
6055: long exposant;
6056: long longueur_utile;
6057: long longueur_utile_limite;
1.1 bertrand 6058:
1.52 bertrand 6059: unsigned char *chaine;
6060: unsigned char format[16 + 1];
6061: unsigned char mode[3 + 1];
6062: unsigned char tampon[16 + 1];
1.1 bertrand 6063:
1.52 bertrand 6064: chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
1.1 bertrand 6065:
1.52 bertrand 6066: if (chaine == NULL)
6067: {
6068: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
6069: return(NULL);
6070: }
1.1 bertrand 6071:
1.52 bertrand 6072: if (type == 'R')
6073: {
6074: tampon_reel = *((real8 *) valeur_numerique);
1.1 bertrand 6075:
1.52 bertrand 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: }
1.1 bertrand 6088:
1.61 bertrand 6089: mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
1.52 bertrand 6090: }
6091: else
6092: {
6093: tampon_entier = *((integer8 *) valeur_numerique);
1.1 bertrand 6094:
1.52 bertrand 6095: if (tampon_entier > ((integer8) 0))
6096: {
1.61 bertrand 6097: exposant = (long) floor(log10((double) tampon_entier));
1.52 bertrand 6098: }
6099: else if (tampon_entier < ((integer8) 0))
6100: {
1.61 bertrand 6101: exposant = (long) floor(log10((double) -tampon_entier));
1.1 bertrand 6102: }
1.52 bertrand 6103: else
1.1 bertrand 6104: {
1.52 bertrand 6105: exposant = 0;
6106: }
1.1 bertrand 6107:
1.61 bertrand 6108: mantisse = ((real8) (*((integer8 *) valeur_numerique))) /
6109: pow(10, (double) exposant);
1.52 bertrand 6110: }
1.1 bertrand 6111:
1.63 bertrand 6112: longueur_utile = (long) longueur;
1.52 bertrand 6113: longueur_utile_limite = 15;
1.1 bertrand 6114:
1.52 bertrand 6115: if (longueur_utile > longueur_utile_limite)
6116: {
6117: longueur_utile = longueur_utile_limite;
6118: }
1.1 bertrand 6119:
1.52 bertrand 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: }
1.1 bertrand 6136:
1.52 bertrand 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;
1.1 bertrand 6147:
1.52 bertrand 6148: if (strcmp(mode, "STD") == 0)
6149: {
6150: longueur_utile = longueur_utile_limite - 1;
6151: }
1.1 bertrand 6152:
1.52 bertrand 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;
1.1 bertrand 6165:
1.52 bertrand 6166: if (longueur_utile + exposant >= longueur_utile_limite)
6167: {
6168: longueur_utile = longueur_utile_limite - (exposant + 1);
6169: }
1.1 bertrand 6170:
1.52 bertrand 6171: sprintf(format, "%%.%luf", longueur_utile);
1.1 bertrand 6172:
1.61 bertrand 6173: sprintf(tampon, format, (mantisse * pow(10, (double) exposant)));
1.52 bertrand 6174: strcpy(chaine, tampon);
6175: }
6176: else if (strcmp(mode, "ENG") == 0)
6177: {
6178: chaine[0] = 0;
6179: format[0] = 0;
1.1 bertrand 6180:
1.52 bertrand 6181: correction = labs(exposant) % 3;
1.1 bertrand 6182:
1.52 bertrand 6183: if (exposant < 0)
6184: {
6185: if (correction == 0)
6186: {
6187: correction = 3;
1.1 bertrand 6188: }
1.52 bertrand 6189:
6190: correction = 3 - correction;
6191: }
6192:
6193: longueur_utile -= correction;
6194: sprintf(format, "%%.%luf", longueur_utile);
6195:
1.61 bertrand 6196: sprintf(tampon, format, (mantisse * pow(10, (double) correction)));
1.52 bertrand 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));
1.1 bertrand 6208: }
1.52 bertrand 6209: else
1.1 bertrand 6210: {
1.52 bertrand 6211: chaine[0] = 0;
6212: format[0] = 0;
1.1 bertrand 6213:
1.52 bertrand 6214: if (exposant >= 0)
6215: {
6216: sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
6217: - 1));
6218: }
6219: else
1.1 bertrand 6220: {
1.52 bertrand 6221: sprintf(format, "%%.%luf", longueur_utile_limite);
1.1 bertrand 6222: }
6223:
1.52 bertrand 6224: sprintf(tampon, format, *((real8 *) valeur_numerique));
1.1 bertrand 6225:
1.62 bertrand 6226: i = (integer8) (strlen(tampon)) - 1;
1.52 bertrand 6227: while(tampon[i] == '0')
1.1 bertrand 6228: {
1.52 bertrand 6229: tampon[i] = 0;
6230: i--;
6231: }
1.1 bertrand 6232:
1.52 bertrand 6233: if (ds_imposition_separateur_decimal == d_faux)
6234: {
1.62 bertrand 6235: i = ((integer8) strlen(tampon)) - 1;
1.52 bertrand 6236: if (tampon[i] == '.')
1.1 bertrand 6237: {
1.52 bertrand 6238: tampon[i] = 0;
1.1 bertrand 6239: }
6240: }
6241: }
1.52 bertrand 6242:
6243: strcpy(chaine, tampon);
6244: }
6245:
6246: if (longueur_champ >= 0)
6247: {
6248: if (strlen(chaine) > (size_t) longueur_champ)
1.1 bertrand 6249: {
1.62 bertrand 6250: for(i = 0; i < longueur_champ; i++)
1.52 bertrand 6251: {
6252: chaine[i] = '*';
6253: }
1.1 bertrand 6254:
1.52 bertrand 6255: chaine[i] = d_code_fin_chaine;
1.1 bertrand 6256: }
6257: }
6258:
6259: return(chaine);
6260: }
6261:
6262:
6263: /*
6264: --------------------------------------------------------------------------------
1.52 bertrand 6265: Mêmes fonctions mais pour les fichiers binaires
1.1 bertrand 6266: --------------------------------------------------------------------------------
6267: */
6268:
6269: unsigned char *
1.52 bertrand 6270: formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,
6271: void *valeur_numerique, unsigned char type_entree,
1.61 bertrand 6272: unsigned char type, integer8 longueur, integer8 *longueur_conversion)
1.1 bertrand 6273: {
6274: unsigned char *chaine;
6275:
6276: switch(type)
6277: {
1.52 bertrand 6278: case 'I' :
1.1 bertrand 6279: {
1.52 bertrand 6280: if (type_entree != type)
1.1 bertrand 6281: {
1.52 bertrand 6282: (*s_etat_processus).erreur_execution = d_ex_representation;
1.1 bertrand 6283: return(NULL);
6284: }
6285:
1.52 bertrand 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;
1.61 bertrand 6306: chaine[0] = (unsigned char) 0x10;
6307: chaine[1] = (unsigned char) ((*((integer8 *)
6308: valeur_numerique)) & 0xFF);
1.52 bertrand 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;
1.61 bertrand 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);
1.52 bertrand 6335: break;
6336: }
6337:
6338: case 4:
6339: {
6340: if ((*((integer8 *) valeur_numerique)) !=
1.55 bertrand 6341: ((integer4) (*((integer8 *) valeur_numerique))))
1.52 bertrand 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;
1.61 bertrand 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);
1.52 bertrand 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: }
1.1 bertrand 6376:
1.52 bertrand 6377: (*longueur_conversion) = 9;
1.61 bertrand 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);
1.52 bertrand 6395: break;
6396: }
1.1 bertrand 6397:
1.52 bertrand 6398: default :
6399: {
6400: (*s_etat_processus).erreur_execution =
6401: d_ex_erreur_format_fichier;
6402: return(NULL);
6403: }
1.1 bertrand 6404: }
6405:
1.52 bertrand 6406: break;
6407: }
1.1 bertrand 6408:
1.52 bertrand 6409: case 'R' :
6410: {
6411: switch(longueur)
1.1 bertrand 6412: {
1.52 bertrand 6413: case 4:
6414: {
6415: real8 valeur;
6416: real8 vinf;
6417: real8 vsup;
1.1 bertrand 6418:
1.52 bertrand 6419: union
6420: {
6421: real4 r4;
6422: integer4 i4;
6423: } eq4;
1.1 bertrand 6424:
1.52 bertrand 6425: if (type_entree == 'R')
6426: {
6427: valeur = (*((real8 *) valeur_numerique));
6428: }
6429: else if (type_entree == 'I')
6430: {
1.61 bertrand 6431: valeur = (real8) (*((integer8 *) valeur_numerique));
1.52 bertrand 6432: }
6433: else
6434: {
6435: (*s_etat_processus).erreur_execution =
6436: d_ex_representation;
6437: return(NULL);
6438: }
1.1 bertrand 6439:
1.52 bertrand 6440: if (valeur > 0)
6441: {
6442: vinf = nextafter(valeur, 0);
6443: vsup = nextafter(valeur, valeur * 2);
6444: }
1.84 bertrand 6445: else if (valeur < 0)
1.52 bertrand 6446: {
6447: vinf = nextafter(valeur, valeur * 2);
6448: vsup = nextafter(valeur, 0);
6449: }
1.84 bertrand 6450: else
6451: {
6452: vinf = valeur;
6453: vsup = valeur;
6454: }
1.1 bertrand 6455:
1.84 bertrand 6456: if (!((((real4) vinf) <= ((real4) valeur)) &&
6457: (((real4) valeur) <= ((real4) vsup))))
1.52 bertrand 6458: {
6459: (*s_etat_processus).erreur_execution =
6460: d_ex_representation;
6461: return(NULL);
6462: }
1.1 bertrand 6463:
1.52 bertrand 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: }
1.1 bertrand 6470:
1.52 bertrand 6471: eq4.r4 = (real4) valeur;
6472: (*longueur_conversion) = 5;
1.61 bertrand 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);
1.52 bertrand 6478: break;
6479: }
1.1 bertrand 6480:
1.52 bertrand 6481: case 8:
6482: {
6483: union
6484: {
6485: real8 r8;
6486: integer8 i8;
6487: } eq8;
1.1 bertrand 6488:
1.52 bertrand 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: }
1.1 bertrand 6495:
1.52 bertrand 6496: if (type_entree == 'I')
6497: {
1.61 bertrand 6498: eq8.r8 = (real8) (*((integer8 *) valeur_numerique));
1.52 bertrand 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: }
1.1 bertrand 6510:
1.52 bertrand 6511: (*longueur_conversion) = 9;
1.61 bertrand 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);
1.52 bertrand 6521: break;
6522: }
1.1 bertrand 6523:
1.52 bertrand 6524: default :
6525: {
6526: (*s_etat_processus).erreur_execution =
6527: d_ex_erreur_format_fichier;
6528: return(NULL);
6529: }
1.1 bertrand 6530: }
6531:
6532: break;
6533: }
6534:
1.52 bertrand 6535: case 'C' :
1.1 bertrand 6536: {
1.52 bertrand 6537: switch(longueur)
1.1 bertrand 6538: {
1.52 bertrand 6539: case 8:
6540: {
6541: unsigned char *partie_reelle;
6542: unsigned char *partie_imaginaire;
1.1 bertrand 6543:
1.61 bertrand 6544: integer8 limag;
6545: integer8 lreel;
1.1 bertrand 6546:
1.52 bertrand 6547: real8 zero;
1.1 bertrand 6548:
1.52 bertrand 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: }
1.1 bertrand 6558:
1.52 bertrand 6559: zero = 0;
1.1 bertrand 6560:
1.52 bertrand 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: }
1.1 bertrand 6579:
1.52 bertrand 6580: zero = 0;
1.1 bertrand 6581:
1.52 bertrand 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: }
1.1 bertrand 6600:
1.52 bertrand 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: }
1.1 bertrand 6617:
1.61 bertrand 6618: if ((chaine = malloc((((size_t) lreel) + ((size_t) limag)
6619: - 1) * sizeof(unsigned char))) == NULL)
1.52 bertrand 6620: {
6621: free(partie_reelle);
6622: free(partie_imaginaire);
1.1 bertrand 6623:
1.52 bertrand 6624: (*s_etat_processus).erreur_systeme =
6625: d_es_allocation_memoire;
6626: return(NULL);
6627: }
1.1 bertrand 6628:
1.61 bertrand 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);
1.52 bertrand 6634: (*longueur_conversion) = lreel + limag - 1;
1.1 bertrand 6635:
1.52 bertrand 6636: free(partie_reelle);
6637: free(partie_imaginaire);
6638: break;
6639: }
1.1 bertrand 6640:
1.52 bertrand 6641: case 16:
6642: {
6643: unsigned char *partie_reelle;
6644: unsigned char *partie_imaginaire;
1.1 bertrand 6645:
1.61 bertrand 6646: integer8 limag;
6647: integer8 lreel;
6648:
1.52 bertrand 6649: real8 zero;
1.1 bertrand 6650:
1.52 bertrand 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: }
1.1 bertrand 6660:
1.52 bertrand 6661: zero = 0;
1.1 bertrand 6662:
1.52 bertrand 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: }
1.1 bertrand 6681:
1.52 bertrand 6682: zero = 0;
1.1 bertrand 6683:
1.52 bertrand 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: }
1.1 bertrand 6702:
1.52 bertrand 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: }
1.1 bertrand 6719:
1.61 bertrand 6720: if ((chaine = malloc((((size_t) lreel) + ((size_t) limag)
6721: - 1) * sizeof(unsigned char))) == NULL)
1.52 bertrand 6722: {
6723: free(partie_reelle);
6724: free(partie_imaginaire);
1.1 bertrand 6725:
1.52 bertrand 6726: (*s_etat_processus).erreur_systeme =
6727: d_es_allocation_memoire;
6728: return(NULL);
6729: }
1.1 bertrand 6730:
1.61 bertrand 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);
1.52 bertrand 6736: (*longueur_conversion) = lreel + limag - 1;
1.1 bertrand 6737:
1.52 bertrand 6738: free(partie_reelle);
6739: free(partie_imaginaire);
6740: break;
6741: }
1.1 bertrand 6742:
1.52 bertrand 6743: default :
1.1 bertrand 6744: {
1.52 bertrand 6745: (*s_etat_processus).erreur_execution =
6746: d_ex_erreur_format_fichier;
6747: return(NULL);
1.1 bertrand 6748: }
6749: }
1.52 bertrand 6750:
6751: break;
1.1 bertrand 6752: }
1.51 bertrand 6753:
1.52 bertrand 6754: default :
1.1 bertrand 6755: {
1.52 bertrand 6756: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
6757: return(NULL);
1.1 bertrand 6758: }
6759: }
6760:
6761: return(chaine);
6762: }
1.34 bertrand 6763:
6764:
6765: /*
1.52 bertrand 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 *.
1.34 bertrand 6772: --------------------------------------------------------------------------------
1.52 bertrand 6773: Sorties : pointeur sur un struct_objet nouvellement alloué
1.34 bertrand 6774: --------------------------------------------------------------------------------
1.52 bertrand 6775: Effets de bord : néant
6776: ================================================================================
1.34 bertrand 6777: */
6778:
1.52 bertrand 6779: struct_objet *
6780: lecture_fichier_non_formate(struct_processus *s_etat_processus,
6781: void *argument, integer8 longueur_buffer, logical1 recursivite)
1.34 bertrand 6782: {
1.52 bertrand 6783: file *fichier;
6784:
1.53 bertrand 6785: int j;
6786:
1.52 bertrand 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;
1.53 bertrand 6797: unsigned char *flux;
1.52 bertrand 6798: unsigned char *ptr;
1.59 bertrand 6799: unsigned char type_objet;
1.52 bertrand 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: {
1.55 bertrand 6811: buffer = (*((unsigned char **) argument));
1.52 bertrand 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: {
1.53 bertrand 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:
1.52 bertrand 6830: return(NULL);
6831: }
6832: }
6833: else
6834: {
1.53 bertrand 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: }
1.52 bertrand 6844: }
1.34 bertrand 6845:
1.59 bertrand 6846: switch(type_objet = (octets[0] & 0xF0))
1.34 bertrand 6847: {
1.54 bertrand 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])
1.61 bertrand 6930: << (8 * ((((signed) deplacement) - 1) - i));
1.54 bertrand 6931: }
6932:
6933: break;
6934: }
6935:
1.52 bertrand 6936: case 0x10: // Scalaire
1.34 bertrand 6937: {
1.52 bertrand 6938: switch(octets[0] & 0x0C)
1.34 bertrand 6939: {
1.52 bertrand 6940: case 0x00: // Entier
1.34 bertrand 6941: {
1.52 bertrand 6942: switch(octets[0] & 0x03)
1.34 bertrand 6943: {
1.52 bertrand 6944: case 0x00: // integer*1
6945: {
6946: deplacement = 1;
6947: break;
6948: }
1.34 bertrand 6949:
1.52 bertrand 6950: case 0x01: // integer*2
6951: {
6952: deplacement = 2;
6953: break;
6954: }
1.34 bertrand 6955:
1.52 bertrand 6956: case 0x02: // integer*4
6957: {
6958: deplacement = 4;
6959: break;
6960: }
1.34 bertrand 6961:
1.52 bertrand 6962: case 0x03: // integer*8
6963: {
6964: deplacement = 8;
6965: break;
6966: }
1.34 bertrand 6967: }
6968:
1.52 bertrand 6969: if (longueur_buffer < 0)
1.34 bertrand 6970: {
1.52 bertrand 6971: if (fread(octets, (size_t) sizeof(unsigned char),
6972: deplacement, fichier) != deplacement)
6973: {
1.53 bertrand 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:
1.52 bertrand 6985: return(NULL);
6986: }
1.34 bertrand 6987: }
1.52 bertrand 6988: else
1.34 bertrand 6989: {
1.53 bertrand 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
1.52 bertrand 6999: {
1.53 bertrand 7000: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
7001: return(NULL);
1.52 bertrand 7002: }
1.34 bertrand 7003: }
7004:
1.53 bertrand 7005: if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
7006: {
7007: return(NULL);
7008: }
7009:
1.64 bertrand 7010: // Récupération des données avec extension de signe.
1.34 bertrand 7011:
7012: {
1.64 bertrand 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:
1.66 bertrand 7028: i1 = (integer1) octets[0];
1.64 bertrand 7029: break;
7030:
7031: case 2:
1.65 bertrand 7032: i2 |= (integer2) (((integer8) octets[i]) <<
1.64 bertrand 7033: (8 * ((((signed) deplacement) - 1)
7034: - i)));
7035: break;
7036:
7037: case 4:
1.65 bertrand 7038: i4 |= (integer4) (((integer8) octets[i]) <<
1.64 bertrand 7039: (8 * ((((signed) deplacement) - 1)
7040: - i)));
7041: break;
7042:
7043: case 8:
1.65 bertrand 7044: i8 |= (integer8) (((integer8) octets[i]) <<
1.64 bertrand 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: }
1.34 bertrand 7073: }
7074:
7075: break;
7076: }
7077:
1.52 bertrand 7078: case 0x04: // Réel
1.34 bertrand 7079: {
1.52 bertrand 7080: switch(octets[0] & 0x03)
7081: {
7082: case 0x00: // real*4
7083: {
7084: deplacement = 4;
7085: break;
7086: }
1.34 bertrand 7087:
1.52 bertrand 7088: case 0x01: // real*8
7089: {
7090: deplacement = 8;
7091: break;
7092: }
1.34 bertrand 7093:
1.52 bertrand 7094: default:
7095: {
7096: (*s_etat_processus).erreur_execution =
7097: d_ex_syntaxe;
7098: return(NULL);
7099: }
7100: }
1.34 bertrand 7101:
1.52 bertrand 7102: if (longueur_buffer < 0)
1.34 bertrand 7103: {
1.52 bertrand 7104: if (fread(octets, (size_t) sizeof(unsigned char),
7105: deplacement, fichier) != deplacement)
7106: {
1.53 bertrand 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:
1.52 bertrand 7118: return(NULL);
7119: }
1.34 bertrand 7120: }
7121: else
7122: {
1.53 bertrand 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
1.52 bertrand 7132: {
1.53 bertrand 7133: (*s_etat_processus).erreur_execution =
7134: d_ex_syntaxe;
7135: return(NULL);
1.52 bertrand 7136: }
1.34 bertrand 7137: }
7138:
1.53 bertrand 7139: if ((s_objet = allocation(s_etat_processus, REL)) == NULL)
7140: {
7141: return(NULL);
7142: }
7143:
1.52 bertrand 7144: if (deplacement == 4)
1.34 bertrand 7145: {
1.52 bertrand 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]) <<
1.61 bertrand 7157: (8 * ((((signed) deplacement) - 1) - i));
1.52 bertrand 7158: }
7159:
7160: (*((real8 *) (*s_objet).objet)) = (real8) eq4.r4;
1.34 bertrand 7161: }
1.52 bertrand 7162: else
7163: {
7164: union
7165: {
7166: real8 r8;
7167: integer8 i8;
7168: } eq8;
1.34 bertrand 7169:
1.52 bertrand 7170: eq8.i8 = 0;
7171:
7172: for(i = 0; i < (signed) deplacement; i++)
7173: {
7174: eq8.i8 |= ((integer8) octets[i]) <<
1.61 bertrand 7175: (8 * ((((signed) deplacement) - 1) - i));
1.52 bertrand 7176: }
7177:
7178: (*((real8 *) (*s_objet).objet)) = (real8) eq8.r8;
1.34 bertrand 7179: }
7180:
7181: break;
7182: }
7183:
1.52 bertrand 7184: case 0x08: // Complexe
1.34 bertrand 7185: {
1.53 bertrand 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:
1.52 bertrand 7208: if ((s_objet = allocation(s_etat_processus, CPL)) == NULL)
1.34 bertrand 7209: {
7210: return(NULL);
7211: }
7212:
1.53 bertrand 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]) <<
1.61 bertrand 7268: (8 * ((((signed) deplacement) - 1)
7269: - i));
1.53 bertrand 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]) <<
1.61 bertrand 7296: (8 * ((((signed) deplacement) - 1)
7297: - i));
1.53 bertrand 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:
1.34 bertrand 7313: break;
7314: }
7315:
1.52 bertrand 7316: default:
1.34 bertrand 7317: {
1.52 bertrand 7318: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
1.34 bertrand 7319: return(NULL);
7320: }
7321: }
7322:
7323: break;
7324: }
7325:
1.52 bertrand 7326: case 0x40: // Liste
1.59 bertrand 7327: case 0x60: // Expression
7328: case 0x70: // Expression algébrique
1.34 bertrand 7329: {
1.52 bertrand 7330: if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits
7331: {
7332: longueur = (octets[0] & 0x07);
7333: }
7334: else
1.34 bertrand 7335: {
1.52 bertrand 7336: switch(octets[0] & 0x07)
1.34 bertrand 7337: {
1.52 bertrand 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: {
1.53 bertrand 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:
1.52 bertrand 7356: return(NULL);
7357: }
7358: }
7359: else
7360: {
1.53 bertrand 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: }
1.52 bertrand 7371: }
1.34 bertrand 7372:
1.52 bertrand 7373: longueur = octets[0];
7374: break;
7375: }
1.34 bertrand 7376:
1.52 bertrand 7377: case 0x01: // Longueur sur 16 bits
1.34 bertrand 7378: {
1.52 bertrand 7379: if (longueur_buffer < 0)
7380: {
7381: if (fread(octets, (size_t) sizeof(unsigned char),
7382: 2, fichier) != 2)
7383: {
1.53 bertrand 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:
1.52 bertrand 7395: return(NULL);
7396: }
7397: }
7398: else
7399: {
1.53 bertrand 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: }
1.52 bertrand 7410: }
7411:
7412: longueur = (((integer8) (octets[0])) << 8)
7413: | ((integer8) (octets[1]));
7414: break;
1.34 bertrand 7415: }
7416:
1.52 bertrand 7417: case 0x02: // Longueur sur 32 bits
1.34 bertrand 7418: {
1.52 bertrand 7419: if (longueur_buffer < 0)
7420: {
7421: if (fread(octets, (size_t) sizeof(unsigned char),
7422: 4, fichier) != 4)
7423: {
1.53 bertrand 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:
1.52 bertrand 7435: return(NULL);
7436: }
7437: }
7438: else
7439: {
1.53 bertrand 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: }
1.52 bertrand 7450: }
7451:
7452: longueur = (((integer8) (octets[0])) << 24)
7453: | (((integer8) (octets[1])) << 16)
7454: | (((integer8) (octets[2])) << 8)
7455: | ((integer8) (octets[3]));
7456: break;
1.34 bertrand 7457: }
7458:
1.52 bertrand 7459: case 0x03: // Longueur sur 64 bits
1.34 bertrand 7460: {
1.52 bertrand 7461: if (longueur_buffer < 0)
7462: {
7463: if (fread(octets, (size_t) sizeof(unsigned char),
7464: 8, fichier) != 8)
7465: {
1.53 bertrand 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:
1.52 bertrand 7477: return(NULL);
7478: }
7479: }
7480: else
7481: {
1.53 bertrand 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: }
1.52 bertrand 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: }
1.34 bertrand 7504:
1.52 bertrand 7505: default:
7506: {
7507: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
1.34 bertrand 7508: return(NULL);
7509: }
1.52 bertrand 7510: }
7511: }
7512:
1.59 bertrand 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)
1.52 bertrand 7521: {
1.59 bertrand 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: }
1.52 bertrand 7533: }
1.34 bertrand 7534:
1.52 bertrand 7535: l_element_courant = NULL;
1.34 bertrand 7536:
1.52 bertrand 7537: for(i = 0; i < longueur; i++)
7538: {
7539: // Lecture des éléments de la liste.
1.34 bertrand 7540:
1.52 bertrand 7541: if (longueur_buffer < 0)
1.34 bertrand 7542: {
1.52 bertrand 7543: if ((s_objet_elementaire = lecture_fichier_non_formate(
7544: s_etat_processus, fichier, longueur_buffer, d_vrai))
1.34 bertrand 7545: == NULL)
7546: {
1.52 bertrand 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);
1.34 bertrand 7558: return(NULL);
7559: }
1.52 bertrand 7560: }
1.34 bertrand 7561:
1.52 bertrand 7562: if (l_element_courant == NULL)
7563: {
7564: if (((*s_objet).objet = allocation_maillon(
7565: s_etat_processus)) == NULL)
1.34 bertrand 7566: {
1.52 bertrand 7567: liberation(s_etat_processus, s_objet_elementaire);
7568: liberation(s_etat_processus, s_objet);
1.34 bertrand 7569: return(NULL);
7570: }
7571:
1.52 bertrand 7572: l_element_courant = (*s_objet).objet;
7573: }
7574: else
7575: {
7576: if (((*l_element_courant).suivant = allocation_maillon(
7577: s_etat_processus)) == NULL)
1.34 bertrand 7578: {
1.52 bertrand 7579: liberation(s_etat_processus, s_objet_elementaire);
7580: liberation(s_etat_processus, s_objet);
1.34 bertrand 7581: return(NULL);
7582: }
7583:
1.52 bertrand 7584: l_element_courant = (*l_element_courant).suivant;
1.34 bertrand 7585: }
7586:
1.52 bertrand 7587: (*l_element_courant).donnee = s_objet_elementaire;
7588: (*l_element_courant).suivant = NULL;
1.34 bertrand 7589: }
7590:
7591: break;
7592: }
1.52 bertrand 7593:
7594: case 0x80: // Chaîne de caractères
7595: {
1.53 bertrand 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: {
1.61 bertrand 7781: if ((flux = malloc(((size_t) longueur) * sizeof(unsigned char)))
7782: == NULL)
1.53 bertrand 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),
1.61 bertrand 7790: (size_t) longueur, fichier) != (size_t) longueur)
1.53 bertrand 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:
1.52 bertrand 7840: break;
7841: }
7842:
1.60 bertrand 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 =
1.61 bertrand 8035: malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
8036: == NULL)
1.60 bertrand 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),
1.61 bertrand 8046: (size_t) longueur, fichier) != (unsigned) longueur)
1.60 bertrand 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:
1.58 bertrand 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 =
1.61 bertrand 8296: malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
8297: == NULL)
1.58 bertrand 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),
1.61 bertrand 8307: (size_t) longueur, fichier) != (unsigned) longueur)
1.58 bertrand 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:
1.52 bertrand 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:
1.53 bertrand 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:
1.52 bertrand 8397: return(NULL);
8398: }
8399:
8400: if ((octets[0] & 0x01) != 0)
8401: {
1.61 bertrand 8402: deplacement = (size_t) (((octets[0] & 0x0F) >> 1) + 1);
1.52 bertrand 8403:
8404: if (fread(octets, (size_t) sizeof(unsigned char), deplacement,
8405: fichier) != deplacement)
8406: {
8407: liberation(s_etat_processus, s_objet);
8408:
1.53 bertrand 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:
1.52 bertrand 8418: return(NULL);
8419: }
8420: }
1.34 bertrand 8421: }
8422:
1.55 bertrand 8423: if (longueur_buffer >= 0)
8424: {
8425: (*((unsigned char **) argument)) = ptr;
8426: }
8427:
1.52 bertrand 8428: return(s_objet);
1.34 bertrand 8429: }
1.40 bertrand 8430:
8431: // vim: ts=4