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