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