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