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