1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.13
4: Copyright (C) 1989-2013 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #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) - 1;
1500:
1501: if (format_chaine[position_3] != ')')
1502: {
1503: free(chaine);
1504: free(format_chaine);
1505:
1506: (*s_etat_processus).erreur_execution =
1507: d_ex_erreur_format_fichier;
1508: return(NULL);
1509: }
1510:
1511: format_chaine[position_3] = d_code_fin_chaine;
1512:
1513: position_2 = position_1;
1514:
1515: while(format_chaine[position_2] != '(')
1516: {
1517: if (format_chaine[position_2] == d_code_fin_chaine)
1518: {
1519: free(chaine);
1520: free(format_chaine);
1521:
1522: (*s_etat_processus).erreur_execution =
1523: d_ex_erreur_format_fichier;
1524: return(NULL);
1525: }
1526:
1527: position_2++;
1528: }
1529:
1530: format_chaine[position_2++] = d_code_fin_chaine;
1531:
1532: if (format_degenere == d_faux)
1533: {
1534: if (sscanf(&(format_chaine[position_1]), "%ld",
1535: &longueur) != 1)
1536: {
1537: free(chaine);
1538: free(format_chaine);
1539:
1540: (*s_etat_processus).erreur_execution =
1541: d_ex_erreur_format_fichier;
1542: return(NULL);
1543: }
1544: }
1545: else
1546: {
1547: longueur = -1;
1548: }
1549:
1550: if (strcmp(&(format_chaine[position_2]), "*") != 0)
1551: {
1552: if (sscanf(&(format_chaine[position_2]), "%ld",
1553: &longueur_champ) != 1)
1554: {
1555: free(chaine);
1556: free(format_chaine);
1557:
1558: (*s_etat_processus).erreur_execution =
1559: d_ex_erreur_format_fichier;
1560: return(NULL);
1561: }
1562: }
1563: else
1564: {
1565: longueur_champ = -1;
1566: }
1567:
1568: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
1569: longueur_champ))
1570: {
1571: free(chaine);
1572: free(format_chaine);
1573:
1574: (*s_etat_processus).erreur_execution =
1575: d_ex_erreur_format_fichier;
1576: return(NULL);
1577: }
1578:
1579: free(format_chaine);
1580:
1581: chaine_sauvegarde = chaine;
1582:
1583: if ((chaine_formatee = formateur_fichier(s_etat_processus,
1584: (*l_element_courant).donnee, s_format,
1585: longueur, longueur_champ, format_sortie, type,
1586: longueur_effective, recursivite)) == NULL)
1587: {
1588: free(chaine);
1589: return(NULL);
1590: }
1591:
1592: if ((*(*l_element_courant).donnee).type == CHN)
1593: {
1594: chaine = (unsigned char *)
1595: malloc((strlen(chaine_formatee)
1596: + strlen(chaine_sauvegarde) + 4)
1597: * sizeof(unsigned char));
1598:
1599: if (chaine == NULL)
1600: {
1601: (*s_etat_processus).erreur_systeme =
1602: d_es_allocation_memoire;
1603: return(NULL);
1604: }
1605:
1606: strcpy(chaine, chaine_sauvegarde);
1607: free(chaine_sauvegarde);
1608: strcat(chaine, " \"");
1609: strcat(chaine, chaine_formatee);
1610: free(chaine_formatee);
1611: strcat(chaine, "\"");
1612: }
1613: else if ((*(*l_element_courant).donnee).type == NOM)
1614: {
1615: chaine = (unsigned char *)
1616: malloc((strlen(chaine_formatee)
1617: + strlen(chaine_sauvegarde) + 2)
1618: * sizeof(unsigned char));
1619:
1620: if (chaine == NULL)
1621: {
1622: (*s_etat_processus).erreur_systeme =
1623: d_es_allocation_memoire;
1624: return(NULL);
1625: }
1626:
1627: sprintf(chaine, "%s %s", chaine_sauvegarde,
1628: chaine_formatee);
1629: free(chaine_formatee);
1630: }
1631: else
1632: {
1633: chaine = (unsigned char *)
1634: malloc((strlen(chaine_formatee)
1635: + strlen(chaine_sauvegarde) + 2)
1636: * sizeof(unsigned char));
1637:
1638: if (chaine == NULL)
1639: {
1640: (*s_etat_processus).erreur_systeme =
1641: d_es_allocation_memoire;
1642: return(NULL);
1643: }
1644:
1645: strcpy(chaine, chaine_sauvegarde);
1646: free(chaine_sauvegarde);
1647: strcat(chaine, " ");
1648: strcat(chaine, chaine_formatee);
1649: free(chaine_formatee);
1650: }
1651: }
1652:
1653: nombre_elements++;
1654: l_element_courant = (*l_element_courant).suivant;
1655: l_element_courant_format = (*l_element_courant_format).suivant;
1656: }
1657:
1658: if ((l_element_courant != NULL) ||
1659: (l_element_courant_format != NULL))
1660: {
1661: free(chaine);
1662:
1663: (*s_etat_processus).erreur_execution =
1664: d_ex_erreur_format_fichier;
1665: return(NULL);
1666: }
1667:
1668: chaine_sauvegarde = chaine;
1669: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3)
1670: * sizeof(unsigned char));
1671:
1672: if (chaine == NULL)
1673: {
1674: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1675: return(NULL);
1676: }
1677:
1678: strcpy(chaine, chaine_sauvegarde);
1679: free(chaine_sauvegarde);
1680: strcat(chaine, " }");
1681: }
1682: else if ((*s_objet).type == TBL)
1683: {
1684:
1685: /*
1686: --------------------------------------------------------------------------------
1687: Table
1688: --------------------------------------------------------------------------------
1689: */
1690:
1691: if ((*s_format).type != TBL)
1692: {
1693: (*s_etat_processus).erreur_execution =
1694: d_ex_erreur_format_fichier;
1695: return(NULL);
1696: }
1697:
1698: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1699: l_element_courant_format = (struct_liste_chainee *)
1700: (*s_format).objet;
1701:
1702: if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
1703: (*((struct_tableau *) (*s_format).objet)).nombre_elements)
1704: {
1705: (*s_etat_processus).erreur_execution =
1706: d_ex_erreur_format_fichier;
1707: return(NULL);
1708: }
1709:
1710: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
1711:
1712: if (chaine == NULL)
1713: {
1714: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1715: return(NULL);
1716: }
1717:
1718: strcpy(chaine, "<[");
1719:
1720: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
1721: .nombre_elements; i++)
1722: {
1723: if ((((*(*((struct_tableau *) (*s_format).objet))
1724: .elements[i]).type == LST) &&
1725: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
1726: .type == LST)) ||
1727: (((*(*((struct_tableau *) (*s_format).objet))
1728: .elements[i]).type == TBL) &&
1729: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
1730: .type == TBL)))
1731: {
1732: chaine_sauvegarde = chaine;
1733:
1734: if ((chaine_formatee = formateur_fichier(s_etat_processus,
1735: (*l_element_courant).donnee,
1736: (*l_element_courant_format).donnee,
1737: 0, 0, ' ', 'F', longueur_effective, recursivite))
1738: == NULL)
1739: {
1740: return(NULL);
1741: }
1742:
1743: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
1744: + strlen(chaine_sauvegarde) + 2)
1745: * sizeof(unsigned char));
1746:
1747: if (chaine == NULL)
1748: {
1749: (*s_etat_processus).erreur_systeme =
1750: d_es_allocation_memoire;
1751: return(NULL);
1752: }
1753:
1754: strcpy(chaine, chaine_sauvegarde);
1755: free(chaine_sauvegarde);
1756: strcat(chaine, " ");
1757: strcat(chaine, chaine_formatee);
1758: free(chaine_formatee);
1759: }
1760: else if ((*(*((struct_tableau *) (*s_format).objet))
1761: .elements[i]).type != CHN)
1762: {
1763: free(chaine);
1764:
1765: (*s_etat_processus).erreur_execution =
1766: d_ex_erreur_format_fichier;
1767: return(NULL);
1768: }
1769: else
1770: {
1771: if ((format_chaine = conversion_majuscule((unsigned char *)
1772: (*(*((struct_tableau *) (*s_format).objet))
1773: .elements[i]).objet)) == NULL)
1774: {
1775: (*s_etat_processus).erreur_systeme =
1776: d_es_allocation_memoire;
1777: return(NULL);
1778: }
1779:
1780: format_degenere = d_faux;
1781:
1782: if (strncmp("STANDARD*", format_chaine, 9) == 0)
1783: {
1784: format_sortie = 'S';
1785: position_1 = 9;
1786: format_degenere = d_vrai;
1787: }
1788: else if (strncmp("BINARY*", format_chaine, 7) == 0)
1789: {
1790: format_sortie = 'B';
1791: position_1 = 7;
1792: }
1793: else if (strncmp("FIXED*", format_chaine, 6) == 0)
1794: {
1795: format_sortie = 'F';
1796: position_1 = 6;
1797: }
1798: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
1799: {
1800: format_sortie = 'I';
1801: position_1 = 11;
1802: }
1803: else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
1804: {
1805: format_sortie = 'E';
1806: position_1 = 9;
1807: }
1808: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
1809: {
1810: format_sortie = 'C';
1811: position_1 = 10;
1812: format_degenere = d_vrai;
1813: }
1814: else
1815: {
1816: free(chaine);
1817: free(format_chaine);
1818:
1819: (*s_etat_processus).erreur_execution =
1820: d_ex_erreur_format_fichier;
1821: return(NULL);
1822: }
1823:
1824: position_3 = strlen(format_chaine);
1825: format_chaine[--position_3] = d_code_fin_chaine;
1826:
1827: position_2 = position_1;
1828:
1829: while(format_chaine[position_2] != '(')
1830: {
1831: if (format_chaine[position_2] == d_code_fin_chaine)
1832: {
1833: free(chaine);
1834: free(format_chaine);
1835:
1836: (*s_etat_processus).erreur_execution =
1837: d_ex_erreur_format_fichier;
1838: return(NULL);
1839: }
1840:
1841: position_2++;
1842: }
1843:
1844: format_chaine[position_2++] = d_code_fin_chaine;
1845:
1846: if (format_degenere == d_faux)
1847: {
1848: if (sscanf(&(format_chaine[position_1]), "%ld",
1849: &longueur) != 1)
1850: {
1851: free(chaine);
1852: free(format_chaine);
1853:
1854: (*s_etat_processus).erreur_execution =
1855: d_ex_erreur_format_fichier;
1856: return(NULL);
1857: }
1858: }
1859: else
1860: {
1861: longueur = -1;
1862: }
1863:
1864: if (strcmp(&(format_chaine[position_2]), "*") != 0)
1865: {
1866: if (sscanf(&(format_chaine[position_2]), "%ld",
1867: &longueur_champ) != 1)
1868: {
1869: free(chaine);
1870: free(format_chaine);
1871:
1872: (*s_etat_processus).erreur_execution =
1873: d_ex_erreur_format_fichier;
1874: return(NULL);
1875: }
1876: }
1877: else
1878: {
1879: longueur_champ = -1;
1880: }
1881:
1882: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
1883: longueur_champ))
1884: {
1885: free(chaine);
1886: free(format_chaine);
1887:
1888: (*s_etat_processus).erreur_execution =
1889: d_ex_erreur_format_fichier;
1890: return(NULL);
1891: }
1892:
1893: free(format_chaine);
1894:
1895: chaine_sauvegarde = chaine;
1896:
1897: if ((chaine_formatee = formateur_fichier(s_etat_processus,
1898: (*((struct_tableau *) (*s_objet).objet))
1899: .elements[i], s_format,
1900: longueur, longueur_champ, format_sortie, type,
1901: longueur_effective, recursivite)) == NULL)
1902: {
1903: return(NULL);
1904: }
1905:
1906: if ((*(*((struct_tableau *) (*s_objet).objet))
1907: .elements[i]).type == CHN)
1908: {
1909: chaine = (unsigned char *)
1910: malloc((strlen(chaine_formatee)
1911: + strlen(chaine_sauvegarde) + 4)
1912: * sizeof(unsigned char));
1913:
1914: if (chaine == NULL)
1915: {
1916: (*s_etat_processus).erreur_systeme =
1917: d_es_allocation_memoire;
1918: return(NULL);
1919: }
1920:
1921: strcpy(chaine, chaine_sauvegarde);
1922: free(chaine_sauvegarde);
1923: strcat(chaine, " \"");
1924: strcat(chaine, chaine_formatee);
1925: free(chaine_formatee);
1926: strcat(chaine, "\"");
1927: }
1928: else if ((*(*((struct_tableau *) (*s_objet).objet))
1929: .elements[i]).type == NOM)
1930: {
1931: chaine = (unsigned char *)
1932: malloc((strlen(chaine_formatee)
1933: + strlen(chaine_sauvegarde) + 2)
1934: * sizeof(unsigned char));
1935:
1936: if (chaine == NULL)
1937: {
1938: (*s_etat_processus).erreur_systeme =
1939: d_es_allocation_memoire;
1940: return(NULL);
1941: }
1942:
1943: sprintf(chaine, "%s %s", chaine_sauvegarde,
1944: chaine_formatee);
1945: free(chaine_formatee);
1946: }
1947: else
1948: {
1949: chaine = (unsigned char *)
1950: malloc((strlen(chaine_formatee)
1951: + strlen(chaine_sauvegarde) + 2)
1952: * sizeof(unsigned char));
1953:
1954: if (chaine == NULL)
1955: {
1956: (*s_etat_processus).erreur_systeme =
1957: d_es_allocation_memoire;
1958: return(NULL);
1959: }
1960:
1961: strcpy(chaine, chaine_sauvegarde);
1962: free(chaine_sauvegarde);
1963: strcat(chaine, " ");
1964: strcat(chaine, chaine_formatee);
1965: free(chaine_formatee);
1966: }
1967: }
1968: }
1969:
1970: chaine_sauvegarde = chaine;
1971: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4)
1972: * sizeof(unsigned char));
1973:
1974: if (chaine == NULL)
1975: {
1976: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1977: return(NULL);
1978: }
1979:
1980: strcpy(chaine, chaine_sauvegarde);
1981: free(chaine_sauvegarde);
1982: strcat(chaine, " ]>");
1983: }
1984: else if ((*s_objet).type == MCX)
1985: {
1986:
1987: /*
1988: --------------------------------------------------------------------------------
1989: Matrice complexe
1990: --------------------------------------------------------------------------------
1991: */
1992:
1993: if ((format_sortie != 'S') && (format_sortie != 'F') &&
1994: (format_sortie != 'I') && (format_sortie != 'E'))
1995: {
1996: (*s_etat_processus).erreur_execution =
1997: d_ex_erreur_format_fichier;
1998: return(NULL);
1999: }
2000:
2001: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
2002: .nombre_lignes;
2003: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
2004: .nombre_colonnes;
2005:
2006: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2007:
2008: if (chaine != NULL)
2009: {
2010: strcpy(chaine, "[[");
2011:
2012: for(i = 0; i < nombre_lignes; i++)
2013: {
2014: for(j = 0; j < nombre_colonnes; j++)
2015: {
2016: if ((chaine_formatee =
2017: formateur_fichier_nombre(s_etat_processus,
2018: (void *) &(((struct_complexe16 **)
2019: ((*((struct_matrice *)
2020: ((*s_objet).objet))).tableau))[i][j]), 'C',
2021: longueur, longueur_champ, format_sortie))
2022: == NULL)
2023: {
2024: (*s_etat_processus).erreur_systeme =
2025: d_es_allocation_memoire;
2026: return(NULL);
2027: }
2028:
2029: chaine_sauvegarde = chaine;
2030: chaine = (unsigned char *) malloc(
2031: (strlen(chaine_sauvegarde) +
2032: strlen(chaine_formatee) + 2)
2033: * sizeof(unsigned char));
2034:
2035: if (chaine == NULL)
2036: {
2037: (*s_etat_processus).erreur_systeme =
2038: d_es_allocation_memoire;
2039: return(NULL);
2040: }
2041:
2042: strcpy(chaine, chaine_sauvegarde);
2043: free(chaine_sauvegarde);
2044: strcat(chaine, " ");
2045: strcat(chaine, chaine_formatee);
2046: free(chaine_formatee);
2047: }
2048:
2049: chaine_sauvegarde = chaine;
2050: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2051: {
2052: chaine = (unsigned char *) malloc(
2053: (strlen(chaine_sauvegarde) + 6)
2054: * sizeof(unsigned char));
2055:
2056: if (chaine == NULL)
2057: {
2058: (*s_etat_processus).erreur_systeme =
2059: d_es_allocation_memoire;
2060: return(NULL);
2061: }
2062:
2063: strcpy(chaine, chaine_sauvegarde);
2064: free(chaine_sauvegarde);
2065: strcat(chaine, " ]\n [");
2066: }
2067: else
2068: {
2069: chaine = (unsigned char *) malloc(
2070: (strlen(chaine_sauvegarde) + 4)
2071: * sizeof(unsigned char));
2072:
2073: if (chaine == NULL)
2074: {
2075: (*s_etat_processus).erreur_systeme =
2076: d_es_allocation_memoire;
2077: return(NULL);
2078: }
2079:
2080: strcpy(chaine, chaine_sauvegarde);
2081: free(chaine_sauvegarde);
2082: strcat(chaine, " ][");
2083: }
2084: }
2085:
2086: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2087: {
2088: chaine[strlen(chaine) - 3] = ']';
2089: chaine[strlen(chaine) - 2] = 0;
2090:
2091: chaine_sauvegarde = chaine;
2092: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2093: + 1) * sizeof(unsigned char));
2094:
2095: if (chaine == NULL)
2096: {
2097: (*s_etat_processus).erreur_systeme =
2098: d_es_allocation_memoire;
2099: return(NULL);
2100: }
2101:
2102: strcpy(chaine, chaine_sauvegarde);
2103: free(chaine_sauvegarde);
2104: }
2105: else
2106: {
2107: chaine[strlen(chaine) - 2] = ']';
2108: chaine[strlen(chaine) - 1] = 0;
2109:
2110: chaine_sauvegarde = chaine;
2111: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2112: + 2) * sizeof(unsigned char));
2113:
2114: if (chaine == NULL)
2115: {
2116: (*s_etat_processus).erreur_systeme =
2117: d_es_allocation_memoire;
2118: return(NULL);
2119: }
2120:
2121: strcpy(chaine, chaine_sauvegarde);
2122: free(chaine_sauvegarde);
2123: strcat(chaine, "]");
2124: }
2125: }
2126: }
2127: else if ((*s_objet).type == MIN)
2128: {
2129:
2130: /*
2131: --------------------------------------------------------------------------------
2132: Matrice entière
2133: --------------------------------------------------------------------------------
2134: */
2135:
2136: if ((format_sortie != 'S') && (format_sortie != 'F') &&
2137: (format_sortie != 'I') && (format_sortie != 'E'))
2138: {
2139: (*s_etat_processus).erreur_execution =
2140: d_ex_erreur_format_fichier;
2141: return(NULL);
2142: }
2143:
2144: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
2145: .nombre_lignes;
2146: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
2147: .nombre_colonnes;
2148:
2149: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2150:
2151: if (chaine != NULL)
2152: {
2153: strcpy(chaine, "[[");
2154:
2155: for(i = 0; i < nombre_lignes; i++)
2156: {
2157: for(j = 0; j < nombre_colonnes; j++)
2158: {
2159: if ((chaine_formatee =
2160: formateur_fichier_nombre(s_etat_processus,
2161: (void *) &(((integer8 **) ((*((struct_matrice *)
2162: ((*s_objet).objet))).tableau))[i][j]), 'I',
2163: longueur, longueur_champ, format_sortie))
2164: == NULL)
2165: {
2166: (*s_etat_processus).erreur_systeme =
2167: d_es_allocation_memoire;
2168: return(NULL);
2169: }
2170:
2171: chaine_sauvegarde = chaine;
2172: chaine = (unsigned char *) malloc(
2173: (strlen(chaine_sauvegarde) +
2174: strlen(chaine_formatee) + 2)
2175: * sizeof(unsigned char));
2176:
2177: if (chaine == NULL)
2178: {
2179: (*s_etat_processus).erreur_systeme =
2180: d_es_allocation_memoire;
2181: return(NULL);
2182: }
2183:
2184: strcpy(chaine, chaine_sauvegarde);
2185: free(chaine_sauvegarde);
2186: strcat(chaine, " ");
2187: strcat(chaine, chaine_formatee);
2188: free(chaine_formatee);
2189: }
2190:
2191: chaine_sauvegarde = chaine;
2192: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2193: {
2194: chaine = (unsigned char *) malloc(
2195: (strlen(chaine_sauvegarde) + 6)
2196: * sizeof(unsigned char));
2197:
2198: if (chaine == NULL)
2199: {
2200: (*s_etat_processus).erreur_systeme =
2201: d_es_allocation_memoire;
2202: return(NULL);
2203: }
2204:
2205: strcpy(chaine, chaine_sauvegarde);
2206: free(chaine_sauvegarde);
2207: strcat(chaine, " ]\n [");
2208: }
2209: else
2210: {
2211: chaine = (unsigned char *) malloc(
2212: (strlen(chaine_sauvegarde) + 4)
2213: * sizeof(unsigned char));
2214:
2215: if (chaine == NULL)
2216: {
2217: (*s_etat_processus).erreur_systeme =
2218: d_es_allocation_memoire;
2219: return(NULL);
2220: }
2221:
2222: strcpy(chaine, chaine_sauvegarde);
2223: free(chaine_sauvegarde);
2224: strcat(chaine, " ][");
2225: }
2226: }
2227:
2228: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2229: {
2230: chaine[strlen(chaine) - 3] = ']';
2231: chaine[strlen(chaine) - 2] = 0;
2232:
2233: chaine_sauvegarde = chaine;
2234: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2235: + 1) * sizeof(unsigned char));
2236:
2237: if (chaine == NULL)
2238: {
2239: (*s_etat_processus).erreur_systeme =
2240: d_es_allocation_memoire;
2241: return(NULL);
2242: }
2243:
2244: strcpy(chaine, chaine_sauvegarde);
2245: free(chaine_sauvegarde);
2246: }
2247: else
2248: {
2249: chaine[strlen(chaine) - 2] = ']';
2250: chaine[strlen(chaine) - 1] = 0;
2251:
2252: chaine_sauvegarde = chaine;
2253: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2254: + 2) * sizeof(unsigned char));
2255:
2256: if (chaine == NULL)
2257: {
2258: (*s_etat_processus).erreur_systeme =
2259: d_es_allocation_memoire;
2260: return(NULL);
2261: }
2262:
2263: strcpy(chaine, chaine_sauvegarde);
2264: free(chaine_sauvegarde);
2265: strcat(chaine, "]");
2266: }
2267: }
2268: }
2269: else if ((*s_objet).type == MRL)
2270: {
2271:
2272: /*
2273: --------------------------------------------------------------------------------
2274: Matrice réelle
2275: --------------------------------------------------------------------------------
2276: */
2277:
2278: if ((format_sortie != 'S') && (format_sortie != 'F') &&
2279: (format_sortie != 'I') && (format_sortie != 'E'))
2280: {
2281: (*s_etat_processus).erreur_execution =
2282: d_ex_erreur_format_fichier;
2283: return(NULL);
2284: }
2285:
2286: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
2287: .nombre_lignes;
2288: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
2289: .nombre_colonnes;
2290:
2291: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2292:
2293: if (chaine != NULL)
2294: {
2295: strcpy(chaine, "[[");
2296:
2297: for(i = 0; i < nombre_lignes; i++)
2298: {
2299: for(j = 0; j < nombre_colonnes; j++)
2300: {
2301: if ((chaine_formatee =
2302: formateur_fichier_nombre(s_etat_processus,
2303: (void *) &(((real8 **) ((*((struct_matrice *)
2304: ((*s_objet).objet))).tableau))[i][j]), 'R',
2305: longueur, longueur_champ, format_sortie))
2306: == NULL)
2307: {
2308: (*s_etat_processus).erreur_systeme =
2309: d_es_allocation_memoire;
2310: return(NULL);
2311: }
2312:
2313: chaine_sauvegarde = chaine;
2314: chaine = (unsigned char *) malloc(
2315: (strlen(chaine_sauvegarde) +
2316: strlen(chaine_formatee) + 2)
2317: * sizeof(unsigned char));
2318:
2319: if (chaine == NULL)
2320: {
2321: (*s_etat_processus).erreur_systeme =
2322: d_es_allocation_memoire;
2323: return(NULL);
2324: }
2325:
2326: strcpy(chaine, chaine_sauvegarde);
2327: free(chaine_sauvegarde);
2328: strcat(chaine, " ");
2329: strcat(chaine, chaine_formatee);
2330: free(chaine_formatee);
2331: }
2332:
2333: chaine_sauvegarde = chaine;
2334: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2335: {
2336: chaine = (unsigned char *) malloc(
2337: (strlen(chaine_sauvegarde) + 6)
2338: * sizeof(unsigned char));
2339:
2340: if (chaine == NULL)
2341: {
2342: (*s_etat_processus).erreur_systeme =
2343: d_es_allocation_memoire;
2344: return(NULL);
2345: }
2346:
2347: strcpy(chaine, chaine_sauvegarde);
2348: free(chaine_sauvegarde);
2349: strcat(chaine, " ]\n [");
2350: }
2351: else
2352: {
2353: chaine = (unsigned char *) malloc(
2354: (strlen(chaine_sauvegarde) + 4)
2355: * sizeof(unsigned char));
2356:
2357: if (chaine == NULL)
2358: {
2359: (*s_etat_processus).erreur_systeme =
2360: d_es_allocation_memoire;
2361: return(NULL);
2362: }
2363:
2364: strcpy(chaine, chaine_sauvegarde);
2365: free(chaine_sauvegarde);
2366: strcat(chaine, " ][");
2367: }
2368: }
2369:
2370: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2371: {
2372: chaine[strlen(chaine) - 3] = ']';
2373: chaine[strlen(chaine) - 2] = 0;
2374:
2375: chaine_sauvegarde = chaine;
2376: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2377: + 1) * sizeof(unsigned char));
2378:
2379: if (chaine == NULL)
2380: {
2381: (*s_etat_processus).erreur_systeme =
2382: d_es_allocation_memoire;
2383: return(NULL);
2384: }
2385:
2386: strcpy(chaine, chaine_sauvegarde);
2387: free(chaine_sauvegarde);
2388: }
2389: else
2390: {
2391: chaine[strlen(chaine) - 2] = ']';
2392: chaine[strlen(chaine) - 1] = 0;
2393:
2394: chaine_sauvegarde = chaine;
2395: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2396: + 2) * sizeof(unsigned char));
2397:
2398: if (chaine == NULL)
2399: {
2400: (*s_etat_processus).erreur_systeme =
2401: d_es_allocation_memoire;
2402: return(NULL);
2403: }
2404:
2405: strcpy(chaine, chaine_sauvegarde);
2406: free(chaine_sauvegarde);
2407: strcat(chaine, "]");
2408: }
2409: }
2410: }
2411: else if ((*s_objet).type == NOM)
2412: {
2413:
2414: /*
2415: --------------------------------------------------------------------------------
2416: Nom
2417: --------------------------------------------------------------------------------
2418: */
2419:
2420: chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
2421: (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
2422:
2423: if (chaine == NULL)
2424: {
2425: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2426: return(NULL);
2427: }
2428:
2429: sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom);
2430: }
2431: else if ((*s_objet).type == REL)
2432: {
2433:
2434: /*
2435: --------------------------------------------------------------------------------
2436: Réel
2437: --------------------------------------------------------------------------------
2438: */
2439:
2440: if ((format_sortie != 'S') && (format_sortie != 'F') &&
2441: (format_sortie != 'I') && (format_sortie != 'E'))
2442: {
2443: (*s_etat_processus).erreur_execution =
2444: d_ex_erreur_format_fichier;
2445: return(NULL);
2446: }
2447:
2448: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
2449: (void *) ((real8 *) ((*s_objet).objet)), 'R',
2450: longueur, longueur_champ, format_sortie)) == NULL)
2451: {
2452: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2453: return(NULL);
2454: }
2455:
2456: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1)
2457: * sizeof(unsigned char));
2458:
2459: if (chaine == NULL)
2460: {
2461: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2462: return(NULL);
2463: }
2464:
2465: strcpy(chaine, chaine_formatee);
2466: free(chaine_formatee);
2467: }
2468: else if ((*s_objet).type == VCX)
2469: {
2470:
2471: /*
2472: --------------------------------------------------------------------------------
2473: Vecteur complexe
2474: --------------------------------------------------------------------------------
2475: */
2476:
2477: if ((format_sortie != 'S') && (format_sortie != 'F') &&
2478: (format_sortie != 'I') && (format_sortie != 'E'))
2479: {
2480: (*s_etat_processus).erreur_execution =
2481: d_ex_erreur_format_fichier;
2482: return(NULL);
2483: }
2484:
2485: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
2486: .taille;
2487:
2488: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
2489:
2490: if (chaine != NULL)
2491: {
2492: strcpy(chaine, "[");
2493:
2494: for(i = 0; i < nombre_colonnes; i++)
2495: {
2496: if ((chaine_formatee =
2497: formateur_fichier_nombre(s_etat_processus,
2498: (void *) &(((struct_complexe16 *)
2499: ((*((struct_vecteur *)
2500: ((*s_objet).objet))).tableau))[i]), 'C',
2501: longueur, longueur_champ, format_sortie)) == NULL)
2502: {
2503: (*s_etat_processus).erreur_systeme =
2504: d_es_allocation_memoire;
2505: return(NULL);
2506: }
2507:
2508: chaine_sauvegarde = chaine;
2509: chaine = (unsigned char *) malloc(
2510: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
2511: + 2) * sizeof(unsigned char));
2512:
2513: if (chaine == NULL)
2514: {
2515: (*s_etat_processus).erreur_systeme =
2516: d_es_allocation_memoire;
2517: return(NULL);
2518: }
2519:
2520: strcpy(chaine, chaine_sauvegarde);
2521: free(chaine_sauvegarde);
2522: strcat(chaine, " ");
2523: strcat(chaine, chaine_formatee);
2524: free(chaine_formatee);
2525: }
2526:
2527: chaine_sauvegarde = chaine;
2528: chaine = (unsigned char *) malloc(
2529: (strlen(chaine_sauvegarde) + 3)
2530: * sizeof(unsigned char));
2531:
2532: if (chaine == NULL)
2533: {
2534: (*s_etat_processus).erreur_systeme =
2535: d_es_allocation_memoire;
2536: return(NULL);
2537: }
2538:
2539: strcpy(chaine, chaine_sauvegarde);
2540: free(chaine_sauvegarde);
2541: strcat(chaine, " ]");
2542: }
2543: }
2544: else if ((*s_objet).type == VIN)
2545: {
2546:
2547: /*
2548: --------------------------------------------------------------------------------
2549: Vecteur entier
2550: --------------------------------------------------------------------------------
2551: */
2552:
2553: if ((format_sortie != 'S') && (format_sortie != 'F') &&
2554: (format_sortie != 'I') && (format_sortie != 'E'))
2555: {
2556: (*s_etat_processus).erreur_execution =
2557: d_ex_erreur_format_fichier;
2558: return(NULL);
2559: }
2560:
2561: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
2562: .taille;
2563:
2564: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
2565:
2566: if (chaine != NULL)
2567: {
2568: strcpy(chaine, "[");
2569:
2570: for(i = 0; i < nombre_colonnes; i++)
2571: {
2572: if ((chaine_formatee =
2573: formateur_fichier_nombre(s_etat_processus,
2574: (void *) &(((integer8 *) ((*((struct_vecteur *)
2575: ((*s_objet).objet))).tableau))[i]), 'I',
2576: longueur, longueur_champ, format_sortie)) == NULL)
2577: {
2578: (*s_etat_processus).erreur_systeme =
2579: d_es_allocation_memoire;
2580: return(NULL);
2581: }
2582:
2583: chaine_sauvegarde = chaine;
2584: chaine = (unsigned char *) malloc(
2585: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
2586: + 2) * sizeof(unsigned char));
2587:
2588: if (chaine == NULL)
2589: {
2590: (*s_etat_processus).erreur_systeme =
2591: d_es_allocation_memoire;
2592: return(NULL);
2593: }
2594:
2595: strcpy(chaine, chaine_sauvegarde);
2596: free(chaine_sauvegarde);
2597: strcat(chaine, " ");
2598: strcat(chaine, chaine_formatee);
2599: free(chaine_formatee);
2600: }
2601:
2602: chaine_sauvegarde = chaine;
2603: chaine = (unsigned char *) malloc(
2604: (strlen(chaine_sauvegarde) + 3)
2605: * sizeof(unsigned char));
2606:
2607: if (chaine == NULL)
2608: {
2609: (*s_etat_processus).erreur_systeme =
2610: d_es_allocation_memoire;
2611: return(NULL);
2612: }
2613:
2614: strcpy(chaine, chaine_sauvegarde);
2615: free(chaine_sauvegarde);
2616: strcat(chaine, " ]");
2617: }
2618: }
2619: else if ((*s_objet).type == VRL)
2620: {
2621:
2622: /*
2623: --------------------------------------------------------------------------------
2624: Vecteur réel
2625: --------------------------------------------------------------------------------
2626: */
2627:
2628: if ((format_sortie != 'S') && (format_sortie != 'F') &&
2629: (format_sortie != 'I') && (format_sortie != 'E'))
2630: {
2631: (*s_etat_processus).erreur_execution =
2632: d_ex_erreur_format_fichier;
2633: return(NULL);
2634: }
2635:
2636: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
2637: .taille;
2638:
2639: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
2640:
2641: if (chaine != NULL)
2642: {
2643: strcpy(chaine, "[");
2644:
2645: for(i = 0; i < nombre_colonnes; i++)
2646: {
2647: if ((chaine_formatee =
2648: formateur_fichier_nombre(s_etat_processus,
2649: (void *) &(((real8 *) ((*((struct_vecteur *)
2650: ((*s_objet).objet))).tableau))[i]), 'R',
2651: longueur, longueur_champ, format_sortie)) == NULL)
2652: {
2653: (*s_etat_processus).erreur_systeme =
2654: d_es_allocation_memoire;
2655: return(NULL);
2656: }
2657:
2658: chaine_sauvegarde = chaine;
2659: chaine = (unsigned char *) malloc(
2660: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
2661: + 2) * sizeof(unsigned char));
2662:
2663: if (chaine == NULL)
2664: {
2665: (*s_etat_processus).erreur_systeme =
2666: d_es_allocation_memoire;
2667: return(NULL);
2668: }
2669:
2670: strcpy(chaine, chaine_sauvegarde);
2671: free(chaine_sauvegarde);
2672: strcat(chaine, " ");
2673: strcat(chaine, chaine_formatee);
2674: free(chaine_formatee);
2675: }
2676:
2677: chaine_sauvegarde = chaine;
2678: chaine = (unsigned char *) malloc(
2679: (strlen(chaine_sauvegarde) + 3)
2680: * sizeof(unsigned char));
2681:
2682: if (chaine == NULL)
2683: {
2684: (*s_etat_processus).erreur_systeme =
2685: d_es_allocation_memoire;
2686: return(NULL);
2687: }
2688:
2689: strcpy(chaine, chaine_sauvegarde);
2690: free(chaine_sauvegarde);
2691: strcat(chaine, " ]");
2692: }
2693: }
2694: else
2695: {
2696: // Type non exportable
2697:
2698: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
2699: free(chaine);
2700:
2701: return(NULL);
2702: }
2703:
2704: (*longueur_effective) = strlen(chaine) + 1;
2705: }
2706: else
2707: {
2708: /*
2709: * Fichiers non formatés
2710: */
2711:
2712: #define __zone() \
2713: do { int _i; \
2714: for(_i = 0; _i < longueur_totale; _i++) \
2715: printf("%02X ", chaine[_i]); printf("\b\n"); } while(0)
2716:
2717: /*
2718: * Chaque enregistrement est composé d'une donnée (une liste)
2719: * suivie de sa longueur en octets et d'un champ binaire indiquant
2720: * le format (integer*1,2,4 ou 8) d'écriture de cette longueur.
2721: * Les données contenues dans ces fichiers sont associées à un
2722: * descripteur de type.
2723: *
2724: * Attention : les fichiers non formatés ne sont pas portables
2725: * d'une architecture à l'autre.
2726: *
2727: * Structure d'un enregistrement :
2728: * [en-tête][.........données..........][longueur + type de longueur]
2729: *
2730: * Longueur : (pour l'instruction backspace)
2731: *
2732: * 00 XXXXXX longueur sur 6 bits
2733: * 01 000000 longueur sur 16 bits
2734: * 10 000000 longueur sur 32 bits
2735: * 11 000000 longueur sur 64 bits
2736: *
2737: * Exemples :
2738: * [00 XXXXXX]
2739: * [01 ----XX][XXXXXXXX][01 XXXXXX]
2740: * [10 ----XX][XXXXXXXX][XXXXXXXX][XXXXXXXX][10 XXXXXX]
2741: * [11 ----XX][XXXXXXXX][XXXXXXXX][XXXXXXXX][XXXXXXXX][XXXXXXXX]
2742: * [XXXXXXXX][XXXXXXXX][11 XXXXXX]
2743: *
2744: * Structures des enregistrements :
2745: * chaque type de donnée est associé à une en-tête binaire comprenant
2746: * le type de données ainsi que toutes autres informations utiles.
2747: *
2748: * Représentation binaire :
2749: *
2750: * 1/ scalaires
2751: * 0000 XXXX Binaire sur XXXX octets
2752: *
2753: * TYPE
2754: * 0001 00 00 integer*1
2755: * 0001 00 01 integer*2
2756: * 0001 00 10 integer*4
2757: * 0001 00 11 integer*8
2758: *
2759: * 0001 01 00 real*4
2760: * 0001 01 01 real*8
2761: *
2762: * 0001 10 00 complex*8
2763: * 0001 10 01 complex*16
2764: *
2765: * 0010 00 00 vecteur integer*1 (dimensions integer*1)
2766: * 0010 01 00 vecteur integer*1 (dimensions integer*2)
2767: * 0010 10 00 vecteur integer*1 (dimensions integer*4)
2768: * 0010 11 00 vecteur integer*1 (dimensions integer*8)
2769: * 0010 00 01 vecteur integer*2 (dimensions integer*1)
2770: * 0010 01 01 vecteur integer*2 (dimensions integer*2)
2771: * 0010 10 01 vecteur integer*2 (dimensions integer*4)
2772: * 0010 11 01 vecteur integer*2 (dimensions integer*8)
2773: * 0010 00 10 vecteur integer*4 (dimensions integer*1)
2774: * 0010 01 10 vecteur integer*4 (dimensions integer*2)
2775: * 0010 10 10 vecteur integer*4 (dimensions integer*4)
2776: * 0010 11 10 vecteur integer*4 (dimensions integer*8)
2777: * 0010 00 11 vecteur integer*8 (dimensions integer*1)
2778: * 0010 01 11 vecteur integer*8 (dimensions integer*2)
2779: * 0010 10 11 vecteur integer*8 (dimensions integer*4)
2780: * 0010 11 11 vecteur integer*8 (dimensions integer*8)
2781: *
2782: * 0011 00 00 matrice integer*1 (dimensions integer*1)
2783: * 0011 01 00 matrice integer*1 (dimensions integer*2)
2784: * 0011 10 00 matrice integer*1 (dimensions integer*4)
2785: * 0011 11 00 matrice integer*1 (dimensions integer*8)
2786: * 0011 00 01 matrice integer*2 (dimensions integer*1)
2787: * 0011 01 01 matrice integer*2 (dimensions integer*2)
2788: * 0011 10 01 matrice integer*2 (dimensions integer*4)
2789: * 0011 11 01 matrice integer*2 (dimensions integer*8)
2790: * 0011 00 10 matrice integer*4 (dimensions integer*1)
2791: * 0011 01 10 matrice integer*4 (dimensions integer*2)
2792: * 0011 10 10 matrice integer*4 (dimensions integer*4)
2793: * 0011 11 10 matrice integer*4 (dimensions integer*8)
2794: * 0011 00 11 matrice integer*8 (dimensions integer*1)
2795: * 0011 01 11 matrice integer*8 (dimensions integer*2)
2796: * 0011 10 11 matrice integer*8 (dimensions integer*4)
2797: * 0011 11 11 matrice integer*8 (dimensions integer*8)
2798: *
2799: * 0100 0 XXX liste de longueur XXX
2800: * 0100 10 00 liste de longueur integer*1
2801: * 0100 10 01 liste de longueur integer*2
2802: * 0100 10 10 liste de longueur integer*4
2803: * 0100 10 11 liste de longueur integer*8
2804: *
2805: * 0101 0 XXX nom de longueur XXX
2806: * 0101 10 LL nom de longueur integer*LL
2807: *
2808: * 0110 0 XXX expression RPN
2809: * 0110 10 LL
2810: *
2811: * 0111 0 XXX expression algébrique
2812: * 0111 10 LL
2813: *
2814: * 1000 0 XXX chaîne de caractères
2815: * 1000 10 LL
2816: *
2817: * 1001 0 XXX table de longueur XXX
2818: * 1001 10 00 table de longueur integer*1
2819: * 1001 10 01 table de longueur integer*2
2820: * 1001 10 10 table de longueur integer*4
2821: * 1001 10 11 table de longueur integer*8
2822: *
2823: * 1010 00 10 vecteur real*4 (dimensions integer*1)
2824: * 1010 01 10 vecteur real*4 (dimensions integer*2)
2825: * 1010 10 10 vecteur real*4 (dimensions integer*4)
2826: * 1010 11 10 vecteur real*4 (dimensions integer*8)
2827: * 1010 00 11 vecteur real*8 (dimensions integer*1)
2828: * 1010 01 11 vecteur real*8 (dimensions integer*2)
2829: * 1010 10 11 vecteur real*8 (dimensions integer*4)
2830: * 1010 11 11 vecteur real*8 (dimensions integer*8)
2831: * 1011 00 10 vecteur complex*8 (dimensions integer*1)
2832: * 1011 01 10 vecteur complex*8 (dimensions integer*2)
2833: * 1011 10 10 vecteur complex*8 (dimensions integer*4)
2834: * 1011 11 10 vecteur complex*8 (dimensions integer*8)
2835: * 1011 00 11 vecteur complex*16 (dimensions integer*1)
2836: * 1011 01 11 vecteur complex*16 (dimensions integer*2)
2837: * 1011 10 11 vecteur complex*16 (dimensions integer*4)
2838: * 1011 11 11 vecteur complex*16 (dimensions integer*8)
2839: *
2840: * 1100 00 10 matrice real*4 (dimensions integer*1)
2841: * 1100 01 10 matrice real*4 (dimensions integer*2)
2842: * 1100 10 10 matrice real*4 (dimensions integer*4)
2843: * 1100 11 10 matrice real*4 (dimensions integer*8)
2844: * 1100 00 11 matrice real*8 (dimensions integer*1)
2845: * 1100 01 11 matrice real*8 (dimensions integer*2)
2846: * 1100 10 11 matrice real*8 (dimensions integer*4)
2847: * 1100 11 11 matrice real*8 (dimensions integer*8)
2848: * 1101 00 10 matrice complex*8 (dimensions integer*1)
2849: * 1101 01 10 matrice complex*8 (dimensions integer*2)
2850: * 1101 10 10 matrice complex*8 (dimensions integer*4)
2851: * 1101 11 10 matrice complex*8 (dimensions integer*8)
2852: * 1101 00 11 matrice complex*16 (dimensions integer*1)
2853: * 1101 01 11 matrice complex*16 (dimensions integer*2)
2854: * 1101 10 11 matrice complex*16 (dimensions integer*4)
2855: * 1101 11 11 matrice complex*16 (dimensions integer*8)
2856: *
2857: * Les longueurs indiquées par le champ LL suivent l'en-tête :
2858: * 00 : integer*1
2859: * 01 : integer*2
2860: * 10 : integer*4
2861: * 11 : integer*8
2862: *
2863: * [En-tête][longueur_1][longueur_2][données]
2864: * le nombre de champs longueur dépendant des types d'enregistrement.
2865: *
2866: * Toutes les autres combinaisons sont invalides.
2867: */
2868:
2869: chaine = NULL;
2870: chaine_formatee = NULL;
2871: chaine_sauvegarde = NULL;
2872:
2873: strcpy(base, " ");
2874:
2875: masque_binaire = 0;
2876:
2877: if ((*s_objet).type == ALG)
2878: {
2879:
2880: /*
2881: --------------------------------------------------------------------------------
2882: Expression algébrique
2883: --------------------------------------------------------------------------------
2884: */
2885:
2886: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
2887:
2888: while(l_element_courant != NULL)
2889: {
2890: if ((*(*l_element_courant).donnee).type == FCT)
2891: {
2892: if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
2893: .donnee).objet)).nom_fonction, "<<") != 0) &&
2894: (strcmp((*((struct_fonction *)
2895: (*(*l_element_courant)
2896: .donnee).objet)).nom_fonction, ">>") != 0))
2897: {
2898: if ((strcmp((*((struct_fonction *)
2899: (*(*l_element_courant)
2900: .donnee).objet)).nom_fonction, "+") == 0) ||
2901: (strcmp((*((struct_fonction *)
2902: (*(*l_element_courant).donnee).objet))
2903: .nom_fonction, "-") == 0) || (strcmp(
2904: (*((struct_fonction *) (*(*l_element_courant)
2905: .donnee).objet)).nom_fonction, "*") == 0) ||
2906: (strcmp((*((struct_fonction *)
2907: (*(*l_element_courant).donnee).objet))
2908: .nom_fonction,
2909: "/") == 0) || (strcmp((*((struct_fonction *)
2910: (*(*l_element_courant).donnee).objet))
2911: .nom_fonction,
2912: "^") == 0) || (strcmp((*((struct_fonction *)
2913: (*(*l_element_courant).donnee).objet))
2914: .nom_fonction,
2915: "<") == 0) || (strcmp((*((struct_fonction *)
2916: (*(*l_element_courant).donnee).objet))
2917: .nom_fonction,
2918: ">") == 0) || (strcmp((*((struct_fonction *)
2919: (*(*l_element_courant).donnee).objet))
2920: .nom_fonction,
2921: "==") == 0) || (strcmp((*((struct_fonction *)
2922: (*(*l_element_courant).donnee).objet))
2923: .nom_fonction,
2924: "<>") == 0) || (strcmp((*((struct_fonction *)
2925: (*(*l_element_courant).donnee).objet))
2926: .nom_fonction,
2927: "<=") == 0) || (strcmp((*((struct_fonction *)
2928: (*(*l_element_courant).donnee).objet))
2929: .nom_fonction,
2930: "=<") == 0) || (strcmp((*((struct_fonction *)
2931: (*(*l_element_courant).donnee).objet))
2932: .nom_fonction,
2933: ">=") == 0) || (strcmp((*((struct_fonction *)
2934: (*(*l_element_courant).donnee).objet))
2935: .nom_fonction,
2936: "=>") == 0))
2937: {
2938: if (depilement(s_etat_processus,
2939: &((*s_etat_processus)
2940: .l_base_pile), &s_sous_objet_2) == d_erreur)
2941: {
2942: return(NULL);
2943: }
2944:
2945: chaine_sauvegarde = (*s_etat_processus)
2946: .instruction_courante;
2947:
2948: if (((*s_etat_processus).instruction_courante =
2949: (unsigned char *) malloc((strlen(
2950: (unsigned char *) (*s_sous_objet_2).objet)
2951: + 2 + 1) * sizeof(unsigned char))) == NULL)
2952: {
2953: (*s_etat_processus).instruction_courante =
2954: chaine_sauvegarde;
2955: (*s_etat_processus).erreur_systeme =
2956: d_es_allocation_memoire;
2957: return(NULL);
2958: }
2959:
2960: sprintf((*s_etat_processus).instruction_courante,
2961: "'%s'", (unsigned char *)
2962: (*s_sous_objet_2).objet);
2963:
2964: presence_signe = (((*s_etat_processus)
2965: .instruction_courante[1] == '+')
2966: || ((*s_etat_processus)
2967: .instruction_courante[1]
2968: == '-')) ? d_vrai : d_faux;
2969:
2970: recherche_type(s_etat_processus);
2971:
2972: if ((*s_etat_processus).erreur_execution != d_ex)
2973: {
2974: // Aucune erreur ne peut être renvoyée.
2975:
2976: return(NULL);
2977: }
2978:
2979: if (depilement(s_etat_processus,
2980: &((*s_etat_processus)
2981: .l_base_pile), &s_sous_objet_3) == d_erreur)
2982: {
2983: return(NULL);
2984: }
2985:
2986: free((*s_etat_processus).instruction_courante);
2987:
2988: (*s_etat_processus).instruction_courante =
2989: chaine_sauvegarde;
2990:
2991: autorisation_parenthese = d_faux;
2992:
2993: if ((*s_sous_objet_3).type == ALG)
2994: {
2995: l_atome = (struct_liste_chainee *)
2996: (*s_sous_objet_3).objet;
2997: chaine_fonction = "";
2998: nombre_arguments_fonction = 0;
2999:
3000: while(l_atome != NULL)
3001: {
3002: if ((*(*l_atome).donnee).type == FCT)
3003: {
3004: if (strcmp((*((struct_fonction *)
3005: (*(*l_atome).donnee).objet))
3006: .nom_fonction, ">>") != 0)
3007: {
3008: chaine_fonction =
3009: (*((struct_fonction *)
3010: (*(*l_atome).donnee).objet))
3011: .nom_fonction;
3012: nombre_arguments_fonction =
3013: (*((struct_fonction *)
3014: (*(*l_atome).donnee).objet))
3015: .nombre_arguments;
3016: }
3017: }
3018:
3019: l_atome = (*l_atome).suivant;
3020: }
3021:
3022: if (strcmp((*((struct_fonction *)
3023: (*(*l_element_courant).donnee).objet))
3024: .nom_fonction, "+") == 0)
3025: {
3026: if ((strcmp(chaine_fonction, "AND") == 0) ||
3027: (strcmp(chaine_fonction, "XOR") ==
3028: 0) || (strcmp(chaine_fonction, "OR")
3029: == 0))
3030: {
3031: autorisation_parenthese = d_vrai;
3032: }
3033: }
3034: else if (strcmp((*((struct_fonction *)
3035: (*(*l_element_courant).donnee).objet))
3036: .nom_fonction, "-") == 0)
3037: {
3038: if (nombre_arguments_fonction != 0)
3039: {
3040: autorisation_parenthese = d_faux;
3041: }
3042: else
3043: {
3044: autorisation_parenthese = d_vrai;
3045: }
3046: }
3047: else if (strcmp((*((struct_fonction *)
3048: (*(*l_element_courant).donnee).objet))
3049: .nom_fonction, "*") == 0)
3050: {
3051: if ((strcmp(chaine_fonction, "+") == 0) ||
3052: (strcmp(chaine_fonction, "-") == 0)
3053: || (strcmp(chaine_fonction, "AND")
3054: == 0) || (strcmp(chaine_fonction,
3055: "XOR") == 0) || (strcmp(
3056: chaine_fonction, "OR") == 0))
3057: {
3058: autorisation_parenthese = d_vrai;
3059: }
3060: }
3061: else if (strcmp((*((struct_fonction *)
3062: (*(*l_element_courant).donnee).objet))
3063: .nom_fonction, "/") == 0)
3064: {
3065: if (nombre_arguments_fonction != 0)
3066: {
3067: autorisation_parenthese = d_faux;
3068: }
3069: else
3070: {
3071: autorisation_parenthese = d_vrai;
3072: }
3073: }
3074: else if ((strcmp((*((struct_fonction *)
3075: (*(*l_element_courant).donnee).objet))
3076: .nom_fonction, "^") == 0))
3077: {
3078: if (nombre_arguments_fonction != 0)
3079: {
3080: autorisation_parenthese = d_faux;
3081: }
3082: else
3083: {
3084: autorisation_parenthese = d_vrai;
3085: }
3086: }
3087: }
3088:
3089: if ((autorisation_parenthese == d_vrai) ||
3090: (presence_signe == d_vrai))
3091: {
3092: chaine_sauvegarde = (unsigned char *)
3093: (*s_sous_objet_2).objet;
3094:
3095: if (((*s_sous_objet_2).objet = (void *)
3096: malloc((strlen(chaine_sauvegarde) + 2
3097: + 1) * sizeof(unsigned char))) == NULL)
3098: {
3099: (*s_etat_processus).erreur_systeme =
3100: d_es_allocation_memoire;
3101: return(NULL);
3102: }
3103:
3104: sprintf((unsigned char *) (*s_sous_objet_2)
3105: .objet, "(%s)", chaine_sauvegarde);
3106: free(chaine_sauvegarde);
3107: }
3108:
3109: liberation(s_etat_processus, s_sous_objet_3);
3110:
3111: if (depilement(s_etat_processus,
3112: &((*s_etat_processus)
3113: .l_base_pile), &s_sous_objet_1) == d_erreur)
3114: {
3115: return(NULL);
3116: }
3117:
3118: chaine_sauvegarde = (*s_etat_processus)
3119: .instruction_courante;
3120:
3121: if (((*s_etat_processus).instruction_courante =
3122: (unsigned char *) malloc((strlen(
3123: (unsigned char *) (*s_sous_objet_1).objet)
3124: + 2 + 1) * sizeof(unsigned char))) == NULL)
3125: {
3126: (*s_etat_processus).instruction_courante =
3127: chaine_sauvegarde;
3128: (*s_etat_processus).erreur_systeme =
3129: d_es_allocation_memoire;
3130: return(NULL);
3131: }
3132:
3133: sprintf((*s_etat_processus).instruction_courante,
3134: "'%s'", (unsigned char *)
3135: (*s_sous_objet_1).objet);
3136:
3137: recherche_type(s_etat_processus);
3138:
3139: if ((*s_etat_processus).erreur_execution != d_ex)
3140: {
3141: // Aucune erreur ne peut être renvoyée.
3142:
3143: return(NULL);
3144: }
3145:
3146: if (depilement(s_etat_processus,
3147: &((*s_etat_processus)
3148: .l_base_pile), &s_sous_objet_3) == d_erreur)
3149: {
3150: return(NULL);
3151: }
3152:
3153: free((*s_etat_processus).instruction_courante);
3154:
3155: (*s_etat_processus).instruction_courante =
3156: chaine_sauvegarde;
3157:
3158: autorisation_parenthese = d_faux;
3159:
3160: if ((*s_sous_objet_3).type == ALG)
3161: {
3162: l_atome = (struct_liste_chainee *)
3163: (*s_sous_objet_3).objet;
3164: chaine_fonction = "";
3165:
3166: while(l_atome != NULL)
3167: {
3168: if ((*(*l_atome).donnee).type == FCT)
3169: {
3170: if (strcmp((*((struct_fonction *)
3171: (*(*l_atome).donnee).objet))
3172: .nom_fonction, ">>") != 0)
3173: {
3174: chaine_fonction =
3175: (*((struct_fonction *)
3176: (*(*l_atome).donnee).objet))
3177: .nom_fonction;
3178: }
3179: }
3180:
3181: l_atome = (*l_atome).suivant;
3182: }
3183:
3184: if ((strcmp((*((struct_fonction *)
3185: (*(*l_element_courant).donnee).objet))
3186: .nom_fonction, "+") == 0) ||
3187: (strcmp((*((struct_fonction *)
3188: (*(*l_element_courant).donnee).objet))
3189: .nom_fonction, "-") == 0))
3190: {
3191: if ((strcmp(chaine_fonction, "AND") == 0) ||
3192: (strcmp(chaine_fonction, "XOR") ==
3193: 0) || (strcmp(chaine_fonction, "OR")
3194: == 0))
3195: {
3196: autorisation_parenthese = d_vrai;
3197: }
3198: }
3199: else if ((strcmp((*((struct_fonction *)
3200: (*(*l_element_courant).donnee).objet))
3201: .nom_fonction, "*") == 0) ||
3202: (strcmp((*((struct_fonction *)
3203: (*(*l_element_courant).donnee).objet))
3204: .nom_fonction, "/") == 0))
3205: {
3206: if ((strcmp(chaine_fonction, "+") == 0) ||
3207: (strcmp(chaine_fonction, "-") == 0)
3208: || (strcmp(chaine_fonction, "AND")
3209: == 0) || (strcmp(chaine_fonction,
3210: "XOR") == 0) || (strcmp(
3211: chaine_fonction, "OR") == 0))
3212: {
3213: autorisation_parenthese = d_vrai;
3214: }
3215: }
3216: else if ((strcmp((*((struct_fonction *)
3217: (*(*l_element_courant).donnee).objet))
3218: .nom_fonction, "^") == 0))
3219: {
3220: autorisation_parenthese = d_vrai;
3221: }
3222: }
3223:
3224: if (autorisation_parenthese == d_vrai)
3225: {
3226: chaine_sauvegarde = (unsigned char *)
3227: (*s_sous_objet_1).objet;
3228:
3229: if (((*s_sous_objet_1).objet = (void *)
3230: malloc((strlen(chaine_sauvegarde) + 2
3231: + 1) * sizeof(unsigned char))) == NULL)
3232: {
3233: (*s_etat_processus).erreur_systeme =
3234: d_es_allocation_memoire;
3235: return(NULL);
3236: }
3237:
3238: sprintf((unsigned char *) (*s_sous_objet_1)
3239: .objet, "(%s)", chaine_sauvegarde);
3240: free(chaine_sauvegarde);
3241: }
3242:
3243: liberation(s_etat_processus, s_sous_objet_3);
3244:
3245: if ((s_sous_objet = allocation(s_etat_processus,
3246: CHN)) == NULL)
3247: {
3248: (*s_etat_processus).erreur_systeme =
3249: d_es_allocation_memoire;
3250: return(NULL);
3251: }
3252:
3253: if (((*s_sous_objet).objet = (void *)
3254: malloc((strlen(
3255: (unsigned char *) (*s_sous_objet_1).objet) +
3256: strlen((*((struct_fonction *)
3257: (*(*l_element_courant).donnee).objet))
3258: .nom_fonction) + strlen((unsigned char *)
3259: (*s_sous_objet_2).objet) + 1) *
3260: sizeof(unsigned char))) == NULL)
3261: {
3262: (*s_etat_processus).erreur_systeme =
3263: d_es_allocation_memoire;
3264: return(NULL);
3265: }
3266:
3267: sprintf((unsigned char *) (*s_sous_objet).objet,
3268: "%s%s%s", (unsigned char *)
3269: (*s_sous_objet_1)
3270: .objet, (*((struct_fonction *)
3271: (*(*l_element_courant).donnee).objet))
3272: .nom_fonction, (unsigned char *)
3273: (*s_sous_objet_2).objet);
3274:
3275: liberation(s_etat_processus, s_sous_objet_1);
3276: liberation(s_etat_processus, s_sous_objet_2);
3277:
3278: if (empilement(s_etat_processus,
3279: &((*s_etat_processus)
3280: .l_base_pile), s_sous_objet) == d_erreur)
3281: {
3282: return(NULL);
3283: }
3284: }
3285: else if (strcmp((*((struct_fonction *)
3286: (*(*l_element_courant).donnee).objet))
3287: .nom_fonction, "=") == 0)
3288: {
3289: if (depilement(s_etat_processus,
3290: &((*s_etat_processus).l_base_pile),
3291: &s_sous_objet_2) == d_erreur)
3292: {
3293: return(NULL);
3294: }
3295:
3296: if (depilement(s_etat_processus,
3297: &((*s_etat_processus).l_base_pile),
3298: &s_sous_objet_1) == d_erreur)
3299: {
3300: return(NULL);
3301: }
3302:
3303: if ((s_sous_objet = allocation(s_etat_processus,
3304: CHN)) == NULL)
3305: {
3306: (*s_etat_processus).erreur_systeme =
3307: d_es_allocation_memoire;
3308: return(NULL);
3309: }
3310:
3311: autorisation_parenthese = d_vrai;
3312: l_atome = l_element_courant;
3313:
3314: if (l_atome != NULL)
3315: {
3316: if ((*l_atome).suivant != NULL)
3317: {
3318: l_atome = (*l_atome).suivant;
3319:
3320: if ((*(*l_atome).donnee).type == FCT)
3321: {
3322: if (strcmp((*((struct_fonction *)
3323: (*(*l_atome).donnee).objet))
3324: .nom_fonction, ">>") == 0)
3325: {
3326: if ((*l_atome).suivant == NULL)
3327: {
3328: autorisation_parenthese =
3329: d_faux;
3330: }
3331: }
3332: }
3333: }
3334: }
3335:
3336: if (autorisation_parenthese == d_vrai)
3337: {
3338: if (((*s_sous_objet).objet =
3339: (void *) malloc((strlen(
3340: (unsigned char *) (*s_sous_objet_1)
3341: .objet) + strlen((*((struct_fonction *)
3342: (*(*l_element_courant).donnee).objet))
3343: .nom_fonction) +
3344: strlen((unsigned char *)
3345: (*s_sous_objet_2).objet) + 2 + 1) *
3346: sizeof(unsigned char))) == NULL)
3347: {
3348: (*s_etat_processus).erreur_systeme =
3349: d_es_allocation_memoire;
3350: return(NULL);
3351: }
3352:
3353: sprintf((unsigned char *) (*s_sous_objet).objet,
3354: "(%s%s%s)", (unsigned char *)
3355: (*s_sous_objet_1)
3356: .objet, (*((struct_fonction *)
3357: (*(*l_element_courant).donnee).objet))
3358: .nom_fonction, (unsigned char *)
3359: (*s_sous_objet_2).objet);
3360: }
3361: else
3362: {
3363: if (((*s_sous_objet).objet =
3364: (void *) malloc((strlen(
3365: (unsigned char *) (*s_sous_objet_1)
3366: .objet) + strlen((*((struct_fonction *)
3367: (*(*l_element_courant).donnee).objet))
3368: .nom_fonction) + strlen(
3369: (unsigned char *) (*s_sous_objet_2)
3370: .objet) + 1) * sizeof(unsigned char)))
3371: == NULL)
3372: {
3373: (*s_etat_processus).erreur_systeme =
3374: d_es_allocation_memoire;
3375: return(NULL);
3376: }
3377:
3378: sprintf((unsigned char *) (*s_sous_objet).objet,
3379: "%s%s%s", (unsigned char *)
3380: (*s_sous_objet_1)
3381: .objet, (*((struct_fonction *)
3382: (*(*l_element_courant).donnee).objet))
3383: .nom_fonction, (unsigned char *)
3384: (*s_sous_objet_2).objet);
3385: }
3386:
3387: liberation(s_etat_processus, s_sous_objet_1);
3388: liberation(s_etat_processus, s_sous_objet_2);
3389:
3390: if (empilement(s_etat_processus,
3391: &((*s_etat_processus).l_base_pile),
3392: s_sous_objet) == d_erreur)
3393: {
3394: return(NULL);
3395: }
3396: }
3397: else if (strcmp((*((struct_fonction *)
3398: (*(*l_element_courant).donnee).objet))
3399: .nom_fonction,
3400: "NOT") == 0)
3401: {
3402: if (depilement(s_etat_processus,
3403: &((*s_etat_processus)
3404: .l_base_pile), &s_sous_objet_1) == d_erreur)
3405: {
3406: return(NULL);
3407: }
3408:
3409: if ((s_sous_objet = allocation(s_etat_processus,
3410: CHN)) == NULL)
3411: {
3412: (*s_etat_processus).erreur_systeme =
3413: d_es_allocation_memoire;
3414: return(NULL);
3415: }
3416:
3417: if (((*s_sous_objet).objet = (unsigned char *)
3418: malloc(
3419: (strlen((unsigned char *) (*s_sous_objet_1)
3420: .objet) + 4 + 1) * sizeof(unsigned char)))
3421: == NULL)
3422: {
3423: (*s_etat_processus).erreur_systeme =
3424: d_es_allocation_memoire;
3425: return(NULL);
3426: }
3427:
3428: sprintf((unsigned char *) (*s_sous_objet).objet,
3429: "%s %s", (*((struct_fonction *)
3430: (*(*l_element_courant).donnee).objet))
3431: .nom_fonction, (unsigned char *)
3432: (*s_sous_objet_1).objet );
3433:
3434: liberation(s_etat_processus, s_sous_objet_1);
3435:
3436: if (empilement(s_etat_processus,
3437: &((*s_etat_processus)
3438: .l_base_pile), s_sous_objet) == d_erreur)
3439: {
3440: return(NULL);
3441: }
3442: }
3443: else if ((strcmp((*((struct_fonction *)
3444: (*(*l_element_courant).donnee).objet))
3445: .nom_fonction,
3446: "OR") == 0) || (strcmp((*((struct_fonction *)
3447: (*(*l_element_courant).donnee).objet))
3448: .nom_fonction,
3449: "XOR") == 0) || (strcmp((*((struct_fonction *)
3450: (*(*l_element_courant).donnee).objet))
3451: .nom_fonction,
3452: "AND") == 0))
3453: {
3454: if (depilement(s_etat_processus,
3455: &((*s_etat_processus)
3456: .l_base_pile), &s_sous_objet_2) == d_erreur)
3457: {
3458: return(NULL);
3459: }
3460:
3461: if (depilement(s_etat_processus,
3462: &((*s_etat_processus)
3463: .l_base_pile), &s_sous_objet_1) == d_erreur)
3464: {
3465: return(NULL);
3466: }
3467:
3468: if ((s_sous_objet = allocation(s_etat_processus,
3469: CHN)) == NULL)
3470: {
3471: (*s_etat_processus).erreur_systeme =
3472: d_es_allocation_memoire;
3473: return(NULL);
3474: }
3475:
3476: if (((*s_sous_objet).objet = (void *)
3477: malloc((strlen(
3478: (unsigned char *) (*s_sous_objet_1).objet) +
3479: strlen((*((struct_fonction *)
3480: (*(*l_element_courant).donnee).objet))
3481: .nom_fonction) + strlen((unsigned char *)
3482: (*s_sous_objet_2).objet) + 2 + 1) *
3483: sizeof(unsigned char))) == NULL)
3484: {
3485: (*s_etat_processus).erreur_systeme =
3486: d_es_allocation_memoire;
3487: return(NULL);
3488: }
3489:
3490: sprintf((unsigned char *) (*s_sous_objet).objet,
3491: "%s %s %s", (unsigned char *)
3492: (*s_sous_objet_1)
3493: .objet, (*((struct_fonction *)
3494: (*(*l_element_courant).donnee).objet))
3495: .nom_fonction, (unsigned char *)
3496: (*s_sous_objet_2).objet);
3497:
3498: liberation(s_etat_processus, s_sous_objet_1);
3499: liberation(s_etat_processus, s_sous_objet_2);
3500:
3501: if (empilement(s_etat_processus,
3502: &((*s_etat_processus)
3503: .l_base_pile), s_sous_objet) == d_erreur)
3504: {
3505: return(NULL);
3506: }
3507: }
3508: else
3509: {
3510: nombre_arguments = (*((struct_fonction *)
3511: (*(*l_element_courant).donnee).objet))
3512: .nombre_arguments;
3513:
3514: if ((chaine = (unsigned char *)
3515: malloc(sizeof(unsigned char))) == NULL)
3516: {
3517: (*s_etat_processus).erreur_systeme =
3518: d_es_allocation_memoire;
3519: return(NULL);
3520: }
3521:
3522: chaine[0] = d_code_fin_chaine;
3523:
3524: for(i = 0; i < nombre_arguments; i++)
3525: {
3526: if ((nombre_arguments - i) > 1)
3527: {
3528: l_liste1 = (*s_etat_processus).l_base_pile;
3529:
3530: for(j = 2; j < (nombre_arguments - i); j++)
3531: {
3532: l_liste1 = (*l_liste1).suivant;
3533: }
3534:
3535: l_liste2 = (*l_liste1).suivant;
3536: (*l_liste1).suivant = (*l_liste2).suivant;
3537: (*l_liste2).suivant = (*s_etat_processus)
3538: .l_base_pile;
3539: (*s_etat_processus).l_base_pile = l_liste2;
3540: }
3541:
3542: if (depilement(s_etat_processus,
3543: &((*s_etat_processus).l_base_pile),
3544: &s_sous_objet) == d_erreur)
3545: {
3546: return(NULL);
3547: }
3548:
3549: chaine_sauvegarde = chaine;
3550:
3551: if (strlen(chaine_sauvegarde) == 0)
3552: {
3553: if ((chaine = (unsigned char *)
3554: malloc((strlen((unsigned char *)
3555: (*s_sous_objet).objet) + 1) *
3556: sizeof(unsigned char))) == NULL)
3557: {
3558: (*s_etat_processus).erreur_systeme =
3559: d_es_allocation_memoire;
3560: return(NULL);
3561: }
3562:
3563: sprintf(chaine, "%s", (unsigned char *)
3564: (*s_sous_objet).objet);
3565: }
3566: else
3567: {
3568: if ((chaine = (unsigned char *)
3569: malloc((strlen(chaine_sauvegarde)
3570: + 1 + strlen((unsigned char *)
3571: (*s_sous_objet).objet) + 1) *
3572: sizeof(unsigned char))) == NULL)
3573: {
3574: (*s_etat_processus).erreur_systeme =
3575: d_es_allocation_memoire;
3576: return(NULL);
3577: }
3578:
3579: sprintf(chaine, "%s,%s", chaine_sauvegarde,
3580: (unsigned char *) (*s_sous_objet)
3581: .objet);
3582: }
3583:
3584: free(chaine_sauvegarde);
3585: liberation(s_etat_processus, s_sous_objet);
3586: }
3587:
3588: chaine_sauvegarde = chaine;
3589:
3590: if ((chaine = (unsigned char *) malloc((strlen(
3591: (*((struct_fonction *)
3592: (*(*l_element_courant)
3593: .donnee).objet)).nom_fonction) + 2 +
3594: strlen(chaine_sauvegarde) + 1) *
3595: sizeof(unsigned char))) == NULL)
3596: {
3597: (*s_etat_processus).erreur_systeme =
3598: d_es_allocation_memoire;
3599: return(NULL);
3600: }
3601:
3602: sprintf(chaine, "%s(%s)", (*((struct_fonction *)
3603: (*(*l_element_courant).donnee).objet))
3604: .nom_fonction, chaine_sauvegarde);
3605: free(chaine_sauvegarde);
3606:
3607: if ((s_sous_objet = allocation(s_etat_processus,
3608: CHN)) == NULL)
3609: {
3610: (*s_etat_processus).erreur_systeme =
3611: d_es_allocation_memoire;
3612: return(NULL);
3613: }
3614:
3615: (*s_sous_objet).objet = (void *) chaine;
3616:
3617: if (empilement(s_etat_processus,
3618: &((*s_etat_processus)
3619: .l_base_pile), s_sous_objet) == d_erreur)
3620: {
3621: return(NULL);
3622: }
3623: }
3624: }
3625: }
3626: else
3627: {
3628: if ((s_sous_objet = allocation(s_etat_processus, CHN))
3629: == NULL)
3630: {
3631: (*s_etat_processus).erreur_systeme =
3632: d_es_allocation_memoire;
3633: return(NULL);
3634: }
3635:
3636: if (((*s_sous_objet).objet = (void *) formateur_fichier(
3637: s_etat_processus, (*l_element_courant).donnee,
3638: s_format, longueur, longueur_champ, format_sortie,
3639: type, longueur_effective, recursivite)) == NULL)
3640: {
3641: (*s_etat_processus).erreur_systeme =
3642: d_es_allocation_memoire;
3643: return(NULL);
3644: }
3645:
3646: if (((*(*l_element_courant).donnee).type == ALG)
3647: || ((*(*l_element_courant).donnee).type == NOM))
3648: {
3649: chaine_sauvegarde = (unsigned char *)
3650: (*s_sous_objet).objet;
3651:
3652: if (((*s_sous_objet).objet = malloc((strlen(
3653: chaine_sauvegarde) - 1) *
3654: sizeof(unsigned char))) == NULL)
3655: {
3656: (*s_etat_processus).erreur_systeme =
3657: d_es_allocation_memoire;
3658: return(NULL);
3659: }
3660:
3661: ptrl = chaine_sauvegarde;
3662: ptre = (unsigned char *) (*s_sous_objet).objet;
3663:
3664: for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;
3665: i--, *ptre++ = *ptrl++);
3666:
3667: (*ptre) = d_code_fin_chaine;
3668:
3669: free(chaine_sauvegarde);
3670: }
3671: else if ((*(*l_element_courant).donnee).type == CHN)
3672: {
3673: chaine_sauvegarde = (unsigned char *)
3674: (*s_sous_objet).objet;
3675:
3676: if (((*s_sous_objet).objet = malloc((strlen(
3677: chaine_sauvegarde) + 3) *
3678: sizeof(unsigned char))) == NULL)
3679: {
3680: (*s_etat_processus).erreur_systeme =
3681: d_es_allocation_memoire;
3682: return(NULL);
3683: }
3684:
3685: sprintf((unsigned char *) (*s_sous_objet).objet,
3686: "\"%s\"", chaine_sauvegarde);
3687:
3688: free(chaine_sauvegarde);
3689: }
3690:
3691: if (empilement(s_etat_processus, &((*s_etat_processus)
3692: .l_base_pile), s_sous_objet) == d_erreur)
3693: {
3694: return(NULL);
3695: }
3696: }
3697:
3698: l_element_courant = (*l_element_courant).suivant;
3699: }
3700:
3701: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
3702: &s_sous_objet) == d_erreur)
3703: {
3704: return(NULL);
3705: }
3706:
3707: if ((chaine = (unsigned char *) malloc((strlen((unsigned char *)
3708: (*s_sous_objet).objet) + 2 + 1) * sizeof(unsigned char)))
3709: == NULL)
3710: {
3711: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3712: return(NULL);
3713: }
3714:
3715: sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet);
3716: liberation(s_etat_processus, s_sous_objet);
3717: }
3718: else if ((*s_objet).type == BIN)
3719: {
3720:
3721: /*
3722: --------------------------------------------------------------------------------
3723: Entier binaire en base 2, 8, 10 ou 16
3724: --------------------------------------------------------------------------------
3725: */
3726:
3727: if (format_sortie != 'B')
3728: {
3729: (*s_etat_processus).erreur_execution =
3730: d_ex_erreur_format_fichier;
3731: return(NULL);
3732: }
3733:
3734: masque_binaire = masque_entiers_binaires(s_etat_processus);
3735:
3736: if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
3737: (test_cfsf(s_etat_processus, 44) == d_faux))
3738: {
3739:
3740: /*
3741: -- Base décimale ---------------------------------------------------------------
3742: */
3743:
3744: sprintf(tampon, "%llu", (*((logical8 *)
3745: ((*s_objet).objet))) & masque_binaire);
3746: strcpy(base, "d");
3747: }
3748: else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&
3749: (test_cfsf(s_etat_processus, 44) == d_faux))
3750: {
3751:
3752: /*
3753: -- Base octale -----------------------------------------------------------------
3754: */
3755:
3756: sprintf(tampon, "%llo", (*((logical8 *)
3757: ((*s_objet).objet))) & masque_binaire);
3758: strcpy(base, "o");
3759: }
3760: else if (test_cfsf(s_etat_processus, 44) == d_vrai)
3761: {
3762:
3763: /*
3764: -- Bases hexadécimale et binaire -----------------------------------------------
3765: */
3766:
3767: sprintf(tampon, "%llX", (*((logical8 *)
3768: ((*s_objet).objet))) & masque_binaire);
3769:
3770: if (test_cfsf(s_etat_processus, 43) == d_vrai)
3771: {
3772: strcpy(base, "h");
3773: }
3774: else
3775: {
3776: chaine = (unsigned char *) malloc((strlen(tampon) + 1)
3777: * sizeof(unsigned char));
3778:
3779: if (chaine == NULL)
3780: {
3781: (*s_etat_processus).erreur_systeme =
3782: d_es_allocation_memoire;
3783: return(NULL);
3784: }
3785:
3786: strcpy(chaine, tampon);
3787: tampon[0] = 0;
3788:
3789: for(i = 0; i < strlen(chaine); i++)
3790: {
3791: switch(chaine[i])
3792: {
3793: case '0' :
3794: {
3795: strcat(tampon, (i != 0) ? "0000" : "0");
3796: break;
3797: }
3798: case '1' :
3799: {
3800: strcat(tampon, (i != 0) ? "0001" : "1");
3801: break;
3802: }
3803: case '2' :
3804: {
3805: strcat(tampon, (i != 0) ? "0010" : "10");
3806: break;
3807: }
3808: case '3' :
3809: {
3810: strcat(tampon, (i != 0) ? "0011" : "11");
3811: break;
3812: }
3813: case '4' :
3814: {
3815: strcat(tampon, (i != 0) ? "0100" : "100");
3816: break;
3817: }
3818: case '5' :
3819: {
3820: strcat(tampon, (i != 0) ? "0101" : "101");
3821: break;
3822: }
3823: case '6' :
3824: {
3825: strcat(tampon, (i != 0) ? "0110" : "110");
3826: break;
3827: }
3828: case '7' :
3829: {
3830: strcat(tampon, (i != 0) ? "0111" : "111");
3831: break;
3832: }
3833: case '8' :
3834: {
3835: strcat(tampon, "1000");
3836: break;
3837: }
3838: case '9' :
3839: {
3840: strcat(tampon, "1001");
3841: break;
3842: }
3843: case 'A' :
3844: {
3845: strcat(tampon, "1010");
3846: break;
3847: }
3848: case 'B' :
3849: {
3850: strcat(tampon, "1011");
3851: break;
3852: }
3853: case 'C' :
3854: {
3855: strcat(tampon, "1100");
3856: break;
3857: }
3858: case 'D' :
3859: {
3860: strcat(tampon, "1101");
3861: break;
3862: }
3863: case 'E' :
3864: {
3865: strcat(tampon, "1110");
3866: break;
3867: }
3868: case 'F' :
3869: {
3870: strcat(tampon, "1111");
3871: break;
3872: }
3873: }
3874: }
3875:
3876: free(chaine);
3877: strcpy(base, "b");
3878: }
3879: }
3880:
3881: chaine = (unsigned char *) malloc((strlen(tampon) + 4)
3882: * sizeof(unsigned char));
3883:
3884: if (chaine == NULL)
3885: {
3886: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3887: return(NULL);
3888: }
3889:
3890: strcpy(chaine, "# ");
3891:
3892: strcat(chaine, tampon);
3893: strcat(chaine, base);
3894: }
3895: else if ((*s_objet).type == CHN)
3896: {
3897:
3898: /*
3899: --------------------------------------------------------------------------------
3900: Chaîne de caractères
3901: --------------------------------------------------------------------------------
3902: */
3903:
3904: if (format_sortie != 'C')
3905: {
3906: (*s_etat_processus).erreur_execution =
3907: d_ex_erreur_format_fichier;
3908: return(NULL);
3909: }
3910:
3911: chaine = (unsigned char *) malloc((strlen((unsigned char *)
3912: ((*s_objet).objet)) + 1) * sizeof(unsigned char));
3913:
3914: if (chaine == NULL)
3915: {
3916: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3917: return(NULL);
3918: }
3919:
3920: strcpy(chaine, (unsigned char *) ((*s_objet).objet));
3921: }
3922: else if ((*s_objet).type == CPL)
3923: {
3924:
3925: /*
3926: --------------------------------------------------------------------------------
3927: Complexe
3928: Poids fort 0001 10
3929: --------------------------------------------------------------------------------
3930: */
3931:
3932: if (format_sortie != 'C')
3933: {
3934: (*s_etat_processus).erreur_execution =
3935: d_ex_erreur_format_fichier;
3936: return(NULL);
3937: }
3938:
3939: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
3940: (*s_objet).objet, 'C', longueur, longueur_effective))
3941: == NULL)
3942: {
3943: return(NULL);
3944: }
3945: }
3946: else if ((*s_objet).type == RPN)
3947: {
3948:
3949: /*
3950: --------------------------------------------------------------------------------
3951: Définition
3952: --------------------------------------------------------------------------------
3953: */
3954:
3955: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
3956: chaine_sauvegarde = chaine;
3957:
3958: while(l_element_courant != NULL)
3959: {
3960: if ((chaine_formatee = formateur_fichier(s_etat_processus,
3961: (*l_element_courant).donnee, s_format,
3962: longueur, longueur_champ, format_sortie, type,
3963: longueur_effective, recursivite)) == NULL)
3964: {
3965: return(NULL);
3966: }
3967:
3968: if ((*(*l_element_courant).donnee).type == CHN)
3969: {
3970: chaine_tampon = chaine_formatee;
3971:
3972: if ((chaine_formatee = (unsigned char *) malloc((strlen(
3973: chaine_tampon) + 3) * sizeof(unsigned char)))
3974: == NULL)
3975: {
3976: (*s_etat_processus).erreur_systeme =
3977: d_es_allocation_memoire;
3978: return(NULL);
3979: }
3980:
3981: sprintf(chaine_formatee, "\"%s\"", chaine_tampon);
3982: free(chaine_tampon);
3983: }
3984:
3985: l_element_courant = (*l_element_courant).suivant;
3986:
3987: if (chaine != NULL)
3988: {
3989: chaine_sauvegarde = chaine;
3990:
3991: if ((chaine = (unsigned char *) malloc((strlen(
3992: chaine_sauvegarde) + strlen(chaine_formatee) + 2) *
3993: sizeof(unsigned char))) == NULL)
3994: {
3995: (*s_etat_processus).erreur_systeme =
3996: d_es_allocation_memoire;
3997: return(NULL);
3998: }
3999:
4000: strcpy(chaine, chaine_sauvegarde);
4001: free(chaine_sauvegarde);
4002: strcat(chaine, " ");
4003: strcat(chaine, chaine_formatee);
4004: free(chaine_formatee);
4005: }
4006: else
4007: {
4008: chaine = chaine_formatee;
4009: }
4010: }
4011:
4012: chaine_sauvegarde = chaine;
4013: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) *
4014: sizeof(unsigned char));
4015:
4016: if (chaine == NULL)
4017: {
4018: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4019: free(chaine_sauvegarde);
4020: return(NULL);
4021: }
4022:
4023: chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine;
4024: strcpy(chaine, chaine_sauvegarde);
4025: free(chaine_sauvegarde);
4026: }
4027: else if ((*s_objet).type == INT)
4028: {
4029:
4030: /*
4031: --------------------------------------------------------------------------------
4032: Entier
4033: Poids fort 0001 00
4034: --------------------------------------------------------------------------------
4035: */
4036:
4037: if (format_sortie != 'I')
4038: {
4039: (*s_etat_processus).erreur_execution =
4040: d_ex_erreur_format_fichier;
4041: return(NULL);
4042: }
4043:
4044: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
4045: (*s_objet).objet, 'I', longueur, longueur_effective))
4046: == NULL)
4047: {
4048: return(NULL);
4049: }
4050: }
4051: else if ((*s_objet).type == FCT)
4052: {
4053:
4054: /*
4055: --------------------------------------------------------------------------------
4056: Fonction
4057: --------------------------------------------------------------------------------
4058: */
4059:
4060: chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
4061: ((*s_objet).objet))).nom_fonction) + 1) *
4062: sizeof(unsigned char));
4063:
4064: if (chaine == NULL)
4065: {
4066: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4067: return(NULL);
4068: }
4069:
4070: strcpy(chaine, (unsigned char *) (*((struct_fonction *)
4071: ((*s_objet).objet))).nom_fonction);
4072: }
4073: else if ((*s_objet).type == LST)
4074: {
4075:
4076: /*
4077: --------------------------------------------------------------------------------
4078: Liste
4079: Poids fort 0100
4080: --------------------------------------------------------------------------------
4081: */
4082:
4083: chaine = malloc(sizeof(unsigned char));
4084:
4085: if (chaine == NULL)
4086: {
4087: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4088: return(NULL);
4089: }
4090:
4091: // Calcul de la longueur de la liste.
4092:
4093: longueur_liste = 0;
4094: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
4095:
4096: while(l_element_courant != NULL)
4097: {
4098: l_element_courant = (*l_element_courant).suivant;
4099: longueur_liste++;
4100: }
4101:
4102: if (longueur_liste < (1LL << 3))
4103: {
4104: chaine[0] = 0x40 | (longueur_liste & 0x7);
4105: }
4106: else if (longueur_liste < (1LL << 8))
4107: {
4108: chaine[0] = 0x48;
4109: }
4110: else if (longueur_liste < (1LL << 16))
4111: {
4112: chaine[0] = 0x49;
4113: }
4114: else if (longueur_liste < (1LL << 32))
4115: {
4116: chaine[0] = 0x4A;
4117: }
4118: else
4119: {
4120: chaine[0] = 0x4B;
4121: }
4122:
4123: longueur_totale = 1;
4124:
4125: if ((chaine[0] & 0x8) != 0)
4126: {
4127: switch(chaine[0] & 0x03)
4128: {
4129: case 0x00 :
4130: {
4131: longueur_totale += 1;
4132:
4133: if ((chaine = realloc(chaine, longueur_totale *
4134: sizeof(unsigned char))) == NULL)
4135: {
4136: (*s_etat_processus).erreur_systeme =
4137: d_es_allocation_memoire;
4138: return(NULL);
4139: }
4140:
4141: chaine[longueur_totale - 1] =
4142: (unsigned char) (longueur_liste & 0xFF);
4143: break;
4144: }
4145:
4146: case 0x01 :
4147: {
4148: longueur_totale += 2;
4149:
4150: if ((chaine = realloc(chaine, longueur_totale *
4151: sizeof(unsigned char))) == NULL)
4152: {
4153: (*s_etat_processus).erreur_systeme =
4154: d_es_allocation_memoire;
4155: return(NULL);
4156: }
4157:
4158: chaine[longueur_totale - 2] =
4159: (unsigned char) ((longueur_liste >> 8) & 0xFF);
4160: chaine[longueur_totale - 1] =
4161: (unsigned char) (longueur_liste & 0xFF);
4162: break;
4163: }
4164:
4165: case 0x02 :
4166: {
4167: longueur_totale += 4;
4168:
4169: if ((chaine = realloc(chaine, longueur_totale *
4170: sizeof(unsigned char))) == NULL)
4171: {
4172: (*s_etat_processus).erreur_systeme =
4173: d_es_allocation_memoire;
4174: return(NULL);
4175: }
4176:
4177: chaine[longueur_totale - 4] =
4178: (unsigned char) ((longueur_liste >> 24) & 0xFF);
4179: chaine[longueur_totale - 3] =
4180: (unsigned char) ((longueur_liste >> 16) & 0xFF);
4181: chaine[longueur_totale - 2] =
4182: (unsigned char) ((longueur_liste >> 8) & 0xFF);
4183: chaine[longueur_totale - 1] =
4184: (unsigned char) (longueur_liste & 0xFF);
4185: break;
4186: }
4187:
4188: case 0x03 :
4189: {
4190: longueur_totale += 8;
4191:
4192: if ((chaine = realloc(chaine, longueur_totale *
4193: sizeof(unsigned char))) == NULL)
4194: {
4195: (*s_etat_processus).erreur_systeme =
4196: d_es_allocation_memoire;
4197: return(NULL);
4198: }
4199:
4200: chaine[longueur_totale - 8] =
4201: (unsigned char) ((longueur_liste >> 56) & 0xFF);
4202: chaine[longueur_totale - 7] =
4203: (unsigned char) ((longueur_liste >> 48) & 0xFF);
4204: chaine[longueur_totale - 6] =
4205: (unsigned char) ((longueur_liste >> 40) & 0xFF);
4206: chaine[longueur_totale - 5] =
4207: (unsigned char) ((longueur_liste >> 32) & 0xFF);
4208: chaine[longueur_totale - 4] =
4209: (unsigned char) ((longueur_liste >> 24) & 0xFF);
4210: chaine[longueur_totale - 3] =
4211: (unsigned char) ((longueur_liste >> 16) & 0xFF);
4212: chaine[longueur_totale - 2] =
4213: (unsigned char) ((longueur_liste >> 8) & 0xFF);
4214: chaine[longueur_totale - 1] =
4215: (unsigned char) (longueur_liste & 0xFF);
4216: break;
4217: }
4218:
4219: default :
4220: {
4221: BUG(1, printf("Internal format error\n"));
4222: }
4223: }
4224: }
4225:
4226: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
4227: l_element_courant_format = (struct_liste_chainee *)
4228: (*s_format).objet;
4229: nombre_elements = 0;
4230:
4231: while((l_element_courant != NULL) &&
4232: (l_element_courant_format != NULL))
4233: {
4234: if ((((*(*l_element_courant_format).donnee).type == LST)
4235: && ((*(*l_element_courant).donnee).type == LST)) ||
4236: (((*(*l_element_courant_format).donnee).type == TBL)
4237: && ((*(*l_element_courant).donnee).type == TBL)))
4238: {
4239: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4240: (*l_element_courant).donnee,
4241: (*l_element_courant_format).donnee,
4242: 0, 0, ' ', 'U', longueur_effective, recursivite))
4243: == NULL)
4244: {
4245: return(NULL);
4246: }
4247:
4248: if ((chaine = realloc(chaine, (longueur_totale +
4249: (*longueur_effective)) * sizeof(unsigned char)))
4250: == NULL)
4251: {
4252: (*s_etat_processus).erreur_systeme =
4253: d_es_allocation_memoire;
4254: return(NULL);
4255: }
4256:
4257: memcpy(&(chaine[longueur_totale]), chaine_formatee,
4258: (*longueur_effective));
4259: longueur_totale += (*longueur_effective);
4260: free(chaine_formatee);
4261: }
4262: else if ((*(*l_element_courant_format).donnee).type != CHN)
4263: {
4264: free(chaine);
4265:
4266: (*s_etat_processus).erreur_execution =
4267: d_ex_erreur_format_fichier;
4268: return(NULL);
4269: }
4270: else
4271: {
4272: if ((format_chaine = conversion_majuscule((unsigned char *)
4273: (*(*l_element_courant_format).donnee).objet))
4274: == NULL)
4275: {
4276: (*s_etat_processus).erreur_systeme =
4277: d_es_allocation_memoire;
4278: return(NULL);
4279: }
4280:
4281: format_degenere = d_faux;
4282:
4283: if (strncmp("INTEGER*", format_chaine, 8) == 0)
4284: {
4285: format_sortie = 'I';
4286: position_1 = 8;
4287: }
4288: else if (strncmp("LOGICAL*", format_chaine, 8) == 0)
4289: {
4290: format_sortie = 'L';
4291: position_1 = 8;
4292: }
4293: else if (strncmp("REAL*", format_chaine, 5) == 0)
4294: {
4295: format_sortie = 'R';
4296: position_1 = 5;
4297: }
4298: else if (strncmp("COMPLEX*", format_chaine, 8) == 0)
4299: {
4300: format_sortie = 'C';
4301: position_1 = 8;
4302: }
4303: else if (strcmp("CHARACTER", format_chaine) == 0)
4304: {
4305: format_sortie = 'S';
4306: position_1 = 10;
4307: format_degenere = d_vrai;
4308: }
4309: else
4310: {
4311: free(chaine);
4312: free(format_chaine);
4313:
4314: (*s_etat_processus).erreur_execution =
4315: d_ex_erreur_format_fichier;
4316: return(NULL);
4317: }
4318:
4319: if (format_degenere == d_faux)
4320: {
4321: if (format_chaine[position_1] == d_code_fin_chaine)
4322: {
4323: free(chaine);
4324: free(format_chaine);
4325:
4326: (*s_etat_processus).erreur_execution =
4327: d_ex_erreur_format_fichier;
4328: return(NULL);
4329: }
4330:
4331: if (sscanf(&(format_chaine[position_1]), "%ld",
4332: &longueur) != 1)
4333: {
4334: free(chaine);
4335: free(format_chaine);
4336:
4337: (*s_etat_processus).erreur_execution =
4338: d_ex_erreur_format_fichier;
4339: return(NULL);
4340: }
4341: }
4342: else
4343: {
4344: longueur = -1;
4345: }
4346:
4347: free(format_chaine);
4348:
4349: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4350: (*l_element_courant).donnee, s_format,
4351: longueur, longueur_champ, format_sortie, type,
4352: longueur_effective, recursivite)) == NULL)
4353: {
4354: free(chaine);
4355: return(NULL);
4356: }
4357:
4358: if ((chaine = realloc(chaine,
4359: (longueur_totale + (*longueur_effective))
4360: * sizeof(unsigned char))) == NULL)
4361: {
4362: (*s_etat_processus).erreur_systeme =
4363: d_es_allocation_memoire;
4364: return(NULL);
4365: }
4366:
4367: memcpy(&(chaine[longueur_totale]), chaine_formatee,
4368: (*longueur_effective));
4369: longueur_totale += (*longueur_effective);
4370: free(chaine_formatee);
4371: }
4372:
4373: nombre_elements++;
4374: l_element_courant = (*l_element_courant).suivant;
4375: l_element_courant_format = (*l_element_courant_format).suivant;
4376: }
4377:
4378: if ((l_element_courant != NULL) ||
4379: (l_element_courant_format != NULL))
4380: {
4381: free(chaine);
4382:
4383: (*s_etat_processus).erreur_execution =
4384: d_ex_erreur_format_fichier;
4385: return(NULL);
4386: }
4387:
4388: if ((*recursivite) == 1)
4389: {
4390: // Ajout de la longueur totale en fin d'enregistrement.
4391:
4392: if (longueur_totale < (((integer8) 1) << 6))
4393: {
4394: tampon[0] = longueur_totale + 1;
4395:
4396: if ((chaine = realloc(chaine, (longueur_totale + 1)
4397: * sizeof(unsigned char))) == NULL)
4398: {
4399: (*s_etat_processus).erreur_systeme =
4400: d_es_allocation_memoire;
4401: return(NULL);
4402: }
4403:
4404: memcpy(&(chaine[longueur_totale]), tampon, 1);
4405: longueur_totale += 1;
4406: }
4407: else if (longueur_totale < (((integer8) 1) << 16))
4408: {
4409: tampon[2] = 0x40;
4410: tampon[1] = (longueur_totale + 1) & 0xFF;
4411: tampon[0] = ((longueur_totale + 1) >> 8) & 0xFF;
4412:
4413: if ((chaine = realloc(chaine, (longueur_totale + 3)
4414: * sizeof(unsigned char))) == NULL)
4415: {
4416: (*s_etat_processus).erreur_systeme =
4417: d_es_allocation_memoire;
4418: return(NULL);
4419: }
4420:
4421: memcpy(&(chaine[longueur_totale]), tampon, 3);
4422: longueur_totale += 3;
4423: }
4424: else if (longueur_totale < (((integer8) 1) << 32))
4425: {
4426: tampon[4] = 0x80;
4427: tampon[3] = (longueur_totale + 1) & 0xFF;
4428: tampon[2] = ((longueur_totale + 1) >> 8) & 0xFF;
4429: tampon[1] = ((longueur_totale + 1) >> 16) & 0xFF;
4430: tampon[0] = ((longueur_totale + 1) >> 24) & 0xFF;
4431:
4432: if ((chaine = realloc(chaine, (longueur_totale + 5)
4433: * sizeof(unsigned char))) == NULL)
4434: {
4435: (*s_etat_processus).erreur_systeme =
4436: d_es_allocation_memoire;
4437: return(NULL);
4438: }
4439:
4440: memcpy(&(chaine[longueur_totale]), tampon, 5);
4441: longueur_totale += 5;
4442: }
4443: else
4444: {
4445: tampon[8] = 0xC0;
4446: tampon[7] = (longueur_totale + 1) & 0xFF;
4447: tampon[6] = ((longueur_totale + 1) >> 8) & 0xFF;
4448: tampon[5] = ((longueur_totale + 1) >> 16) & 0xFF;
4449: tampon[4] = ((longueur_totale + 1) >> 24) & 0xFF;
4450: tampon[3] = ((longueur_totale + 1) >> 32) & 0xFF;
4451: tampon[2] = ((longueur_totale + 1) >> 40) & 0xFF;
4452: tampon[1] = ((longueur_totale + 1) >> 48) & 0xFF;
4453: tampon[0] = ((longueur_totale + 1) >> 56) & 0xFF;
4454:
4455: if ((chaine = realloc(chaine, (longueur_totale + 9)
4456: * sizeof(unsigned char))) == NULL)
4457: {
4458: (*s_etat_processus).erreur_systeme =
4459: d_es_allocation_memoire;
4460: return(NULL);
4461: }
4462:
4463: memcpy(&(chaine[longueur_totale]), tampon, 9);
4464: longueur_totale += 9;
4465: }
4466:
4467: __zone();
4468: }
4469:
4470: (*longueur_effective) = longueur_totale;
4471: }
4472: else if ((*s_objet).type == TBL)
4473: {
4474:
4475: /*
4476: --------------------------------------------------------------------------------
4477: Table
4478: --------------------------------------------------------------------------------
4479: */
4480:
4481: if ((*s_format).type != TBL)
4482: {
4483: (*s_etat_processus).erreur_execution =
4484: d_ex_erreur_format_fichier;
4485: return(NULL);
4486: }
4487:
4488: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
4489: l_element_courant_format = (struct_liste_chainee *)
4490: (*s_format).objet;
4491:
4492: if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
4493: (*((struct_tableau *) (*s_format).objet)).nombre_elements)
4494: {
4495: (*s_etat_processus).erreur_execution =
4496: d_ex_erreur_format_fichier;
4497: return(NULL);
4498: }
4499:
4500: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
4501:
4502: if (chaine == NULL)
4503: {
4504: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4505: return(NULL);
4506: }
4507:
4508: strcpy(chaine, "<[");
4509:
4510: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
4511: .nombre_elements; i++)
4512: {
4513: if ((((*(*((struct_tableau *) (*s_format).objet))
4514: .elements[i]).type == LST) &&
4515: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
4516: .type == LST)) ||
4517: (((*(*((struct_tableau *) (*s_format).objet))
4518: .elements[i]).type == TBL) &&
4519: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
4520: .type == TBL)))
4521: {
4522: chaine_sauvegarde = chaine;
4523:
4524: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4525: (*l_element_courant).donnee,
4526: (*l_element_courant_format).donnee,
4527: 0, 0, ' ', 'F', longueur_effective, recursivite))
4528: == NULL)
4529: {
4530: return(NULL);
4531: }
4532:
4533: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
4534: + strlen(chaine_sauvegarde) + 2)
4535: * sizeof(unsigned char));
4536:
4537: if (chaine == NULL)
4538: {
4539: (*s_etat_processus).erreur_systeme =
4540: d_es_allocation_memoire;
4541: return(NULL);
4542: }
4543:
4544: strcpy(chaine, chaine_sauvegarde);
4545: free(chaine_sauvegarde);
4546: strcat(chaine, " ");
4547: strcat(chaine, chaine_formatee);
4548: free(chaine_formatee);
4549: }
4550: else if ((*(*((struct_tableau *) (*s_format).objet))
4551: .elements[i]).type != CHN)
4552: {
4553: free(chaine);
4554:
4555: (*s_etat_processus).erreur_execution =
4556: d_ex_erreur_format_fichier;
4557: return(NULL);
4558: }
4559: else
4560: {
4561: if ((format_chaine = conversion_majuscule((unsigned char *)
4562: (*(*((struct_tableau *) (*s_format).objet))
4563: .elements[i]).objet)) == NULL)
4564: {
4565: (*s_etat_processus).erreur_systeme =
4566: d_es_allocation_memoire;
4567: return(NULL);
4568: }
4569:
4570: format_degenere = d_faux;
4571:
4572: if (strncmp("STANDARD*", format_chaine, 9) == 0)
4573: {
4574: format_sortie = 'S';
4575: position_1 = 9;
4576: format_degenere = d_vrai;
4577: }
4578: else if (strncmp("BINARY*", format_chaine, 7) == 0)
4579: {
4580: format_sortie = 'B';
4581: position_1 = 7;
4582: }
4583: else if (strncmp("FIXED*", format_chaine, 6) == 0)
4584: {
4585: format_sortie = 'F';
4586: position_1 = 6;
4587: }
4588: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
4589: {
4590: format_sortie = 'I';
4591: position_1 = 11;
4592: }
4593: else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
4594: {
4595: format_sortie = 'E';
4596: position_1 = 9;
4597: }
4598: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
4599: {
4600: format_sortie = 'C';
4601: position_1 = 10;
4602: format_degenere = d_vrai;
4603: }
4604: else
4605: {
4606: free(chaine);
4607: free(format_chaine);
4608:
4609: (*s_etat_processus).erreur_execution =
4610: d_ex_erreur_format_fichier;
4611: return(NULL);
4612: }
4613:
4614: position_3 = strlen(format_chaine);
4615: format_chaine[--position_3] = d_code_fin_chaine;
4616:
4617: position_2 = position_1;
4618:
4619: while(format_chaine[position_2] != '(')
4620: {
4621: if (format_chaine[position_2] == d_code_fin_chaine)
4622: {
4623: free(chaine);
4624: free(format_chaine);
4625:
4626: (*s_etat_processus).erreur_execution =
4627: d_ex_erreur_format_fichier;
4628: return(NULL);
4629: }
4630:
4631: position_2++;
4632: }
4633:
4634: format_chaine[position_2++] = d_code_fin_chaine;
4635:
4636: if (format_degenere == d_faux)
4637: {
4638: if (sscanf(&(format_chaine[position_1]), "%ld",
4639: &longueur) != 1)
4640: {
4641: free(chaine);
4642: free(format_chaine);
4643:
4644: (*s_etat_processus).erreur_execution =
4645: d_ex_erreur_format_fichier;
4646: return(NULL);
4647: }
4648: }
4649: else
4650: {
4651: longueur = -1;
4652: }
4653:
4654: if (strcmp(&(format_chaine[position_2]), "*") != 0)
4655: {
4656: if (sscanf(&(format_chaine[position_2]), "%ld",
4657: &longueur_champ) != 1)
4658: {
4659: free(chaine);
4660: free(format_chaine);
4661:
4662: (*s_etat_processus).erreur_execution =
4663: d_ex_erreur_format_fichier;
4664: return(NULL);
4665: }
4666: }
4667: else
4668: {
4669: longueur_champ = -1;
4670: }
4671:
4672: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
4673: longueur_champ))
4674: {
4675: free(chaine);
4676: free(format_chaine);
4677:
4678: (*s_etat_processus).erreur_execution =
4679: d_ex_erreur_format_fichier;
4680: return(NULL);
4681: }
4682:
4683: free(format_chaine);
4684:
4685: chaine_sauvegarde = chaine;
4686:
4687: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4688: (*((struct_tableau *) (*s_objet).objet))
4689: .elements[i], s_format,
4690: longueur, longueur_champ, format_sortie, type,
4691: longueur_effective, recursivite)) == NULL)
4692: {
4693: return(NULL);
4694: }
4695:
4696: if ((*(*((struct_tableau *) (*s_objet).objet))
4697: .elements[i]).type == CHN)
4698: {
4699: chaine = (unsigned char *)
4700: malloc((strlen(chaine_formatee)
4701: + strlen(chaine_sauvegarde) + 4)
4702: * sizeof(unsigned char));
4703:
4704: if (chaine == NULL)
4705: {
4706: (*s_etat_processus).erreur_systeme =
4707: d_es_allocation_memoire;
4708: return(NULL);
4709: }
4710:
4711: strcpy(chaine, chaine_sauvegarde);
4712: free(chaine_sauvegarde);
4713: strcat(chaine, " \"");
4714: strcat(chaine, chaine_formatee);
4715: free(chaine_formatee);
4716: strcat(chaine, "\"");
4717: }
4718: else if ((*(*((struct_tableau *) (*s_objet).objet))
4719: .elements[i]).type == NOM)
4720: {
4721: chaine = (unsigned char *)
4722: malloc((strlen(chaine_formatee)
4723: + strlen(chaine_sauvegarde) + 2)
4724: * sizeof(unsigned char));
4725:
4726: if (chaine == NULL)
4727: {
4728: (*s_etat_processus).erreur_systeme =
4729: d_es_allocation_memoire;
4730: return(NULL);
4731: }
4732:
4733: sprintf(chaine, "%s %s", chaine_sauvegarde,
4734: chaine_formatee);
4735: free(chaine_formatee);
4736: }
4737: else
4738: {
4739: chaine = (unsigned char *)
4740: malloc((strlen(chaine_formatee)
4741: + strlen(chaine_sauvegarde) + 2)
4742: * sizeof(unsigned char));
4743:
4744: if (chaine == NULL)
4745: {
4746: (*s_etat_processus).erreur_systeme =
4747: d_es_allocation_memoire;
4748: return(NULL);
4749: }
4750:
4751: strcpy(chaine, chaine_sauvegarde);
4752: free(chaine_sauvegarde);
4753: strcat(chaine, " ");
4754: strcat(chaine, chaine_formatee);
4755: free(chaine_formatee);
4756: }
4757: }
4758: }
4759:
4760: chaine_sauvegarde = chaine;
4761: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4)
4762: * sizeof(unsigned char));
4763:
4764: if (chaine == NULL)
4765: {
4766: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4767: return(NULL);
4768: }
4769:
4770: strcpy(chaine, chaine_sauvegarde);
4771: free(chaine_sauvegarde);
4772: strcat(chaine, " ]>");
4773: }
4774: else if ((*s_objet).type == MCX)
4775: {
4776:
4777: /*
4778: --------------------------------------------------------------------------------
4779: Matrice complexe
4780: --------------------------------------------------------------------------------
4781: */
4782:
4783: if ((format_sortie != 'S') && (format_sortie != 'F') &&
4784: (format_sortie != 'I') && (format_sortie != 'E'))
4785: {
4786: (*s_etat_processus).erreur_execution =
4787: d_ex_erreur_format_fichier;
4788: return(NULL);
4789: }
4790:
4791: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
4792: .nombre_lignes;
4793: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
4794: .nombre_colonnes;
4795:
4796: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
4797:
4798: if (chaine != NULL)
4799: {
4800: strcpy(chaine, "[[");
4801:
4802: for(i = 0; i < nombre_lignes; i++)
4803: {
4804: for(j = 0; j < nombre_colonnes; j++)
4805: {
4806: if ((chaine_formatee =
4807: formateur_fichier_nombre(s_etat_processus,
4808: (void *) &(((struct_complexe16 **)
4809: ((*((struct_matrice *)
4810: ((*s_objet).objet))).tableau))[i][j]), 'C',
4811: longueur, longueur_champ, format_sortie))
4812: == NULL)
4813: {
4814: (*s_etat_processus).erreur_systeme =
4815: d_es_allocation_memoire;
4816: return(NULL);
4817: }
4818:
4819: chaine_sauvegarde = chaine;
4820: chaine = (unsigned char *) malloc(
4821: (strlen(chaine_sauvegarde) +
4822: strlen(chaine_formatee) + 2)
4823: * sizeof(unsigned char));
4824:
4825: if (chaine == NULL)
4826: {
4827: (*s_etat_processus).erreur_systeme =
4828: d_es_allocation_memoire;
4829: return(NULL);
4830: }
4831:
4832: strcpy(chaine, chaine_sauvegarde);
4833: free(chaine_sauvegarde);
4834: strcat(chaine, " ");
4835: strcat(chaine, chaine_formatee);
4836: free(chaine_formatee);
4837: }
4838:
4839: chaine_sauvegarde = chaine;
4840: if (test_cfsf(s_etat_processus, 45) == d_vrai)
4841: {
4842: chaine = (unsigned char *) malloc(
4843: (strlen(chaine_sauvegarde) + 6)
4844: * sizeof(unsigned char));
4845:
4846: if (chaine == NULL)
4847: {
4848: (*s_etat_processus).erreur_systeme =
4849: d_es_allocation_memoire;
4850: return(NULL);
4851: }
4852:
4853: strcpy(chaine, chaine_sauvegarde);
4854: free(chaine_sauvegarde);
4855: strcat(chaine, " ]\n [");
4856: }
4857: else
4858: {
4859: chaine = (unsigned char *) malloc(
4860: (strlen(chaine_sauvegarde) + 4)
4861: * sizeof(unsigned char));
4862:
4863: if (chaine == NULL)
4864: {
4865: (*s_etat_processus).erreur_systeme =
4866: d_es_allocation_memoire;
4867: return(NULL);
4868: }
4869:
4870: strcpy(chaine, chaine_sauvegarde);
4871: free(chaine_sauvegarde);
4872: strcat(chaine, " ][");
4873: }
4874: }
4875:
4876: if (test_cfsf(s_etat_processus, 45) == d_vrai)
4877: {
4878: chaine[strlen(chaine) - 3] = ']';
4879: chaine[strlen(chaine) - 2] = 0;
4880:
4881: chaine_sauvegarde = chaine;
4882: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
4883: + 1) * sizeof(unsigned char));
4884:
4885: if (chaine == NULL)
4886: {
4887: (*s_etat_processus).erreur_systeme =
4888: d_es_allocation_memoire;
4889: return(NULL);
4890: }
4891:
4892: strcpy(chaine, chaine_sauvegarde);
4893: free(chaine_sauvegarde);
4894: }
4895: else
4896: {
4897: chaine[strlen(chaine) - 2] = ']';
4898: chaine[strlen(chaine) - 1] = 0;
4899:
4900: chaine_sauvegarde = chaine;
4901: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
4902: + 2) * sizeof(unsigned char));
4903:
4904: if (chaine == NULL)
4905: {
4906: (*s_etat_processus).erreur_systeme =
4907: d_es_allocation_memoire;
4908: return(NULL);
4909: }
4910:
4911: strcpy(chaine, chaine_sauvegarde);
4912: free(chaine_sauvegarde);
4913: strcat(chaine, "]");
4914: }
4915: }
4916: }
4917: else if ((*s_objet).type == MIN)
4918: {
4919:
4920: /*
4921: --------------------------------------------------------------------------------
4922: Matrice entière
4923: --------------------------------------------------------------------------------
4924: */
4925:
4926: if ((format_sortie != 'S') && (format_sortie != 'F') &&
4927: (format_sortie != 'I') && (format_sortie != 'E'))
4928: {
4929: (*s_etat_processus).erreur_execution =
4930: d_ex_erreur_format_fichier;
4931: return(NULL);
4932: }
4933:
4934: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
4935: .nombre_lignes;
4936: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
4937: .nombre_colonnes;
4938:
4939: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
4940:
4941: if (chaine != NULL)
4942: {
4943: strcpy(chaine, "[[");
4944:
4945: for(i = 0; i < nombre_lignes; i++)
4946: {
4947: for(j = 0; j < nombre_colonnes; j++)
4948: {
4949: if ((chaine_formatee =
4950: formateur_fichier_nombre(s_etat_processus,
4951: (void *) &(((integer8 **) ((*((struct_matrice *)
4952: ((*s_objet).objet))).tableau))[i][j]), 'I',
4953: longueur, longueur_champ, format_sortie))
4954: == NULL)
4955: {
4956: (*s_etat_processus).erreur_systeme =
4957: d_es_allocation_memoire;
4958: return(NULL);
4959: }
4960:
4961: chaine_sauvegarde = chaine;
4962: chaine = (unsigned char *) malloc(
4963: (strlen(chaine_sauvegarde) +
4964: strlen(chaine_formatee) + 2)
4965: * sizeof(unsigned char));
4966:
4967: if (chaine == NULL)
4968: {
4969: (*s_etat_processus).erreur_systeme =
4970: d_es_allocation_memoire;
4971: return(NULL);
4972: }
4973:
4974: strcpy(chaine, chaine_sauvegarde);
4975: free(chaine_sauvegarde);
4976: strcat(chaine, " ");
4977: strcat(chaine, chaine_formatee);
4978: free(chaine_formatee);
4979: }
4980:
4981: chaine_sauvegarde = chaine;
4982: if (test_cfsf(s_etat_processus, 45) == d_vrai)
4983: {
4984: chaine = (unsigned char *) malloc(
4985: (strlen(chaine_sauvegarde) + 6)
4986: * sizeof(unsigned char));
4987:
4988: if (chaine == NULL)
4989: {
4990: (*s_etat_processus).erreur_systeme =
4991: d_es_allocation_memoire;
4992: return(NULL);
4993: }
4994:
4995: strcpy(chaine, chaine_sauvegarde);
4996: free(chaine_sauvegarde);
4997: strcat(chaine, " ]\n [");
4998: }
4999: else
5000: {
5001: chaine = (unsigned char *) malloc(
5002: (strlen(chaine_sauvegarde) + 4)
5003: * sizeof(unsigned char));
5004:
5005: if (chaine == NULL)
5006: {
5007: (*s_etat_processus).erreur_systeme =
5008: d_es_allocation_memoire;
5009: return(NULL);
5010: }
5011:
5012: strcpy(chaine, chaine_sauvegarde);
5013: free(chaine_sauvegarde);
5014: strcat(chaine, " ][");
5015: }
5016: }
5017:
5018: if (test_cfsf(s_etat_processus, 45) == d_vrai)
5019: {
5020: chaine[strlen(chaine) - 3] = ']';
5021: chaine[strlen(chaine) - 2] = 0;
5022:
5023: chaine_sauvegarde = chaine;
5024: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
5025: + 1) * sizeof(unsigned char));
5026:
5027: if (chaine == NULL)
5028: {
5029: (*s_etat_processus).erreur_systeme =
5030: d_es_allocation_memoire;
5031: return(NULL);
5032: }
5033:
5034: strcpy(chaine, chaine_sauvegarde);
5035: free(chaine_sauvegarde);
5036: }
5037: else
5038: {
5039: chaine[strlen(chaine) - 2] = ']';
5040: chaine[strlen(chaine) - 1] = 0;
5041:
5042: chaine_sauvegarde = chaine;
5043: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
5044: + 2) * sizeof(unsigned char));
5045:
5046: if (chaine == NULL)
5047: {
5048: (*s_etat_processus).erreur_systeme =
5049: d_es_allocation_memoire;
5050: return(NULL);
5051: }
5052:
5053: strcpy(chaine, chaine_sauvegarde);
5054: free(chaine_sauvegarde);
5055: strcat(chaine, "]");
5056: }
5057: }
5058: }
5059: else if ((*s_objet).type == MRL)
5060: {
5061:
5062: /*
5063: --------------------------------------------------------------------------------
5064: Matrice réelle
5065: --------------------------------------------------------------------------------
5066: */
5067:
5068: if ((format_sortie != 'S') && (format_sortie != 'F') &&
5069: (format_sortie != 'I') && (format_sortie != 'E'))
5070: {
5071: (*s_etat_processus).erreur_execution =
5072: d_ex_erreur_format_fichier;
5073: return(NULL);
5074: }
5075:
5076: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
5077: .nombre_lignes;
5078: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
5079: .nombre_colonnes;
5080:
5081: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
5082:
5083: if (chaine != NULL)
5084: {
5085: strcpy(chaine, "[[");
5086:
5087: for(i = 0; i < nombre_lignes; i++)
5088: {
5089: for(j = 0; j < nombre_colonnes; j++)
5090: {
5091: if ((chaine_formatee =
5092: formateur_fichier_nombre(s_etat_processus,
5093: (void *) &(((real8 **) ((*((struct_matrice *)
5094: ((*s_objet).objet))).tableau))[i][j]), 'R',
5095: longueur, longueur_champ, format_sortie))
5096: == NULL)
5097: {
5098: (*s_etat_processus).erreur_systeme =
5099: d_es_allocation_memoire;
5100: return(NULL);
5101: }
5102:
5103: chaine_sauvegarde = chaine;
5104: chaine = (unsigned char *) malloc(
5105: (strlen(chaine_sauvegarde) +
5106: strlen(chaine_formatee) + 2)
5107: * sizeof(unsigned char));
5108:
5109: if (chaine == NULL)
5110: {
5111: (*s_etat_processus).erreur_systeme =
5112: d_es_allocation_memoire;
5113: return(NULL);
5114: }
5115:
5116: strcpy(chaine, chaine_sauvegarde);
5117: free(chaine_sauvegarde);
5118: strcat(chaine, " ");
5119: strcat(chaine, chaine_formatee);
5120: free(chaine_formatee);
5121: }
5122:
5123: chaine_sauvegarde = chaine;
5124: if (test_cfsf(s_etat_processus, 45) == d_vrai)
5125: {
5126: chaine = (unsigned char *) malloc(
5127: (strlen(chaine_sauvegarde) + 6)
5128: * sizeof(unsigned char));
5129:
5130: if (chaine == NULL)
5131: {
5132: (*s_etat_processus).erreur_systeme =
5133: d_es_allocation_memoire;
5134: return(NULL);
5135: }
5136:
5137: strcpy(chaine, chaine_sauvegarde);
5138: free(chaine_sauvegarde);
5139: strcat(chaine, " ]\n [");
5140: }
5141: else
5142: {
5143: chaine = (unsigned char *) malloc(
5144: (strlen(chaine_sauvegarde) + 4)
5145: * sizeof(unsigned char));
5146:
5147: if (chaine == NULL)
5148: {
5149: (*s_etat_processus).erreur_systeme =
5150: d_es_allocation_memoire;
5151: return(NULL);
5152: }
5153:
5154: strcpy(chaine, chaine_sauvegarde);
5155: free(chaine_sauvegarde);
5156: strcat(chaine, " ][");
5157: }
5158: }
5159:
5160: if (test_cfsf(s_etat_processus, 45) == d_vrai)
5161: {
5162: chaine[strlen(chaine) - 3] = ']';
5163: chaine[strlen(chaine) - 2] = 0;
5164:
5165: chaine_sauvegarde = chaine;
5166: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
5167: + 1) * sizeof(unsigned char));
5168:
5169: if (chaine == NULL)
5170: {
5171: (*s_etat_processus).erreur_systeme =
5172: d_es_allocation_memoire;
5173: return(NULL);
5174: }
5175:
5176: strcpy(chaine, chaine_sauvegarde);
5177: free(chaine_sauvegarde);
5178: }
5179: else
5180: {
5181: chaine[strlen(chaine) - 2] = ']';
5182: chaine[strlen(chaine) - 1] = 0;
5183:
5184: chaine_sauvegarde = chaine;
5185: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
5186: + 2) * sizeof(unsigned char));
5187:
5188: if (chaine == NULL)
5189: {
5190: (*s_etat_processus).erreur_systeme =
5191: d_es_allocation_memoire;
5192: return(NULL);
5193: }
5194:
5195: strcpy(chaine, chaine_sauvegarde);
5196: free(chaine_sauvegarde);
5197: strcat(chaine, "]");
5198: }
5199: }
5200: }
5201: else if ((*s_objet).type == NOM)
5202: {
5203:
5204: /*
5205: --------------------------------------------------------------------------------
5206: Nom
5207: --------------------------------------------------------------------------------
5208: */
5209:
5210: chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
5211: (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
5212:
5213: if (chaine == NULL)
5214: {
5215: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5216: return(NULL);
5217: }
5218:
5219: sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom);
5220: }
5221: else if ((*s_objet).type == REL)
5222: {
5223:
5224: /*
5225: --------------------------------------------------------------------------------
5226: Réel
5227: Poids fort 0001 01
5228: --------------------------------------------------------------------------------
5229: */
5230:
5231: if (format_sortie != 'R')
5232: {
5233: (*s_etat_processus).erreur_execution =
5234: d_ex_erreur_format_fichier;
5235: return(NULL);
5236: }
5237:
5238: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
5239: (*s_objet).objet, 'R', longueur, longueur_effective))
5240: == NULL)
5241: {
5242: return(NULL);
5243: }
5244: }
5245: else if ((*s_objet).type == VCX)
5246: {
5247:
5248: /*
5249: --------------------------------------------------------------------------------
5250: Vecteur complexe
5251: --------------------------------------------------------------------------------
5252: */
5253:
5254: if ((format_sortie != 'S') && (format_sortie != 'F') &&
5255: (format_sortie != 'I') && (format_sortie != 'E'))
5256: {
5257: (*s_etat_processus).erreur_execution =
5258: d_ex_erreur_format_fichier;
5259: return(NULL);
5260: }
5261:
5262: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
5263: .taille;
5264:
5265: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
5266:
5267: if (chaine != NULL)
5268: {
5269: strcpy(chaine, "[");
5270:
5271: for(i = 0; i < nombre_colonnes; i++)
5272: {
5273: if ((chaine_formatee =
5274: formateur_fichier_nombre(s_etat_processus,
5275: (void *) &(((struct_complexe16 *)
5276: ((*((struct_vecteur *)
5277: ((*s_objet).objet))).tableau))[i]), 'C',
5278: longueur, longueur_champ, format_sortie)) == NULL)
5279: {
5280: (*s_etat_processus).erreur_systeme =
5281: d_es_allocation_memoire;
5282: return(NULL);
5283: }
5284:
5285: chaine_sauvegarde = chaine;
5286: chaine = (unsigned char *) malloc(
5287: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
5288: + 2) * sizeof(unsigned char));
5289:
5290: if (chaine == NULL)
5291: {
5292: (*s_etat_processus).erreur_systeme =
5293: d_es_allocation_memoire;
5294: return(NULL);
5295: }
5296:
5297: strcpy(chaine, chaine_sauvegarde);
5298: free(chaine_sauvegarde);
5299: strcat(chaine, " ");
5300: strcat(chaine, chaine_formatee);
5301: free(chaine_formatee);
5302: }
5303:
5304: chaine_sauvegarde = chaine;
5305: chaine = (unsigned char *) malloc(
5306: (strlen(chaine_sauvegarde) + 3)
5307: * sizeof(unsigned char));
5308:
5309: if (chaine == NULL)
5310: {
5311: (*s_etat_processus).erreur_systeme =
5312: d_es_allocation_memoire;
5313: return(NULL);
5314: }
5315:
5316: strcpy(chaine, chaine_sauvegarde);
5317: free(chaine_sauvegarde);
5318: strcat(chaine, " ]");
5319: }
5320: }
5321: else if ((*s_objet).type == VIN)
5322: {
5323:
5324: /*
5325: --------------------------------------------------------------------------------
5326: Vecteur entier
5327: --------------------------------------------------------------------------------
5328: */
5329:
5330: if ((format_sortie != 'S') && (format_sortie != 'F') &&
5331: (format_sortie != 'I') && (format_sortie != 'E'))
5332: {
5333: (*s_etat_processus).erreur_execution =
5334: d_ex_erreur_format_fichier;
5335: return(NULL);
5336: }
5337:
5338: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
5339: .taille;
5340:
5341: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
5342:
5343: if (chaine != NULL)
5344: {
5345: strcpy(chaine, "[");
5346:
5347: for(i = 0; i < nombre_colonnes; i++)
5348: {
5349: if ((chaine_formatee =
5350: formateur_fichier_nombre(s_etat_processus,
5351: (void *) &(((integer8 *) ((*((struct_vecteur *)
5352: ((*s_objet).objet))).tableau))[i]), 'I',
5353: longueur, longueur_champ, format_sortie)) == NULL)
5354: {
5355: (*s_etat_processus).erreur_systeme =
5356: d_es_allocation_memoire;
5357: return(NULL);
5358: }
5359:
5360: chaine_sauvegarde = chaine;
5361: chaine = (unsigned char *) malloc(
5362: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
5363: + 2) * sizeof(unsigned char));
5364:
5365: if (chaine == NULL)
5366: {
5367: (*s_etat_processus).erreur_systeme =
5368: d_es_allocation_memoire;
5369: return(NULL);
5370: }
5371:
5372: strcpy(chaine, chaine_sauvegarde);
5373: free(chaine_sauvegarde);
5374: strcat(chaine, " ");
5375: strcat(chaine, chaine_formatee);
5376: free(chaine_formatee);
5377: }
5378:
5379: chaine_sauvegarde = chaine;
5380: chaine = (unsigned char *) malloc(
5381: (strlen(chaine_sauvegarde) + 3)
5382: * sizeof(unsigned char));
5383:
5384: if (chaine == NULL)
5385: {
5386: (*s_etat_processus).erreur_systeme =
5387: d_es_allocation_memoire;
5388: return(NULL);
5389: }
5390:
5391: strcpy(chaine, chaine_sauvegarde);
5392: free(chaine_sauvegarde);
5393: strcat(chaine, " ]");
5394: }
5395: }
5396: else if ((*s_objet).type == VRL)
5397: {
5398:
5399: /*
5400: --------------------------------------------------------------------------------
5401: Vecteur réel
5402: --------------------------------------------------------------------------------
5403: */
5404:
5405: if ((format_sortie != 'S') && (format_sortie != 'F') &&
5406: (format_sortie != 'I') && (format_sortie != 'E'))
5407: {
5408: (*s_etat_processus).erreur_execution =
5409: d_ex_erreur_format_fichier;
5410: return(NULL);
5411: }
5412:
5413: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
5414: .taille;
5415:
5416: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
5417:
5418: if (chaine != NULL)
5419: {
5420: strcpy(chaine, "[");
5421:
5422: for(i = 0; i < nombre_colonnes; i++)
5423: {
5424: if ((chaine_formatee =
5425: formateur_fichier_nombre(s_etat_processus,
5426: (void *) &(((real8 *) ((*((struct_vecteur *)
5427: ((*s_objet).objet))).tableau))[i]), 'R',
5428: longueur, longueur_champ, format_sortie)) == NULL)
5429: {
5430: (*s_etat_processus).erreur_systeme =
5431: d_es_allocation_memoire;
5432: return(NULL);
5433: }
5434:
5435: chaine_sauvegarde = chaine;
5436: chaine = (unsigned char *) malloc(
5437: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
5438: + 2) * sizeof(unsigned char));
5439:
5440: if (chaine == NULL)
5441: {
5442: (*s_etat_processus).erreur_systeme =
5443: d_es_allocation_memoire;
5444: return(NULL);
5445: }
5446:
5447: strcpy(chaine, chaine_sauvegarde);
5448: free(chaine_sauvegarde);
5449: strcat(chaine, " ");
5450: strcat(chaine, chaine_formatee);
5451: free(chaine_formatee);
5452: }
5453:
5454: chaine_sauvegarde = chaine;
5455: chaine = (unsigned char *) malloc(
5456: (strlen(chaine_sauvegarde) + 3)
5457: * sizeof(unsigned char));
5458:
5459: if (chaine == NULL)
5460: {
5461: (*s_etat_processus).erreur_systeme =
5462: d_es_allocation_memoire;
5463: return(NULL);
5464: }
5465:
5466: strcpy(chaine, chaine_sauvegarde);
5467: free(chaine_sauvegarde);
5468: strcat(chaine, " ]");
5469: }
5470: }
5471: else
5472: {
5473: // Type non exportable
5474:
5475: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
5476: free(chaine);
5477:
5478: return(NULL);
5479: }
5480: }
5481:
5482: (*recursivite)--;
5483:
5484: return(chaine);
5485: }
5486:
5487:
5488: /*
5489: ================================================================================
5490: Routines qui transforment un nombre entier, réel ou complexe en chaîne de
5491: caractères suivant le format courant
5492: ================================================================================
5493: Entrées : pointeur générique sur la donnée numérique à convertir,
5494: type de l'entité (I, R ou C).
5495: --------------------------------------------------------------------------------
5496: Sorties : chaîne de caractères allouée dans la routine
5497: --------------------------------------------------------------------------------
5498: Effets de bord : néant
5499: ================================================================================
5500: */
5501:
5502: /*
5503: --------------------------------------------------------------------------------
5504: Formatage des complexes, réels et entiers
5505: --------------------------------------------------------------------------------
5506: */
5507:
5508: unsigned char *
5509: formateur_fichier_nombre(struct_processus *s_etat_processus,
5510: void *valeur_numerique, unsigned char type,
5511: long longueur, long longueur_champ, unsigned char format)
5512: {
5513: unsigned char *chaine;
5514: unsigned char *construction_chaine;
5515: unsigned char *sauvegarde;
5516: unsigned char *tampon;
5517:
5518: chaine = NULL;
5519:
5520: switch(type)
5521: {
5522: case 'C' :
5523: {
5524: construction_chaine = (unsigned char *) malloc(
5525: 2 * sizeof(unsigned char));
5526:
5527: if (construction_chaine == NULL)
5528: {
5529: (*s_etat_processus).erreur_systeme =
5530: d_es_allocation_memoire;
5531: return(NULL);
5532: }
5533:
5534: strcpy(construction_chaine, "(");
5535:
5536: tampon = formateur_fichier_reel(s_etat_processus,
5537: (void *) &((*((struct_complexe16 *)
5538: valeur_numerique)).partie_reelle), 'R',
5539: longueur, longueur_champ, format);
5540:
5541: if (tampon == NULL)
5542: {
5543: (*s_etat_processus).erreur_systeme =
5544: d_es_allocation_memoire;
5545: return(NULL);
5546: }
5547:
5548: sauvegarde = construction_chaine;
5549:
5550: construction_chaine = (unsigned char *) malloc(
5551: (strlen(sauvegarde) + strlen(tampon) + 2)
5552: * sizeof(unsigned char));
5553:
5554: if (construction_chaine == NULL)
5555: {
5556: (*s_etat_processus).erreur_systeme =
5557: d_es_allocation_memoire;
5558: return(NULL);
5559: }
5560:
5561: strcpy(construction_chaine, sauvegarde);
5562: free(sauvegarde);
5563: strcat(construction_chaine, tampon);
5564: free(tampon);
5565:
5566: strcat(construction_chaine, ",");
5567:
5568: tampon = formateur_fichier_reel(s_etat_processus,
5569: (void *) &((*((struct_complexe16 *)
5570: valeur_numerique)).partie_imaginaire), 'R',
5571: longueur, longueur_champ, format);
5572:
5573: if (tampon == NULL)
5574: {
5575: (*s_etat_processus).erreur_systeme =
5576: d_es_allocation_memoire;
5577: return(NULL);
5578: }
5579:
5580: sauvegarde = construction_chaine;
5581:
5582: construction_chaine = (unsigned char *) malloc(
5583: (strlen(sauvegarde) + strlen(tampon) + 2)
5584: * sizeof(unsigned char));
5585:
5586: if (construction_chaine == NULL)
5587: {
5588: (*s_etat_processus).erreur_systeme =
5589: d_es_allocation_memoire;
5590: return(NULL);
5591: }
5592:
5593: strcpy(construction_chaine, sauvegarde);
5594: free(sauvegarde);
5595: strcat(construction_chaine, tampon);
5596: free(tampon);
5597: strcat(construction_chaine, ")");
5598:
5599: chaine = construction_chaine;
5600:
5601: break;
5602: }
5603:
5604: case 'R' :
5605: {
5606: chaine = formateur_fichier_reel(s_etat_processus,
5607: valeur_numerique, 'R', longueur, longueur_champ,
5608: format);
5609:
5610: if (chaine == NULL)
5611: {
5612: (*s_etat_processus).erreur_systeme =
5613: d_es_allocation_memoire;
5614: return(NULL);
5615: }
5616:
5617: break;
5618: }
5619:
5620: default :
5621: case 'I' :
5622: {
5623: chaine = formateur_fichier_reel(s_etat_processus,
5624: valeur_numerique, 'I', longueur, longueur_champ,
5625: format);
5626:
5627: if (chaine == NULL)
5628: {
5629: (*s_etat_processus).erreur_systeme =
5630: d_es_allocation_memoire;
5631: return(NULL);
5632: }
5633:
5634: break;
5635: }
5636: }
5637:
5638: return(chaine);
5639: }
5640:
5641:
5642: /*
5643: --------------------------------------------------------------------------------
5644: Formateur des réels et entiers
5645: --------------------------------------------------------------------------------
5646: */
5647:
5648: unsigned char *
5649: formateur_fichier_reel(struct_processus *s_etat_processus,
5650: void *valeur_numerique, unsigned char type,
5651: long longueur, long longueur_champ,
5652: unsigned char format_sortie)
5653: {
5654: real8 mantisse;
5655: real8 tampon_reel;
5656:
5657: integer8 tampon_entier;
5658:
5659: long correction;
5660: long exposant;
5661: long longueur_utile;
5662: long longueur_utile_limite;
5663:
5664: unsigned char *chaine;
5665: unsigned char format[16 + 1];
5666: unsigned char mode[3 + 1];
5667: unsigned char tampon[16 + 1];
5668:
5669: unsigned long i;
5670:
5671: chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
5672:
5673: if (chaine == NULL)
5674: {
5675: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5676: return(NULL);
5677: }
5678:
5679: if (type == 'R')
5680: {
5681: tampon_reel = *((real8 *) valeur_numerique);
5682:
5683: if (tampon_reel > ((real8) 0))
5684: {
5685: exposant = (long) floor(log10(tampon_reel));
5686: }
5687: else if (tampon_reel < ((real8) 0))
5688: {
5689: exposant = (long) floor(log10(-tampon_reel));
5690: }
5691: else
5692: {
5693: exposant = 0;
5694: }
5695:
5696: mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
5697: }
5698: else
5699: {
5700: tampon_entier = *((integer8 *) valeur_numerique);
5701:
5702: if (tampon_entier > ((integer8) 0))
5703: {
5704: exposant = (long) floor(log10(tampon_entier));
5705: }
5706: else if (tampon_entier < ((integer8) 0))
5707: {
5708: exposant = (long) floor(log10(-tampon_entier));
5709: }
5710: else
5711: {
5712: exposant = 0;
5713: }
5714:
5715: mantisse = (*((integer8 *) valeur_numerique)) / pow(10, exposant);
5716: }
5717:
5718: longueur_utile = longueur;
5719: longueur_utile_limite = 15;
5720:
5721: if (longueur_utile > longueur_utile_limite)
5722: {
5723: longueur_utile = longueur_utile_limite;
5724: }
5725:
5726: if (format_sortie == 'S')
5727: {
5728: strcpy(mode, "STD");
5729: }
5730: else if (format_sortie == 'C')
5731: {
5732: strcpy(mode, "SCI");
5733: }
5734: else if (format_sortie == 'F')
5735: {
5736: strcpy(mode, "FIX");
5737: }
5738: else
5739: {
5740: strcpy(mode, "ENG");
5741: }
5742:
5743: if ((strcmp(mode, "SCI") == 0) ||
5744: ((strcmp(mode, "STD") == 0) && ((exposant >
5745: longueur_utile_limite) ||
5746: (exposant < -longueur_utile_limite))) ||
5747: ((strcmp(mode, "FIX") == 0) &&
5748: ((exposant >= longueur_utile_limite) ||
5749: (exposant < -longueur_utile))))
5750: {
5751: chaine[0] = 0;
5752: format[0] = 0;
5753:
5754: if (strcmp(mode, "STD") == 0)
5755: {
5756: longueur_utile = longueur_utile_limite - 1;
5757: }
5758:
5759: sprintf(format, "%%.%luf", longueur_utile);
5760:
5761: sprintf(tampon, format, mantisse);
5762: strcpy(chaine, tampon);
5763: strcat(chaine, "E");
5764: sprintf(tampon, "%ld", exposant);
5765: strcat(chaine, tampon);
5766: }
5767: else if (strcmp(mode, "FIX") == 0)
5768: {
5769: chaine[0] = 0;
5770: format[0] = 0;
5771:
5772: if (longueur_utile + exposant >= longueur_utile_limite)
5773: {
5774: longueur_utile = longueur_utile_limite - (exposant + 1);
5775: }
5776:
5777: sprintf(format, "%%.%luf", longueur_utile);
5778:
5779: sprintf(tampon, format, (mantisse * pow(10, exposant)));
5780: strcpy(chaine, tampon);
5781: }
5782: else if (strcmp(mode, "ENG") == 0)
5783: {
5784: chaine[0] = 0;
5785: format[0] = 0;
5786:
5787: correction = labs(exposant) % 3;
5788:
5789: if (exposant < 0)
5790: {
5791: if (correction == 0)
5792: {
5793: correction = 3;
5794: }
5795:
5796: correction = 3 - correction;
5797: }
5798:
5799: longueur_utile -= correction;
5800: sprintf(format, "%%.%luf", longueur_utile);
5801:
5802: sprintf(tampon, format, (mantisse * pow(10, correction)));
5803: strcpy(chaine, tampon);
5804: strcat(chaine, "E");
5805: sprintf(tampon, "%ld", (exposant - correction));
5806: strcat(chaine, tampon);
5807: }
5808: else
5809: {
5810: if (type == 'I')
5811: {
5812: chaine[0] = 0;
5813: sprintf(tampon, "%lld", *((integer8 *) valeur_numerique));
5814: }
5815: else
5816: {
5817: chaine[0] = 0;
5818: format[0] = 0;
5819:
5820: if (exposant >= 0)
5821: {
5822: sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
5823: - 1));
5824: }
5825: else
5826: {
5827: sprintf(format, "%%.%luf", longueur_utile_limite);
5828: }
5829:
5830: sprintf(tampon, format, *((real8 *) valeur_numerique));
5831:
5832: i = strlen(tampon) - 1;
5833: while(tampon[i] == '0')
5834: {
5835: tampon[i] = 0;
5836: i--;
5837: }
5838:
5839: if (ds_imposition_separateur_decimal == d_faux)
5840: {
5841: i = strlen(tampon) - 1;
5842: if (tampon[i] == '.')
5843: {
5844: tampon[i] = 0;
5845: }
5846: }
5847: }
5848:
5849: strcpy(chaine, tampon);
5850: }
5851:
5852: if (longueur_champ >= 0)
5853: {
5854: if (strlen(chaine) > (size_t) longueur_champ)
5855: {
5856: for(i = 0; i < (unsigned long) longueur_champ; i++)
5857: {
5858: chaine[i] = '*';
5859: }
5860:
5861: chaine[i] = d_code_fin_chaine;
5862: }
5863: }
5864:
5865: return(chaine);
5866: }
5867:
5868:
5869: /*
5870: --------------------------------------------------------------------------------
5871: Mêmes fonctions mais pour les fichiers binaires
5872: --------------------------------------------------------------------------------
5873: */
5874:
5875: unsigned char *
5876: formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,
5877: void *valeur_numerique, unsigned char type, long longueur,
5878: long *longueur_conversion)
5879: {
5880: unsigned char *chaine;
5881:
5882: switch(type)
5883: {
5884: default :
5885: case 'I' :
5886: {
5887: switch(longueur)
5888: {
5889: case 1:
5890: {
5891: if ((*((integer8 *) valeur_numerique)) !=
5892: ((integer1) (*((integer8 *) valeur_numerique))))
5893: {
5894: (*s_etat_processus).erreur_execution =
5895: d_ex_representation;
5896: return(NULL);
5897: }
5898:
5899: if ((chaine = malloc(2 * sizeof(unsigned char))) == NULL)
5900: {
5901: (*s_etat_processus).erreur_systeme =
5902: d_es_allocation_memoire;
5903: return(NULL);
5904: }
5905:
5906: (*longueur_conversion) = 2;
5907: chaine[0] = 0x10;
5908: chaine[1] = (*((integer8 *) valeur_numerique)) & 0xFF;
5909: break;
5910: }
5911:
5912: case 2:
5913: {
5914: if ((*((integer8 *) valeur_numerique)) !=
5915: ((integer2) (*((integer8 *) valeur_numerique))))
5916: {
5917: (*s_etat_processus).erreur_execution =
5918: d_ex_representation;
5919: return(NULL);
5920: }
5921:
5922: if ((chaine = malloc(3 * sizeof(unsigned char))) == NULL)
5923: {
5924: (*s_etat_processus).erreur_systeme =
5925: d_es_allocation_memoire;
5926: return(NULL);
5927: }
5928:
5929: (*longueur_conversion) = 3;
5930: chaine[0] = 0x11;
5931: chaine[1] = ((*((integer8 *) valeur_numerique)) >> 8)
5932: & 0xFF;
5933: chaine[2] = (*((integer8 *) valeur_numerique)) & 0xFF;
5934: break;
5935: }
5936:
5937: case 4:
5938: {
5939: if ((*((integer8 *) valeur_numerique)) !=
5940: ((integer2) (*((integer8 *) valeur_numerique))))
5941: {
5942: (*s_etat_processus).erreur_execution =
5943: d_ex_representation;
5944: return(NULL);
5945: }
5946:
5947: if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
5948: {
5949: (*s_etat_processus).erreur_systeme =
5950: d_es_allocation_memoire;
5951: return(NULL);
5952: }
5953:
5954: (*longueur_conversion) = 5;
5955: chaine[0] = 0x12;
5956: chaine[1] = ((*((integer8 *) valeur_numerique)) >> 24)
5957: & 0xFF;
5958: chaine[2] = ((*((integer8 *) valeur_numerique)) >> 16)
5959: & 0xFF;
5960: chaine[3] = ((*((integer8 *) valeur_numerique)) >> 8)
5961: & 0xFF;
5962: chaine[4] = (*((integer8 *) valeur_numerique)) & 0xFF;
5963: break;
5964: }
5965:
5966: case 8:
5967: {
5968: if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
5969: {
5970: (*s_etat_processus).erreur_systeme =
5971: d_es_allocation_memoire;
5972: return(NULL);
5973: }
5974:
5975: (*longueur_conversion) = 9;
5976: chaine[0] = 0x13;
5977: chaine[1] = ((*((integer8 *) valeur_numerique)) >> 56)
5978: & 0xFF;
5979: chaine[2] = ((*((integer8 *) valeur_numerique)) >> 48)
5980: & 0xFF;
5981: chaine[3] = ((*((integer8 *) valeur_numerique)) >> 40)
5982: & 0xFF;
5983: chaine[4] = ((*((integer8 *) valeur_numerique)) >> 32)
5984: & 0xFF;
5985: chaine[5] = ((*((integer8 *) valeur_numerique)) >> 24)
5986: & 0xFF;
5987: chaine[6] = ((*((integer8 *) valeur_numerique)) >> 16)
5988: & 0xFF;
5989: chaine[7] = ((*((integer8 *) valeur_numerique)) >> 8)
5990: & 0xFF;
5991: chaine[8] = (*((integer8 *) valeur_numerique)) & 0xFF;
5992: break;
5993: }
5994:
5995: default :
5996: {
5997: (*s_etat_processus).erreur_execution =
5998: d_ex_erreur_format_fichier;
5999: return(NULL);
6000: }
6001: }
6002:
6003: break;
6004: }
6005:
6006: case 'R' :
6007: {
6008: switch(longueur)
6009: {
6010: case 4:
6011: {
6012: double vinf;
6013: double vsup;
6014:
6015: union
6016: {
6017: real4 r4;
6018: integer4 i4;
6019: } eq4;
6020:
6021: if ((*((real8 *) valeur_numerique)) > 0)
6022: {
6023: vinf = nextafter((*((real8 *) valeur_numerique)), 0);
6024: vsup = nextafter((*((real8 *) valeur_numerique)),
6025: (*((real8 *) valeur_numerique)) * 2);
6026: }
6027: else
6028: {
6029: vinf = nextafter((*((real8 *) valeur_numerique)),
6030: (*((real8 *) valeur_numerique)) * 2);
6031: vsup = nextafter((*((real8 *) valeur_numerique)), 0);
6032: }
6033:
6034: if (!((vinf <= ((real4) (*((real8 *) valeur_numerique)))) &&
6035: ((real4) ((*((real8 *) valeur_numerique)))
6036: <= vsup)))
6037: {
6038: (*s_etat_processus).erreur_execution =
6039: d_ex_representation;
6040: return(NULL);
6041: }
6042:
6043: if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
6044: {
6045: (*s_etat_processus).erreur_systeme =
6046: d_es_allocation_memoire;
6047: return(NULL);
6048: }
6049:
6050: eq4.r4 = (real4) (*((real8 *) valeur_numerique));
6051: (*longueur_conversion) = 5;
6052: chaine[0] = 0x12;
6053: chaine[1] = (eq4.i4 >> 24) & 0xFF;
6054: chaine[2] = (eq4.i4 >> 16) & 0xFF;
6055: chaine[3] = (eq4.i4 >> 8) & 0xFF;
6056: chaine[4] = eq4.i4 & 0xFF;
6057: break;
6058: }
6059:
6060: case 8:
6061: {
6062: union
6063: {
6064: real8 r8;
6065: integer8 i8;
6066: } eq8;
6067:
6068: if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
6069: {
6070: (*s_etat_processus).erreur_systeme =
6071: d_es_allocation_memoire;
6072: return(NULL);
6073: }
6074:
6075: eq8.r8 = (*((real8 *) valeur_numerique));
6076:
6077: (*longueur_conversion) = 9;
6078: chaine[0] = 0x13;
6079: chaine[1] = (eq8.i8 >> 56) & 0xFF;
6080: chaine[2] = (eq8.i8 >> 48) & 0xFF;
6081: chaine[3] = (eq8.i8 >> 40) & 0xFF;
6082: chaine[4] = (eq8.i8 >> 32) & 0xFF;
6083: chaine[5] = (eq8.i8 >> 24) & 0xFF;
6084: chaine[6] = (eq8.i8 >> 16) & 0xFF;
6085: chaine[7] = (eq8.i8 >> 8) & 0xFF;
6086: chaine[8] = eq8.i8 & 0xFF;
6087: break;
6088: }
6089:
6090: default :
6091: {
6092: (*s_etat_processus).erreur_execution =
6093: d_ex_erreur_format_fichier;
6094: return(NULL);
6095: }
6096: }
6097:
6098: break;
6099: }
6100:
6101: case 'C' :
6102: {
6103: switch(longueur)
6104: {
6105: case 8:
6106: {
6107: unsigned char *partie_reelle;
6108: unsigned char *partie_imaginaire;
6109:
6110: long limag;
6111: long lreel;
6112:
6113: if ((partie_reelle = formateur_fichier_binaire_nombre(
6114: s_etat_processus, &((*((complex16 *)
6115: valeur_numerique)).partie_reelle), 'R', 4, &lreel))
6116: == NULL)
6117: {
6118: return(NULL);
6119: }
6120:
6121: if ((partie_imaginaire = formateur_fichier_binaire_nombre(
6122: s_etat_processus, &((*((complex16 *)
6123: valeur_numerique)).partie_imaginaire), 'R', 4,
6124: &limag)) == NULL)
6125: {
6126: free(partie_reelle);
6127: return(NULL);
6128: }
6129:
6130: if ((chaine = malloc((lreel + limag - 1) *
6131: sizeof(unsigned char))) == NULL)
6132: {
6133: free(partie_reelle);
6134: free(partie_imaginaire);
6135:
6136: (*s_etat_processus).erreur_systeme =
6137: d_es_allocation_memoire;
6138: return(NULL);
6139: }
6140:
6141: chaine[0] = 0x18;
6142: memcpy(chaine + 1, partie_reelle + 1, lreel - 1);
6143: memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);
6144: (*longueur_conversion) = lreel + limag - 1;
6145:
6146: free(partie_reelle);
6147: free(partie_imaginaire);
6148: break;
6149: }
6150:
6151: case 16:
6152: {
6153: unsigned char *partie_reelle;
6154: unsigned char *partie_imaginaire;
6155:
6156: long limag;
6157: long lreel;
6158:
6159: if ((partie_reelle = formateur_fichier_binaire_nombre(
6160: s_etat_processus, &((*((complex16 *)
6161: valeur_numerique)).partie_reelle), 'R', 8, &lreel))
6162: == NULL)
6163: {
6164: return(NULL);
6165: }
6166:
6167: if ((partie_imaginaire = formateur_fichier_binaire_nombre(
6168: s_etat_processus, &((*((complex16 *)
6169: valeur_numerique)).partie_imaginaire), 'R', 8,
6170: &limag)) == NULL)
6171: {
6172: free(partie_reelle);
6173: return(NULL);
6174: }
6175:
6176: if ((chaine = malloc((lreel + limag - 1) *
6177: sizeof(unsigned char))) == NULL)
6178: {
6179: free(partie_reelle);
6180: free(partie_imaginaire);
6181:
6182: (*s_etat_processus).erreur_systeme =
6183: d_es_allocation_memoire;
6184: return(NULL);
6185: }
6186:
6187: chaine[0] = 0x19;
6188: memcpy(chaine + 1, partie_reelle + 1, lreel - 1);
6189: memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);
6190: (*longueur_conversion) = lreel + limag - 1;
6191:
6192: free(partie_reelle);
6193: free(partie_imaginaire);
6194: break;
6195: }
6196:
6197: default :
6198: {
6199: (*s_etat_processus).erreur_execution =
6200: d_ex_erreur_format_fichier;
6201: return(NULL);
6202: }
6203: }
6204:
6205: break;
6206: }
6207: }
6208:
6209: return(chaine);
6210: }
6211:
6212: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to formateur_fichiers.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src