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