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