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