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