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