1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.11
4: Copyright (C) 1989-2012 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Routine de formation des données pour l'écriture dans les fichiers
29: ================================================================================
30: Entrées : structure sur l'état du processus et objet à afficher
31: Longueur est la précision requise et longueur_champ, le nombre maximal
32: de caractères de la chaîne résultat (-1 signifiant une absence de contrainte)
33: Type = 'F/U' (formaté, non formaté)
34: --------------------------------------------------------------------------------
35: Sorties : chaine de caractères et longueur du tableau de caractères
36: --------------------------------------------------------------------------------
37: Effets de bord : néant
38: ================================================================================
39: */
40:
41: unsigned char *
42: formateur_fichier(struct_processus *s_etat_processus, struct_objet *s_objet,
43: struct_objet *s_format, long longueur, long longueur_champ,
44: unsigned char format_sortie, unsigned char type,
45: long *longueur_effective, long *recursivite)
46: {
47: /*
48: * Traitement du format des fichiers formatés :
49: *
50: * { "standard*(*)" (format classique sans limitation)
51: * "standard*(Y)" (format classique limité à Y caractères)
52: * "fixed*X(*)" (format virgule fixe avec une partie
53: * fractionnaire composée de X chiffres,
54: * mais dont la longueur est limité par
55: * la précision de la représentation interne)
56: * "fixed*X(Y)" (idem, mais longueur totale inférieure ou égale à
57: * Y caractères)
58: * "scientific*X(*)"
59: * "scientific*X(Y)"
60: * "engineer*X(*)"
61: * "engineer*X(Y)"
62: * "binary*X(*)"
63: * "binary*X(Y)" (X est la base : 2, 8, 10, 16)
64: * "character*(*)"
65: * "character*(Y)" }
66: *
67: * Traitement du format des fichiers non formatés :
68: *
69: * { "integer*1", "integer*2", "integer*4", "integer*8",
70: * "real*4", "real*8", ["real*16",]
71: * "complex*8", "complex*16", ["complex*32",]
72: * "logical*1", "logical*2", "logical*4", logical*8",
73: * "character" }
74: */
75:
76: logical1 autorisation_parenthese;
77: logical1 format_degenere;
78: logical1 presence_signe;
79:
80: struct_liste_chainee *l_atome;
81: struct_liste_chainee *l_element_courant;
82: struct_liste_chainee *l_element_courant_format;
83: struct_liste_chainee *l_liste1;
84: struct_liste_chainee *l_liste2;
85:
86: struct_objet *s_sous_objet;
87: struct_objet *s_sous_objet_1;
88: struct_objet *s_sous_objet_2;
89: struct_objet *s_sous_objet_3;
90:
91: unsigned char base[1 + 1];
92: unsigned char *chaine;
93: unsigned char *chaine_fonction;
94: unsigned char *chaine_formatee;
95: unsigned char *chaine_tampon;
96: unsigned char *chaine_sauvegarde;
97: unsigned char *format_chaine;
98: unsigned char *ptre;
99: unsigned char *ptrl;
100: unsigned char tampon[64 + 1];
101:
102: unsigned long i;
103: unsigned long j;
104: unsigned long nombre_arguments;
105: unsigned long nombre_arguments_fonction;
106: unsigned long nombre_colonnes;
107: unsigned long nombre_elements;
108: unsigned long nombre_lignes;
109:
110: integer8 longueur_liste;
111: integer8 longueur_totale;
112: integer8 masque_binaire;
113: integer8 position_1;
114: integer8 position_2;
115: integer8 position_3;
116:
117: (*recursivite)++;
118:
119: if (type == 'F')
120: {
121: /*
122: * Fichiers formatés
123: */
124:
125: chaine = NULL;
126: chaine_formatee = NULL;
127: chaine_sauvegarde = NULL;
128:
129: strcpy(base, " ");
130:
131: masque_binaire = 0;
132:
133: if ((*s_objet).type == ALG)
134: {
135:
136: /*
137: --------------------------------------------------------------------------------
138: Expression algébrique
139: --------------------------------------------------------------------------------
140: */
141:
142: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
143:
144: while(l_element_courant != NULL)
145: {
146: if ((*(*l_element_courant).donnee).type == FCT)
147: {
148: if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
149: .donnee).objet)).nom_fonction, "<<") != 0) &&
150: (strcmp((*((struct_fonction *)
151: (*(*l_element_courant)
152: .donnee).objet)).nom_fonction, ">>") != 0))
153: {
154: if ((strcmp((*((struct_fonction *)
155: (*(*l_element_courant)
156: .donnee).objet)).nom_fonction, "+") == 0) ||
157: (strcmp((*((struct_fonction *)
158: (*(*l_element_courant).donnee).objet))
159: .nom_fonction, "-") == 0) || (strcmp(
160: (*((struct_fonction *) (*(*l_element_courant)
161: .donnee).objet)).nom_fonction, "*") == 0) ||
162: (strcmp((*((struct_fonction *)
163: (*(*l_element_courant).donnee).objet))
164: .nom_fonction,
165: "/") == 0) || (strcmp((*((struct_fonction *)
166: (*(*l_element_courant).donnee).objet))
167: .nom_fonction,
168: "^") == 0) || (strcmp((*((struct_fonction *)
169: (*(*l_element_courant).donnee).objet))
170: .nom_fonction,
171: "<") == 0) || (strcmp((*((struct_fonction *)
172: (*(*l_element_courant).donnee).objet))
173: .nom_fonction,
174: ">") == 0) || (strcmp((*((struct_fonction *)
175: (*(*l_element_courant).donnee).objet))
176: .nom_fonction,
177: "==") == 0) || (strcmp((*((struct_fonction *)
178: (*(*l_element_courant).donnee).objet))
179: .nom_fonction,
180: "<>") == 0) || (strcmp((*((struct_fonction *)
181: (*(*l_element_courant).donnee).objet))
182: .nom_fonction,
183: "<=") == 0) || (strcmp((*((struct_fonction *)
184: (*(*l_element_courant).donnee).objet))
185: .nom_fonction,
186: "=<") == 0) || (strcmp((*((struct_fonction *)
187: (*(*l_element_courant).donnee).objet))
188: .nom_fonction,
189: ">=") == 0) || (strcmp((*((struct_fonction *)
190: (*(*l_element_courant).donnee).objet))
191: .nom_fonction,
192: "=>") == 0))
193: {
194: if (depilement(s_etat_processus,
195: &((*s_etat_processus)
196: .l_base_pile), &s_sous_objet_2) == d_erreur)
197: {
198: return(NULL);
199: }
200:
201: chaine_sauvegarde = (*s_etat_processus)
202: .instruction_courante;
203:
204: if (((*s_etat_processus).instruction_courante =
205: (unsigned char *) malloc((strlen(
206: (unsigned char *) (*s_sous_objet_2).objet)
207: + 2 + 1) * sizeof(unsigned char))) == NULL)
208: {
209: (*s_etat_processus).instruction_courante =
210: chaine_sauvegarde;
211: (*s_etat_processus).erreur_systeme =
212: d_es_allocation_memoire;
213: return(NULL);
214: }
215:
216: sprintf((*s_etat_processus).instruction_courante,
217: "'%s'", (unsigned char *)
218: (*s_sous_objet_2).objet);
219:
220: presence_signe = (((*s_etat_processus)
221: .instruction_courante[1] == '+')
222: || ((*s_etat_processus)
223: .instruction_courante[1]
224: == '-')) ? d_vrai : d_faux;
225:
226: recherche_type(s_etat_processus);
227:
228: if ((*s_etat_processus).erreur_execution != d_ex)
229: {
230: // Aucune erreur ne peut être renvoyée.
231:
232: return(NULL);
233: }
234:
235: if (depilement(s_etat_processus,
236: &((*s_etat_processus)
237: .l_base_pile), &s_sous_objet_3) == d_erreur)
238: {
239: return(NULL);
240: }
241:
242: free((*s_etat_processus).instruction_courante);
243:
244: (*s_etat_processus).instruction_courante =
245: chaine_sauvegarde;
246:
247: autorisation_parenthese = d_faux;
248:
249: if ((*s_sous_objet_3).type == ALG)
250: {
251: l_atome = (struct_liste_chainee *)
252: (*s_sous_objet_3).objet;
253: chaine_fonction = "";
254: nombre_arguments_fonction = 0;
255:
256: while(l_atome != NULL)
257: {
258: if ((*(*l_atome).donnee).type == FCT)
259: {
260: if (strcmp((*((struct_fonction *)
261: (*(*l_atome).donnee).objet))
262: .nom_fonction, ">>") != 0)
263: {
264: chaine_fonction =
265: (*((struct_fonction *)
266: (*(*l_atome).donnee).objet))
267: .nom_fonction;
268: nombre_arguments_fonction =
269: (*((struct_fonction *)
270: (*(*l_atome).donnee).objet))
271: .nombre_arguments;
272: }
273: }
274:
275: l_atome = (*l_atome).suivant;
276: }
277:
278: if (strcmp((*((struct_fonction *)
279: (*(*l_element_courant).donnee).objet))
280: .nom_fonction, "+") == 0)
281: {
282: if ((strcmp(chaine_fonction, "AND") == 0) ||
283: (strcmp(chaine_fonction, "XOR") ==
284: 0) || (strcmp(chaine_fonction, "OR")
285: == 0))
286: {
287: autorisation_parenthese = d_vrai;
288: }
289: }
290: else if (strcmp((*((struct_fonction *)
291: (*(*l_element_courant).donnee).objet))
292: .nom_fonction, "-") == 0)
293: {
294: if (nombre_arguments_fonction != 0)
295: {
296: autorisation_parenthese = d_faux;
297: }
298: else
299: {
300: autorisation_parenthese = d_vrai;
301: }
302: }
303: else if (strcmp((*((struct_fonction *)
304: (*(*l_element_courant).donnee).objet))
305: .nom_fonction, "*") == 0)
306: {
307: if ((strcmp(chaine_fonction, "+") == 0) ||
308: (strcmp(chaine_fonction, "-") == 0)
309: || (strcmp(chaine_fonction, "AND")
310: == 0) || (strcmp(chaine_fonction,
311: "XOR") == 0) || (strcmp(
312: chaine_fonction, "OR") == 0))
313: {
314: autorisation_parenthese = d_vrai;
315: }
316: }
317: else if (strcmp((*((struct_fonction *)
318: (*(*l_element_courant).donnee).objet))
319: .nom_fonction, "/") == 0)
320: {
321: if (nombre_arguments_fonction != 0)
322: {
323: autorisation_parenthese = d_faux;
324: }
325: else
326: {
327: autorisation_parenthese = d_vrai;
328: }
329: }
330: else if ((strcmp((*((struct_fonction *)
331: (*(*l_element_courant).donnee).objet))
332: .nom_fonction, "^") == 0))
333: {
334: if (nombre_arguments_fonction != 0)
335: {
336: autorisation_parenthese = d_faux;
337: }
338: else
339: {
340: autorisation_parenthese = d_vrai;
341: }
342: }
343: }
344:
345: if ((autorisation_parenthese == d_vrai) ||
346: (presence_signe == d_vrai))
347: {
348: chaine_sauvegarde = (unsigned char *)
349: (*s_sous_objet_2).objet;
350:
351: if (((*s_sous_objet_2).objet = (void *)
352: malloc((strlen(chaine_sauvegarde) + 2
353: + 1) * sizeof(unsigned char))) == NULL)
354: {
355: (*s_etat_processus).erreur_systeme =
356: d_es_allocation_memoire;
357: return(NULL);
358: }
359:
360: sprintf((unsigned char *) (*s_sous_objet_2)
361: .objet, "(%s)", chaine_sauvegarde);
362: free(chaine_sauvegarde);
363: }
364:
365: liberation(s_etat_processus, s_sous_objet_3);
366:
367: if (depilement(s_etat_processus,
368: &((*s_etat_processus)
369: .l_base_pile), &s_sous_objet_1) == d_erreur)
370: {
371: return(NULL);
372: }
373:
374: chaine_sauvegarde = (*s_etat_processus)
375: .instruction_courante;
376:
377: if (((*s_etat_processus).instruction_courante =
378: (unsigned char *) malloc((strlen(
379: (unsigned char *) (*s_sous_objet_1).objet)
380: + 2 + 1) * sizeof(unsigned char))) == NULL)
381: {
382: (*s_etat_processus).instruction_courante =
383: chaine_sauvegarde;
384: (*s_etat_processus).erreur_systeme =
385: d_es_allocation_memoire;
386: return(NULL);
387: }
388:
389: sprintf((*s_etat_processus).instruction_courante,
390: "'%s'", (unsigned char *)
391: (*s_sous_objet_1).objet);
392:
393: recherche_type(s_etat_processus);
394:
395: if ((*s_etat_processus).erreur_execution != d_ex)
396: {
397: // Aucune erreur ne peut être renvoyée.
398:
399: return(NULL);
400: }
401:
402: if (depilement(s_etat_processus,
403: &((*s_etat_processus)
404: .l_base_pile), &s_sous_objet_3) == d_erreur)
405: {
406: return(NULL);
407: }
408:
409: free((*s_etat_processus).instruction_courante);
410:
411: (*s_etat_processus).instruction_courante =
412: chaine_sauvegarde;
413:
414: autorisation_parenthese = d_faux;
415:
416: if ((*s_sous_objet_3).type == ALG)
417: {
418: l_atome = (struct_liste_chainee *)
419: (*s_sous_objet_3).objet;
420: chaine_fonction = "";
421:
422: while(l_atome != NULL)
423: {
424: if ((*(*l_atome).donnee).type == FCT)
425: {
426: if (strcmp((*((struct_fonction *)
427: (*(*l_atome).donnee).objet))
428: .nom_fonction, ">>") != 0)
429: {
430: chaine_fonction =
431: (*((struct_fonction *)
432: (*(*l_atome).donnee).objet))
433: .nom_fonction;
434: }
435: }
436:
437: l_atome = (*l_atome).suivant;
438: }
439:
440: if ((strcmp((*((struct_fonction *)
441: (*(*l_element_courant).donnee).objet))
442: .nom_fonction, "+") == 0) ||
443: (strcmp((*((struct_fonction *)
444: (*(*l_element_courant).donnee).objet))
445: .nom_fonction, "-") == 0))
446: {
447: if ((strcmp(chaine_fonction, "AND") == 0) ||
448: (strcmp(chaine_fonction, "XOR") ==
449: 0) || (strcmp(chaine_fonction, "OR")
450: == 0))
451: {
452: autorisation_parenthese = d_vrai;
453: }
454: }
455: else if ((strcmp((*((struct_fonction *)
456: (*(*l_element_courant).donnee).objet))
457: .nom_fonction, "*") == 0) ||
458: (strcmp((*((struct_fonction *)
459: (*(*l_element_courant).donnee).objet))
460: .nom_fonction, "/") == 0))
461: {
462: if ((strcmp(chaine_fonction, "+") == 0) ||
463: (strcmp(chaine_fonction, "-") == 0)
464: || (strcmp(chaine_fonction, "AND")
465: == 0) || (strcmp(chaine_fonction,
466: "XOR") == 0) || (strcmp(
467: chaine_fonction, "OR") == 0))
468: {
469: autorisation_parenthese = d_vrai;
470: }
471: }
472: else if ((strcmp((*((struct_fonction *)
473: (*(*l_element_courant).donnee).objet))
474: .nom_fonction, "^") == 0))
475: {
476: autorisation_parenthese = d_vrai;
477: }
478: }
479:
480: if (autorisation_parenthese == d_vrai)
481: {
482: chaine_sauvegarde = (unsigned char *)
483: (*s_sous_objet_1).objet;
484:
485: if (((*s_sous_objet_1).objet = (void *)
486: malloc((strlen(chaine_sauvegarde) + 2
487: + 1) * sizeof(unsigned char))) == NULL)
488: {
489: (*s_etat_processus).erreur_systeme =
490: d_es_allocation_memoire;
491: return(NULL);
492: }
493:
494: sprintf((unsigned char *) (*s_sous_objet_1)
495: .objet, "(%s)", chaine_sauvegarde);
496: free(chaine_sauvegarde);
497: }
498:
499: liberation(s_etat_processus, s_sous_objet_3);
500:
501: if ((s_sous_objet = allocation(s_etat_processus,
502: CHN)) == NULL)
503: {
504: (*s_etat_processus).erreur_systeme =
505: d_es_allocation_memoire;
506: return(NULL);
507: }
508:
509: if (((*s_sous_objet).objet = (void *)
510: malloc((strlen(
511: (unsigned char *) (*s_sous_objet_1).objet) +
512: strlen((*((struct_fonction *)
513: (*(*l_element_courant).donnee).objet))
514: .nom_fonction) + strlen((unsigned char *)
515: (*s_sous_objet_2).objet) + 1) *
516: sizeof(unsigned char))) == NULL)
517: {
518: (*s_etat_processus).erreur_systeme =
519: d_es_allocation_memoire;
520: return(NULL);
521: }
522:
523: sprintf((unsigned char *) (*s_sous_objet).objet,
524: "%s%s%s", (unsigned char *)
525: (*s_sous_objet_1)
526: .objet, (*((struct_fonction *)
527: (*(*l_element_courant).donnee).objet))
528: .nom_fonction, (unsigned char *)
529: (*s_sous_objet_2).objet);
530:
531: liberation(s_etat_processus, s_sous_objet_1);
532: liberation(s_etat_processus, s_sous_objet_2);
533:
534: if (empilement(s_etat_processus,
535: &((*s_etat_processus)
536: .l_base_pile), s_sous_objet) == d_erreur)
537: {
538: return(NULL);
539: }
540: }
541: else if (strcmp((*((struct_fonction *)
542: (*(*l_element_courant).donnee).objet))
543: .nom_fonction, "=") == 0)
544: {
545: if (depilement(s_etat_processus,
546: &((*s_etat_processus).l_base_pile),
547: &s_sous_objet_2) == d_erreur)
548: {
549: return(NULL);
550: }
551:
552: if (depilement(s_etat_processus,
553: &((*s_etat_processus).l_base_pile),
554: &s_sous_objet_1) == d_erreur)
555: {
556: return(NULL);
557: }
558:
559: if ((s_sous_objet = allocation(s_etat_processus,
560: CHN)) == NULL)
561: {
562: (*s_etat_processus).erreur_systeme =
563: d_es_allocation_memoire;
564: return(NULL);
565: }
566:
567: autorisation_parenthese = d_vrai;
568: l_atome = l_element_courant;
569:
570: if (l_atome != NULL)
571: {
572: if ((*l_atome).suivant != NULL)
573: {
574: l_atome = (*l_atome).suivant;
575:
576: if ((*(*l_atome).donnee).type == FCT)
577: {
578: if (strcmp((*((struct_fonction *)
579: (*(*l_atome).donnee).objet))
580: .nom_fonction, ">>") == 0)
581: {
582: if ((*l_atome).suivant == NULL)
583: {
584: autorisation_parenthese =
585: d_faux;
586: }
587: }
588: }
589: }
590: }
591:
592: if (autorisation_parenthese == d_vrai)
593: {
594: if (((*s_sous_objet).objet =
595: (void *) malloc((strlen(
596: (unsigned char *) (*s_sous_objet_1)
597: .objet) + strlen((*((struct_fonction *)
598: (*(*l_element_courant).donnee).objet))
599: .nom_fonction) +
600: strlen((unsigned char *)
601: (*s_sous_objet_2).objet) + 2 + 1) *
602: sizeof(unsigned char))) == NULL)
603: {
604: (*s_etat_processus).erreur_systeme =
605: d_es_allocation_memoire;
606: return(NULL);
607: }
608:
609: sprintf((unsigned char *) (*s_sous_objet).objet,
610: "(%s%s%s)", (unsigned char *)
611: (*s_sous_objet_1)
612: .objet, (*((struct_fonction *)
613: (*(*l_element_courant).donnee).objet))
614: .nom_fonction, (unsigned char *)
615: (*s_sous_objet_2).objet);
616: }
617: else
618: {
619: if (((*s_sous_objet).objet =
620: (void *) malloc((strlen(
621: (unsigned char *) (*s_sous_objet_1)
622: .objet) + strlen((*((struct_fonction *)
623: (*(*l_element_courant).donnee).objet))
624: .nom_fonction) + strlen(
625: (unsigned char *) (*s_sous_objet_2)
626: .objet) + 1) * sizeof(unsigned char)))
627: == NULL)
628: {
629: (*s_etat_processus).erreur_systeme =
630: d_es_allocation_memoire;
631: return(NULL);
632: }
633:
634: sprintf((unsigned char *) (*s_sous_objet).objet,
635: "%s%s%s", (unsigned char *)
636: (*s_sous_objet_1)
637: .objet, (*((struct_fonction *)
638: (*(*l_element_courant).donnee).objet))
639: .nom_fonction, (unsigned char *)
640: (*s_sous_objet_2).objet);
641: }
642:
643: liberation(s_etat_processus, s_sous_objet_1);
644: liberation(s_etat_processus, s_sous_objet_2);
645:
646: if (empilement(s_etat_processus,
647: &((*s_etat_processus).l_base_pile),
648: s_sous_objet) == d_erreur)
649: {
650: return(NULL);
651: }
652: }
653: else if (strcmp((*((struct_fonction *)
654: (*(*l_element_courant).donnee).objet))
655: .nom_fonction,
656: "NOT") == 0)
657: {
658: if (depilement(s_etat_processus,
659: &((*s_etat_processus)
660: .l_base_pile), &s_sous_objet_1) == d_erreur)
661: {
662: return(NULL);
663: }
664:
665: if ((s_sous_objet = allocation(s_etat_processus,
666: CHN)) == NULL)
667: {
668: (*s_etat_processus).erreur_systeme =
669: d_es_allocation_memoire;
670: return(NULL);
671: }
672:
673: if (((*s_sous_objet).objet = (unsigned char *)
674: malloc(
675: (strlen((unsigned char *) (*s_sous_objet_1)
676: .objet) + 4 + 1) * sizeof(unsigned char)))
677: == NULL)
678: {
679: (*s_etat_processus).erreur_systeme =
680: d_es_allocation_memoire;
681: return(NULL);
682: }
683:
684: sprintf((unsigned char *) (*s_sous_objet).objet,
685: "%s %s", (*((struct_fonction *)
686: (*(*l_element_courant).donnee).objet))
687: .nom_fonction, (unsigned char *)
688: (*s_sous_objet_1).objet );
689:
690: liberation(s_etat_processus, s_sous_objet_1);
691:
692: if (empilement(s_etat_processus,
693: &((*s_etat_processus)
694: .l_base_pile), s_sous_objet) == d_erreur)
695: {
696: return(NULL);
697: }
698: }
699: else if ((strcmp((*((struct_fonction *)
700: (*(*l_element_courant).donnee).objet))
701: .nom_fonction,
702: "OR") == 0) || (strcmp((*((struct_fonction *)
703: (*(*l_element_courant).donnee).objet))
704: .nom_fonction,
705: "XOR") == 0) || (strcmp((*((struct_fonction *)
706: (*(*l_element_courant).donnee).objet))
707: .nom_fonction,
708: "AND") == 0))
709: {
710: if (depilement(s_etat_processus,
711: &((*s_etat_processus)
712: .l_base_pile), &s_sous_objet_2) == d_erreur)
713: {
714: return(NULL);
715: }
716:
717: if (depilement(s_etat_processus,
718: &((*s_etat_processus)
719: .l_base_pile), &s_sous_objet_1) == d_erreur)
720: {
721: return(NULL);
722: }
723:
724: if ((s_sous_objet = allocation(s_etat_processus,
725: CHN)) == NULL)
726: {
727: (*s_etat_processus).erreur_systeme =
728: d_es_allocation_memoire;
729: return(NULL);
730: }
731:
732: if (((*s_sous_objet).objet = (void *)
733: malloc((strlen(
734: (unsigned char *) (*s_sous_objet_1).objet) +
735: strlen((*((struct_fonction *)
736: (*(*l_element_courant).donnee).objet))
737: .nom_fonction) + strlen((unsigned char *)
738: (*s_sous_objet_2).objet) + 2 + 1) *
739: sizeof(unsigned char))) == NULL)
740: {
741: (*s_etat_processus).erreur_systeme =
742: d_es_allocation_memoire;
743: return(NULL);
744: }
745:
746: sprintf((unsigned char *) (*s_sous_objet).objet,
747: "%s %s %s", (unsigned char *)
748: (*s_sous_objet_1)
749: .objet, (*((struct_fonction *)
750: (*(*l_element_courant).donnee).objet))
751: .nom_fonction, (unsigned char *)
752: (*s_sous_objet_2).objet);
753:
754: liberation(s_etat_processus, s_sous_objet_1);
755: liberation(s_etat_processus, s_sous_objet_2);
756:
757: if (empilement(s_etat_processus,
758: &((*s_etat_processus)
759: .l_base_pile), s_sous_objet) == d_erreur)
760: {
761: return(NULL);
762: }
763: }
764: else
765: {
766: nombre_arguments = (*((struct_fonction *)
767: (*(*l_element_courant).donnee).objet))
768: .nombre_arguments;
769:
770: if ((chaine = (unsigned char *)
771: malloc(sizeof(unsigned char))) == NULL)
772: {
773: (*s_etat_processus).erreur_systeme =
774: d_es_allocation_memoire;
775: return(NULL);
776: }
777:
778: chaine[0] = d_code_fin_chaine;
779:
780: for(i = 0; i < nombre_arguments; i++)
781: {
782: if ((nombre_arguments - i) > 1)
783: {
784: l_liste1 = (*s_etat_processus).l_base_pile;
785:
786: for(j = 2; j < (nombre_arguments - i); j++)
787: {
788: l_liste1 = (*l_liste1).suivant;
789: }
790:
791: l_liste2 = (*l_liste1).suivant;
792: (*l_liste1).suivant = (*l_liste2).suivant;
793: (*l_liste2).suivant = (*s_etat_processus)
794: .l_base_pile;
795: (*s_etat_processus).l_base_pile = l_liste2;
796: }
797:
798: if (depilement(s_etat_processus,
799: &((*s_etat_processus).l_base_pile),
800: &s_sous_objet) == d_erreur)
801: {
802: return(NULL);
803: }
804:
805: chaine_sauvegarde = chaine;
806:
807: if (strlen(chaine_sauvegarde) == 0)
808: {
809: if ((chaine = (unsigned char *)
810: malloc((strlen((unsigned char *)
811: (*s_sous_objet).objet) + 1) *
812: sizeof(unsigned char))) == NULL)
813: {
814: (*s_etat_processus).erreur_systeme =
815: d_es_allocation_memoire;
816: return(NULL);
817: }
818:
819: sprintf(chaine, "%s", (unsigned char *)
820: (*s_sous_objet).objet);
821: }
822: else
823: {
824: if ((chaine = (unsigned char *)
825: malloc((strlen(chaine_sauvegarde)
826: + 1 + strlen((unsigned char *)
827: (*s_sous_objet).objet) + 1) *
828: sizeof(unsigned char))) == NULL)
829: {
830: (*s_etat_processus).erreur_systeme =
831: d_es_allocation_memoire;
832: return(NULL);
833: }
834:
835: sprintf(chaine, "%s,%s", chaine_sauvegarde,
836: (unsigned char *) (*s_sous_objet)
837: .objet);
838: }
839:
840: free(chaine_sauvegarde);
841: liberation(s_etat_processus, s_sous_objet);
842: }
843:
844: chaine_sauvegarde = chaine;
845:
846: if ((chaine = (unsigned char *) malloc((strlen(
847: (*((struct_fonction *)
848: (*(*l_element_courant)
849: .donnee).objet)).nom_fonction) + 2 +
850: strlen(chaine_sauvegarde) + 1) *
851: sizeof(unsigned char))) == NULL)
852: {
853: (*s_etat_processus).erreur_systeme =
854: d_es_allocation_memoire;
855: return(NULL);
856: }
857:
858: sprintf(chaine, "%s(%s)", (*((struct_fonction *)
859: (*(*l_element_courant).donnee).objet))
860: .nom_fonction, chaine_sauvegarde);
861: free(chaine_sauvegarde);
862:
863: if ((s_sous_objet = allocation(s_etat_processus,
864: CHN)) == NULL)
865: {
866: (*s_etat_processus).erreur_systeme =
867: d_es_allocation_memoire;
868: return(NULL);
869: }
870:
871: (*s_sous_objet).objet = (void *) chaine;
872:
873: if (empilement(s_etat_processus,
874: &((*s_etat_processus)
875: .l_base_pile), s_sous_objet) == d_erreur)
876: {
877: return(NULL);
878: }
879: }
880: }
881: }
882: else
883: {
884: if ((s_sous_objet = allocation(s_etat_processus, CHN))
885: == NULL)
886: {
887: (*s_etat_processus).erreur_systeme =
888: d_es_allocation_memoire;
889: return(NULL);
890: }
891:
892: if (((*s_sous_objet).objet = (void *) formateur_fichier(
893: s_etat_processus, (*l_element_courant).donnee,
894: s_format, longueur, longueur_champ, format_sortie,
895: type, longueur_effective, recursivite)) == NULL)
896: {
897: (*s_etat_processus).erreur_systeme =
898: d_es_allocation_memoire;
899: return(NULL);
900: }
901:
902: if (((*(*l_element_courant).donnee).type == ALG)
903: || ((*(*l_element_courant).donnee).type == NOM))
904: {
905: chaine_sauvegarde = (unsigned char *)
906: (*s_sous_objet).objet;
907:
908: if (((*s_sous_objet).objet = malloc((strlen(
909: chaine_sauvegarde) - 1) *
910: sizeof(unsigned char))) == NULL)
911: {
912: (*s_etat_processus).erreur_systeme =
913: d_es_allocation_memoire;
914: return(NULL);
915: }
916:
917: ptrl = chaine_sauvegarde;
918: ptre = (unsigned char *) (*s_sous_objet).objet;
919:
920: for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;
921: i--, *ptre++ = *ptrl++);
922:
923: (*ptre) = d_code_fin_chaine;
924:
925: free(chaine_sauvegarde);
926: }
927: else if ((*(*l_element_courant).donnee).type == CHN)
928: {
929: chaine_sauvegarde = (unsigned char *)
930: (*s_sous_objet).objet;
931:
932: if (((*s_sous_objet).objet = malloc((strlen(
933: chaine_sauvegarde) + 3) *
934: sizeof(unsigned char))) == NULL)
935: {
936: (*s_etat_processus).erreur_systeme =
937: d_es_allocation_memoire;
938: return(NULL);
939: }
940:
941: sprintf((unsigned char *) (*s_sous_objet).objet,
942: "\"%s\"", chaine_sauvegarde);
943:
944: free(chaine_sauvegarde);
945: }
946:
947: if (empilement(s_etat_processus, &((*s_etat_processus)
948: .l_base_pile), s_sous_objet) == d_erreur)
949: {
950: return(NULL);
951: }
952: }
953:
954: l_element_courant = (*l_element_courant).suivant;
955: }
956:
957: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
958: &s_sous_objet) == d_erreur)
959: {
960: return(NULL);
961: }
962:
963: if ((chaine = (unsigned char *) malloc((strlen((unsigned char *)
964: (*s_sous_objet).objet) + 2 + 1) * sizeof(unsigned char)))
965: == NULL)
966: {
967: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
968: return(NULL);
969: }
970:
971: sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet);
972: liberation(s_etat_processus, s_sous_objet);
973: }
974: else if ((*s_objet).type == BIN)
975: {
976:
977: /*
978: --------------------------------------------------------------------------------
979: Entier binaire en base 2, 8, 10 ou 16
980: --------------------------------------------------------------------------------
981: */
982:
983: if (format_sortie != 'B')
984: {
985: (*s_etat_processus).erreur_execution =
986: d_ex_erreur_format_fichier;
987: return(NULL);
988: }
989:
990: masque_binaire = masque_entiers_binaires(s_etat_processus);
991:
992: if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
993: (test_cfsf(s_etat_processus, 44) == d_faux))
994: {
995:
996: /*
997: -- Base décimale ---------------------------------------------------------------
998: */
999:
1000: sprintf(tampon, "%llu", (*((logical8 *)
1001: ((*s_objet).objet))) & masque_binaire);
1002: strcpy(base, "d");
1003: }
1004: else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&
1005: (test_cfsf(s_etat_processus, 44) == d_faux))
1006: {
1007:
1008: /*
1009: -- Base octale -----------------------------------------------------------------
1010: */
1011:
1012: sprintf(tampon, "%llo", (*((logical8 *)
1013: ((*s_objet).objet))) & masque_binaire);
1014: strcpy(base, "o");
1015: }
1016: else if (test_cfsf(s_etat_processus, 44) == d_vrai)
1017: {
1018:
1019: /*
1020: -- Bases hexadécimale et binaire -----------------------------------------------
1021: */
1022:
1023: sprintf(tampon, "%llX", (*((logical8 *)
1024: ((*s_objet).objet))) & masque_binaire);
1025:
1026: if (test_cfsf(s_etat_processus, 43) == d_vrai)
1027: {
1028: strcpy(base, "h");
1029: }
1030: else
1031: {
1032: chaine = (unsigned char *) malloc((strlen(tampon) + 1)
1033: * sizeof(unsigned char));
1034:
1035: if (chaine == NULL)
1036: {
1037: (*s_etat_processus).erreur_systeme =
1038: d_es_allocation_memoire;
1039: return(NULL);
1040: }
1041:
1042: strcpy(chaine, tampon);
1043: tampon[0] = 0;
1044:
1045: for(i = 0; i < strlen(chaine); i++)
1046: {
1047: switch(chaine[i])
1048: {
1049: case '0' :
1050: {
1051: strcat(tampon, (i != 0) ? "0000" : "0");
1052: break;
1053: }
1054: case '1' :
1055: {
1056: strcat(tampon, (i != 0) ? "0001" : "1");
1057: break;
1058: }
1059: case '2' :
1060: {
1061: strcat(tampon, (i != 0) ? "0010" : "10");
1062: break;
1063: }
1064: case '3' :
1065: {
1066: strcat(tampon, (i != 0) ? "0011" : "11");
1067: break;
1068: }
1069: case '4' :
1070: {
1071: strcat(tampon, (i != 0) ? "0100" : "100");
1072: break;
1073: }
1074: case '5' :
1075: {
1076: strcat(tampon, (i != 0) ? "0101" : "101");
1077: break;
1078: }
1079: case '6' :
1080: {
1081: strcat(tampon, (i != 0) ? "0110" : "110");
1082: break;
1083: }
1084: case '7' :
1085: {
1086: strcat(tampon, (i != 0) ? "0111" : "111");
1087: break;
1088: }
1089: case '8' :
1090: {
1091: strcat(tampon, "1000");
1092: break;
1093: }
1094: case '9' :
1095: {
1096: strcat(tampon, "1001");
1097: break;
1098: }
1099: case 'A' :
1100: {
1101: strcat(tampon, "1010");
1102: break;
1103: }
1104: case 'B' :
1105: {
1106: strcat(tampon, "1011");
1107: break;
1108: }
1109: case 'C' :
1110: {
1111: strcat(tampon, "1100");
1112: break;
1113: }
1114: case 'D' :
1115: {
1116: strcat(tampon, "1101");
1117: break;
1118: }
1119: case 'E' :
1120: {
1121: strcat(tampon, "1110");
1122: break;
1123: }
1124: case 'F' :
1125: {
1126: strcat(tampon, "1111");
1127: break;
1128: }
1129: }
1130: }
1131:
1132: free(chaine);
1133: strcpy(base, "b");
1134: }
1135: }
1136:
1137: chaine = (unsigned char *) malloc((strlen(tampon) + 4)
1138: * sizeof(unsigned char));
1139:
1140: if (chaine == NULL)
1141: {
1142: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1143: return(NULL);
1144: }
1145:
1146: strcpy(chaine, "# ");
1147:
1148: strcat(chaine, tampon);
1149: strcat(chaine, base);
1150: }
1151: else if ((*s_objet).type == CHN)
1152: {
1153:
1154: /*
1155: --------------------------------------------------------------------------------
1156: Chaîne de caractères
1157: --------------------------------------------------------------------------------
1158: */
1159:
1160: if (format_sortie != 'C')
1161: {
1162: (*s_etat_processus).erreur_execution =
1163: d_ex_erreur_format_fichier;
1164: return(NULL);
1165: }
1166:
1167: if ((longueur_champ == -1) || (((long) strlen((unsigned char *)
1168: (*s_objet).objet)) < longueur_champ))
1169: {
1170: chaine = (unsigned char *) malloc((strlen((unsigned char *)
1171: ((*s_objet).objet)) + 1) * sizeof(unsigned char));
1172:
1173: if (chaine == NULL)
1174: {
1175: (*s_etat_processus).erreur_systeme =
1176: d_es_allocation_memoire;
1177: return(NULL);
1178: }
1179:
1180: strcpy(chaine, (unsigned char *) ((*s_objet).objet));
1181: }
1182: else
1183: {
1184: chaine = (unsigned char *) malloc((longueur_champ + 1)
1185: * sizeof(unsigned char));
1186:
1187: if (chaine == NULL)
1188: {
1189: (*s_etat_processus).erreur_systeme =
1190: d_es_allocation_memoire;
1191: return(NULL);
1192: }
1193:
1194: strncpy(chaine, (unsigned char *) ((*s_objet).objet),
1195: longueur_champ);
1196: chaine[longueur_champ] = d_code_fin_chaine;
1197: }
1198: }
1199: else if ((*s_objet).type == CPL)
1200: {
1201:
1202: /*
1203: --------------------------------------------------------------------------------
1204: Complexe
1205: --------------------------------------------------------------------------------
1206: */
1207:
1208: if ((format_sortie != 'S') && (format_sortie != 'F') &&
1209: (format_sortie != 'I') && (format_sortie != 'E'))
1210: {
1211: (*s_etat_processus).erreur_execution =
1212: d_ex_erreur_format_fichier;
1213: return(NULL);
1214: }
1215:
1216: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
1217: (void *) ((struct_complexe16 *) ((*s_objet).objet)), 'C',
1218: longueur, longueur_champ, format_sortie)) == NULL)
1219: {
1220: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1221: return(NULL);
1222: }
1223:
1224: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
1225: + 1) * sizeof(unsigned char));
1226:
1227: if (chaine == NULL)
1228: {
1229: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1230: return(NULL);
1231: }
1232:
1233: strcpy(chaine, chaine_formatee);
1234: free(chaine_formatee);
1235: }
1236: else if ((*s_objet).type == RPN)
1237: {
1238:
1239: /*
1240: --------------------------------------------------------------------------------
1241: Définition
1242: --------------------------------------------------------------------------------
1243: */
1244:
1245: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
1246: chaine_sauvegarde = chaine;
1247:
1248: while(l_element_courant != NULL)
1249: {
1250: if ((chaine_formatee = formateur_fichier(s_etat_processus,
1251: (*l_element_courant).donnee, s_format,
1252: longueur, longueur_champ, format_sortie, type,
1253: longueur_effective, recursivite)) == NULL)
1254: {
1255: return(NULL);
1256: }
1257:
1258: if ((*(*l_element_courant).donnee).type == CHN)
1259: {
1260: chaine_tampon = chaine_formatee;
1261:
1262: if ((chaine_formatee = (unsigned char *) malloc((strlen(
1263: chaine_tampon) + 3) * sizeof(unsigned char)))
1264: == NULL)
1265: {
1266: (*s_etat_processus).erreur_systeme =
1267: d_es_allocation_memoire;
1268: return(NULL);
1269: }
1270:
1271: sprintf(chaine_formatee, "\"%s\"", chaine_tampon);
1272: free(chaine_tampon);
1273: }
1274:
1275: l_element_courant = (*l_element_courant).suivant;
1276:
1277: if (chaine != NULL)
1278: {
1279: chaine_sauvegarde = chaine;
1280:
1281: if ((chaine = (unsigned char *) malloc((strlen(
1282: chaine_sauvegarde) + strlen(chaine_formatee) + 2) *
1283: sizeof(unsigned char))) == NULL)
1284: {
1285: (*s_etat_processus).erreur_systeme =
1286: d_es_allocation_memoire;
1287: return(NULL);
1288: }
1289:
1290: strcpy(chaine, chaine_sauvegarde);
1291: free(chaine_sauvegarde);
1292: strcat(chaine, " ");
1293: strcat(chaine, chaine_formatee);
1294: free(chaine_formatee);
1295: }
1296: else
1297: {
1298: chaine = chaine_formatee;
1299: }
1300: }
1301:
1302: chaine_sauvegarde = chaine;
1303: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) *
1304: sizeof(unsigned char));
1305:
1306: if (chaine == NULL)
1307: {
1308: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1309: free(chaine_sauvegarde);
1310: return(NULL);
1311: }
1312:
1313: chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine;
1314: strcpy(chaine, chaine_sauvegarde);
1315: free(chaine_sauvegarde);
1316: }
1317: else if ((*s_objet).type == INT)
1318: {
1319:
1320: /*
1321: --------------------------------------------------------------------------------
1322: Entier
1323: --------------------------------------------------------------------------------
1324: */
1325:
1326: if ((format_sortie != 'S') && (format_sortie != 'F') &&
1327: (format_sortie != 'I') && (format_sortie != 'E'))
1328: {
1329: (*s_etat_processus).erreur_execution =
1330: d_ex_erreur_format_fichier;
1331: return(NULL);
1332: }
1333:
1334: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
1335: (void *) ((integer8 *) ((*s_objet).objet)), 'I',
1336: longueur, longueur_champ, format_sortie)) == NULL)
1337: {
1338: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1339: return(NULL);
1340: }
1341:
1342: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1)
1343: * sizeof(unsigned char));
1344:
1345: if (chaine == NULL)
1346: {
1347: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1348: return(NULL);
1349: }
1350:
1351: strcpy(chaine, chaine_formatee);
1352: free(chaine_formatee);
1353: }
1354: else if ((*s_objet).type == FCT)
1355: {
1356:
1357: /*
1358: --------------------------------------------------------------------------------
1359: Fonction
1360: --------------------------------------------------------------------------------
1361: */
1362:
1363: chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
1364: ((*s_objet).objet))).nom_fonction) + 1) *
1365: sizeof(unsigned char));
1366:
1367: if (chaine == NULL)
1368: {
1369: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1370: return(NULL);
1371: }
1372:
1373: strcpy(chaine, (unsigned char *) (*((struct_fonction *)
1374: ((*s_objet).objet))).nom_fonction);
1375: }
1376: else if ((*s_objet).type == LST)
1377: {
1378:
1379: /*
1380: --------------------------------------------------------------------------------
1381: Liste
1382: --------------------------------------------------------------------------------
1383: */
1384:
1385: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
1386:
1387: if (chaine == NULL)
1388: {
1389: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1390: return(NULL);
1391: }
1392:
1393: strcpy(chaine, "{");
1394:
1395: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1396: l_element_courant_format = (struct_liste_chainee *)
1397: (*s_format).objet;
1398: nombre_elements = 0;
1399:
1400: while((l_element_courant != NULL) &&
1401: (l_element_courant_format != NULL))
1402: {
1403: if ((((*(*l_element_courant_format).donnee).type == LST)
1404: && ((*(*l_element_courant).donnee).type == LST)) ||
1405: (((*(*l_element_courant_format).donnee).type == TBL)
1406: && ((*(*l_element_courant).donnee).type == TBL)))
1407: {
1408: chaine_sauvegarde = chaine;
1409:
1410: if ((chaine_formatee = formateur_fichier(s_etat_processus,
1411: (*l_element_courant).donnee,
1412: (*l_element_courant_format).donnee,
1413: 0, 0, ' ', 'F', longueur_effective, recursivite))
1414: == NULL)
1415: {
1416: return(NULL);
1417: }
1418:
1419: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
1420: + strlen(chaine_sauvegarde) + 2)
1421: * sizeof(unsigned char));
1422:
1423: if (chaine == NULL)
1424: {
1425: (*s_etat_processus).erreur_systeme =
1426: d_es_allocation_memoire;
1427: return(NULL);
1428: }
1429:
1430: strcpy(chaine, chaine_sauvegarde);
1431: free(chaine_sauvegarde);
1432: strcat(chaine, " ");
1433: strcat(chaine, chaine_formatee);
1434: free(chaine_formatee);
1435: }
1436: else if ((*(*l_element_courant_format).donnee).type != CHN)
1437: {
1438: free(chaine);
1439:
1440: (*s_etat_processus).erreur_execution =
1441: d_ex_erreur_format_fichier;
1442: return(NULL);
1443: }
1444: else
1445: {
1446: if ((format_chaine = conversion_majuscule((unsigned char *)
1447: (*(*l_element_courant_format).donnee).objet))
1448: == NULL)
1449: {
1450: (*s_etat_processus).erreur_systeme =
1451: d_es_allocation_memoire;
1452: return(NULL);
1453: }
1454:
1455: format_degenere = d_faux;
1456:
1457: if (strncmp("STANDARD*", format_chaine, 9) == 0)
1458: {
1459: format_sortie = 'S';
1460: position_1 = 9;
1461: format_degenere = d_vrai;
1462: }
1463: else if (strncmp("BINARY*", format_chaine, 7) == 0)
1464: {
1465: format_sortie = 'B';
1466: position_1 = 7;
1467: }
1468: else if (strncmp("FIXED*", format_chaine, 6) == 0)
1469: {
1470: format_sortie = 'F';
1471: position_1 = 6;
1472: }
1473: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
1474: {
1475: format_sortie = 'I';
1476: position_1 = 11;
1477: }
1478: else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
1479: {
1480: format_sortie = 'E';
1481: position_1 = 9;
1482: }
1483: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
1484: {
1485: format_sortie = 'C';
1486: position_1 = 10;
1487: format_degenere = d_vrai;
1488: }
1489: else
1490: {
1491: free(chaine);
1492: free(format_chaine);
1493:
1494: (*s_etat_processus).erreur_execution =
1495: d_ex_erreur_format_fichier;
1496: return(NULL);
1497: }
1498:
1499: position_3 = strlen(format_chaine) - 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 XXXXXX longueur sur 16 bits
2734: * 10 XXXXXX longueur sur 32 bits
2735: * 11 XXXXXX 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: --------------------------------------------------------------------------------
3929: */
3930:
3931: if (format_sortie != 'C')
3932: {
3933: (*s_etat_processus).erreur_execution =
3934: d_ex_erreur_format_fichier;
3935: return(NULL);
3936: }
3937:
3938: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
3939: (*s_objet).objet, 'C', longueur, longueur_effective))
3940: == NULL)
3941: {
3942: return(NULL);
3943: }
3944: }
3945: else if ((*s_objet).type == RPN)
3946: {
3947:
3948: /*
3949: --------------------------------------------------------------------------------
3950: Définition
3951: --------------------------------------------------------------------------------
3952: */
3953:
3954: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
3955: chaine_sauvegarde = chaine;
3956:
3957: while(l_element_courant != NULL)
3958: {
3959: if ((chaine_formatee = formateur_fichier(s_etat_processus,
3960: (*l_element_courant).donnee, s_format,
3961: longueur, longueur_champ, format_sortie, type,
3962: longueur_effective, recursivite)) == NULL)
3963: {
3964: return(NULL);
3965: }
3966:
3967: if ((*(*l_element_courant).donnee).type == CHN)
3968: {
3969: chaine_tampon = chaine_formatee;
3970:
3971: if ((chaine_formatee = (unsigned char *) malloc((strlen(
3972: chaine_tampon) + 3) * sizeof(unsigned char)))
3973: == NULL)
3974: {
3975: (*s_etat_processus).erreur_systeme =
3976: d_es_allocation_memoire;
3977: return(NULL);
3978: }
3979:
3980: sprintf(chaine_formatee, "\"%s\"", chaine_tampon);
3981: free(chaine_tampon);
3982: }
3983:
3984: l_element_courant = (*l_element_courant).suivant;
3985:
3986: if (chaine != NULL)
3987: {
3988: chaine_sauvegarde = chaine;
3989:
3990: if ((chaine = (unsigned char *) malloc((strlen(
3991: chaine_sauvegarde) + strlen(chaine_formatee) + 2) *
3992: sizeof(unsigned char))) == NULL)
3993: {
3994: (*s_etat_processus).erreur_systeme =
3995: d_es_allocation_memoire;
3996: return(NULL);
3997: }
3998:
3999: strcpy(chaine, chaine_sauvegarde);
4000: free(chaine_sauvegarde);
4001: strcat(chaine, " ");
4002: strcat(chaine, chaine_formatee);
4003: free(chaine_formatee);
4004: }
4005: else
4006: {
4007: chaine = chaine_formatee;
4008: }
4009: }
4010:
4011: chaine_sauvegarde = chaine;
4012: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) *
4013: sizeof(unsigned char));
4014:
4015: if (chaine == NULL)
4016: {
4017: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4018: free(chaine_sauvegarde);
4019: return(NULL);
4020: }
4021:
4022: chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine;
4023: strcpy(chaine, chaine_sauvegarde);
4024: free(chaine_sauvegarde);
4025: }
4026: else if ((*s_objet).type == INT)
4027: {
4028:
4029: /*
4030: --------------------------------------------------------------------------------
4031: Entier
4032: --------------------------------------------------------------------------------
4033: */
4034:
4035: if (format_sortie != 'I')
4036: {
4037: (*s_etat_processus).erreur_execution =
4038: d_ex_erreur_format_fichier;
4039: return(NULL);
4040: }
4041:
4042: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
4043: (*s_objet).objet, 'I', longueur, longueur_effective))
4044: == NULL)
4045: {
4046: return(NULL);
4047: }
4048: }
4049: else if ((*s_objet).type == FCT)
4050: {
4051:
4052: /*
4053: --------------------------------------------------------------------------------
4054: Fonction
4055: --------------------------------------------------------------------------------
4056: */
4057:
4058: chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
4059: ((*s_objet).objet))).nom_fonction) + 1) *
4060: sizeof(unsigned char));
4061:
4062: if (chaine == NULL)
4063: {
4064: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4065: return(NULL);
4066: }
4067:
4068: strcpy(chaine, (unsigned char *) (*((struct_fonction *)
4069: ((*s_objet).objet))).nom_fonction);
4070: }
4071: else if ((*s_objet).type == LST)
4072: {
4073:
4074: /*
4075: --------------------------------------------------------------------------------
4076: Liste
4077: Poids fort 0100
4078: --------------------------------------------------------------------------------
4079: */
4080:
4081: chaine = malloc(sizeof(unsigned char));
4082:
4083: if (chaine == NULL)
4084: {
4085: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4086: return(NULL);
4087: }
4088:
4089: // Calcul de la longueur de la liste.
4090:
4091: longueur_liste = 0;
4092: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
4093:
4094: while(l_element_courant != NULL)
4095: {
4096: l_element_courant = (*l_element_courant).suivant;
4097: longueur_liste++;
4098: }
4099:
4100: if (longueur_liste < (1LL << 3))
4101: {
4102: chaine[0] = 0x40 | (longueur_liste & 0x7);
4103: }
4104: else if (longueur_liste < (1LL << 8))
4105: {
4106: chaine[0] = 0x48;
4107: }
4108: else if (longueur_liste < (1LL << 16))
4109: {
4110: chaine[0] = 0x49;
4111: }
4112: else if (longueur_liste < (1LL << 32))
4113: {
4114: chaine[0] = 0x4A;
4115: }
4116: else
4117: {
4118: chaine[0] = 0x4B;
4119: }
4120:
4121: longueur_totale = 1;
4122:
4123: if ((chaine[0] & 0x8) != 0)
4124: {
4125: switch(chaine[0] & 0x03)
4126: {
4127: case 0x00 :
4128: {
4129: longueur_totale += 1;
4130:
4131: if ((chaine = realloc(chaine, longueur_totale *
4132: sizeof(unsigned char))) == NULL)
4133: {
4134: (*s_etat_processus).erreur_systeme =
4135: d_es_allocation_memoire;
4136: return(NULL);
4137: }
4138:
4139: chaine[longueur_totale - 1] =
4140: (unsigned char) (longueur_liste & 0xFF);
4141: break;
4142: }
4143:
4144: case 0x01 :
4145: {
4146: longueur_totale += 2;
4147:
4148: if ((chaine = realloc(chaine, longueur_totale *
4149: sizeof(unsigned char))) == NULL)
4150: {
4151: (*s_etat_processus).erreur_systeme =
4152: d_es_allocation_memoire;
4153: return(NULL);
4154: }
4155:
4156: chaine[longueur_totale - 2] =
4157: (unsigned char) ((longueur_liste >> 8) & 0xFF);
4158: chaine[longueur_totale - 1] =
4159: (unsigned char) (longueur_liste & 0xFF);
4160: break;
4161: }
4162:
4163: case 0x02 :
4164: {
4165: longueur_totale += 4;
4166:
4167: if ((chaine = realloc(chaine, longueur_totale *
4168: sizeof(unsigned char))) == NULL)
4169: {
4170: (*s_etat_processus).erreur_systeme =
4171: d_es_allocation_memoire;
4172: return(NULL);
4173: }
4174:
4175: chaine[longueur_totale - 4] =
4176: (unsigned char) ((longueur_liste >> 24) & 0xFF);
4177: chaine[longueur_totale - 3] =
4178: (unsigned char) ((longueur_liste >> 16) & 0xFF);
4179: chaine[longueur_totale - 2] =
4180: (unsigned char) ((longueur_liste >> 8) & 0xFF);
4181: chaine[longueur_totale - 1] =
4182: (unsigned char) (longueur_liste & 0xFF);
4183: break;
4184: }
4185:
4186: case 0x03 :
4187: {
4188: longueur_totale += 8;
4189:
4190: if ((chaine = realloc(chaine, longueur_totale *
4191: sizeof(unsigned char))) == NULL)
4192: {
4193: (*s_etat_processus).erreur_systeme =
4194: d_es_allocation_memoire;
4195: return(NULL);
4196: }
4197:
4198: chaine[longueur_totale - 8] =
4199: (unsigned char) ((longueur_liste >> 56) & 0xFF);
4200: chaine[longueur_totale - 7] =
4201: (unsigned char) ((longueur_liste >> 48) & 0xFF);
4202: chaine[longueur_totale - 6] =
4203: (unsigned char) ((longueur_liste >> 40) & 0xFF);
4204: chaine[longueur_totale - 5] =
4205: (unsigned char) ((longueur_liste >> 32) & 0xFF);
4206: chaine[longueur_totale - 4] =
4207: (unsigned char) ((longueur_liste >> 24) & 0xFF);
4208: chaine[longueur_totale - 3] =
4209: (unsigned char) ((longueur_liste >> 16) & 0xFF);
4210: chaine[longueur_totale - 2] =
4211: (unsigned char) ((longueur_liste >> 8) & 0xFF);
4212: chaine[longueur_totale - 1] =
4213: (unsigned char) (longueur_liste & 0xFF);
4214: break;
4215: }
4216:
4217: default :
4218: {
4219: BUG(1, printf("Internal format error\n"));
4220: }
4221: }
4222: }
4223:
4224: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
4225: l_element_courant_format = (struct_liste_chainee *)
4226: (*s_format).objet;
4227: nombre_elements = 0;
4228:
4229: while((l_element_courant != NULL) &&
4230: (l_element_courant_format != NULL))
4231: {
4232: if ((((*(*l_element_courant_format).donnee).type == LST)
4233: && ((*(*l_element_courant).donnee).type == LST)) ||
4234: (((*(*l_element_courant_format).donnee).type == TBL)
4235: && ((*(*l_element_courant).donnee).type == TBL)))
4236: {
4237: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4238: (*l_element_courant).donnee,
4239: (*l_element_courant_format).donnee,
4240: 0, 0, ' ', 'U', longueur_effective, recursivite))
4241: == NULL)
4242: {
4243: return(NULL);
4244: }
4245:
4246: if ((chaine = realloc(chaine, (longueur_totale +
4247: (*longueur_effective)) * sizeof(unsigned char)))
4248: == NULL)
4249: {
4250: (*s_etat_processus).erreur_systeme =
4251: d_es_allocation_memoire;
4252: return(NULL);
4253: }
4254:
4255: memcpy(&(chaine[longueur_totale]), chaine_formatee,
4256: (*longueur_effective));
4257: longueur_totale += (*longueur_effective);
4258: free(chaine_formatee);
4259: }
4260: else if ((*(*l_element_courant_format).donnee).type != CHN)
4261: {
4262: free(chaine);
4263:
4264: (*s_etat_processus).erreur_execution =
4265: d_ex_erreur_format_fichier;
4266: return(NULL);
4267: }
4268: else
4269: {
4270: if ((format_chaine = conversion_majuscule((unsigned char *)
4271: (*(*l_element_courant_format).donnee).objet))
4272: == NULL)
4273: {
4274: (*s_etat_processus).erreur_systeme =
4275: d_es_allocation_memoire;
4276: return(NULL);
4277: }
4278:
4279: format_degenere = d_faux;
4280:
4281: if (strncmp("INTEGER*", format_chaine, 8) == 0)
4282: {
4283: format_sortie = 'I';
4284: position_1 = 8;
4285: }
4286: else if (strncmp("LOGICAL*", format_chaine, 8) == 0)
4287: {
4288: format_sortie = 'L';
4289: position_1 = 8;
4290: }
4291: else if (strncmp("REAL*", format_chaine, 5) == 0)
4292: {
4293: format_sortie = 'R';
4294: position_1 = 5;
4295: }
4296: else if (strncmp("COMPLEX*", format_chaine, 8) == 0)
4297: {
4298: format_sortie = 'C';
4299: position_1 = 8;
4300: }
4301: else if (strcmp("CHARACTER", format_chaine) == 0)
4302: {
4303: format_sortie = 'S';
4304: position_1 = 10;
4305: format_degenere = d_vrai;
4306: }
4307: else
4308: {
4309: free(chaine);
4310: free(format_chaine);
4311:
4312: (*s_etat_processus).erreur_execution =
4313: d_ex_erreur_format_fichier;
4314: return(NULL);
4315: }
4316:
4317: if (format_degenere == d_faux)
4318: {
4319: if (format_chaine[position_1] == d_code_fin_chaine)
4320: {
4321: free(chaine);
4322: free(format_chaine);
4323:
4324: (*s_etat_processus).erreur_execution =
4325: d_ex_erreur_format_fichier;
4326: return(NULL);
4327: }
4328:
4329: if (sscanf(&(format_chaine[position_1]), "%ld",
4330: &longueur) != 1)
4331: {
4332: free(chaine);
4333: free(format_chaine);
4334:
4335: (*s_etat_processus).erreur_execution =
4336: d_ex_erreur_format_fichier;
4337: return(NULL);
4338: }
4339: }
4340: else
4341: {
4342: longueur = -1;
4343: }
4344:
4345: free(format_chaine);
4346:
4347: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4348: (*l_element_courant).donnee, s_format,
4349: longueur, longueur_champ, format_sortie, type,
4350: longueur_effective, recursivite)) == NULL)
4351: {
4352: free(chaine);
4353: return(NULL);
4354: }
4355:
4356: if ((chaine = realloc(chaine,
4357: (longueur_totale + (*longueur_effective))
4358: * sizeof(unsigned char))) == NULL)
4359: {
4360: (*s_etat_processus).erreur_systeme =
4361: d_es_allocation_memoire;
4362: return(NULL);
4363: }
4364:
4365: memcpy(&(chaine[longueur_totale]), chaine_formatee,
4366: (*longueur_effective));
4367: longueur_totale += (*longueur_effective);
4368: free(chaine_formatee);
4369: }
4370:
4371: nombre_elements++;
4372: l_element_courant = (*l_element_courant).suivant;
4373: l_element_courant_format = (*l_element_courant_format).suivant;
4374: }
4375:
4376: if ((l_element_courant != NULL) ||
4377: (l_element_courant_format != NULL))
4378: {
4379: free(chaine);
4380:
4381: (*s_etat_processus).erreur_execution =
4382: d_ex_erreur_format_fichier;
4383: return(NULL);
4384: }
4385:
4386: if ((*recursivite) == 1)
4387: {
4388: // Ajout de la longueur totale en fin d'enregistrement.
4389:
4390: if (longueur_totale < (((integer8) 1) << 6))
4391: {
4392: tampon[0] = longueur_totale + 1;
4393:
4394: if ((chaine = realloc(chaine, (longueur_totale + 1)
4395: * sizeof(unsigned char))) == NULL)
4396: {
4397: (*s_etat_processus).erreur_systeme =
4398: d_es_allocation_memoire;
4399: return(NULL);
4400: }
4401:
4402: memcpy(&(chaine[longueur_totale]), tampon, 1);
4403: longueur_totale += 1;
4404: }
4405: else if (longueur_totale < (((integer8) 1) << 16))
4406: {
4407: tampon[2] = 0x40;
4408: tampon[1] = (longueur_totale + 1) & 0xFF;
4409: tampon[0] = ((longueur_totale + 1) >> 8) & 0xFF;
4410:
4411: if ((chaine = realloc(chaine, (longueur_totale + 3)
4412: * sizeof(unsigned char))) == NULL)
4413: {
4414: (*s_etat_processus).erreur_systeme =
4415: d_es_allocation_memoire;
4416: return(NULL);
4417: }
4418:
4419: memcpy(&(chaine[longueur_totale]), tampon, 3);
4420: longueur_totale += 3;
4421: }
4422: else if (longueur_totale < (((integer8) 1) << 32))
4423: {
4424: tampon[4] = 0x80;
4425: tampon[3] = (longueur_totale + 1) & 0xFF;
4426: tampon[2] = ((longueur_totale + 1) >> 8) & 0xFF;
4427: tampon[1] = ((longueur_totale + 1) >> 16) & 0xFF;
4428: tampon[0] = ((longueur_totale + 1) >> 24) & 0xFF;
4429:
4430: if ((chaine = realloc(chaine, (longueur_totale + 5)
4431: * sizeof(unsigned char))) == NULL)
4432: {
4433: (*s_etat_processus).erreur_systeme =
4434: d_es_allocation_memoire;
4435: return(NULL);
4436: }
4437:
4438: memcpy(&(chaine[longueur_totale]), tampon, 5);
4439: longueur_totale += 5;
4440: }
4441: else
4442: {
4443: tampon[8] = 0xC0;
4444: tampon[7] = (longueur_totale + 1) & 0xFF;
4445: tampon[6] = ((longueur_totale + 1) >> 8) & 0xFF;
4446: tampon[5] = ((longueur_totale + 1) >> 16) & 0xFF;
4447: tampon[4] = ((longueur_totale + 1) >> 24) & 0xFF;
4448: tampon[3] = ((longueur_totale + 1) >> 32) & 0xFF;
4449: tampon[2] = ((longueur_totale + 1) >> 40) & 0xFF;
4450: tampon[1] = ((longueur_totale + 1) >> 48) & 0xFF;
4451: tampon[0] = ((longueur_totale + 1) >> 56) & 0xFF;
4452:
4453: if ((chaine = realloc(chaine, (longueur_totale + 9)
4454: * sizeof(unsigned char))) == NULL)
4455: {
4456: (*s_etat_processus).erreur_systeme =
4457: d_es_allocation_memoire;
4458: return(NULL);
4459: }
4460:
4461: memcpy(&(chaine[longueur_totale]), tampon, 9);
4462: longueur_totale += 9;
4463: }
4464:
4465: __zone();
4466: }
4467:
4468: (*longueur_effective) = longueur_totale;
4469: }
4470: else if ((*s_objet).type == TBL)
4471: {
4472:
4473: /*
4474: --------------------------------------------------------------------------------
4475: Table
4476: --------------------------------------------------------------------------------
4477: */
4478:
4479: if ((*s_format).type != TBL)
4480: {
4481: (*s_etat_processus).erreur_execution =
4482: d_ex_erreur_format_fichier;
4483: return(NULL);
4484: }
4485:
4486: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
4487: l_element_courant_format = (struct_liste_chainee *)
4488: (*s_format).objet;
4489:
4490: if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
4491: (*((struct_tableau *) (*s_format).objet)).nombre_elements)
4492: {
4493: (*s_etat_processus).erreur_execution =
4494: d_ex_erreur_format_fichier;
4495: return(NULL);
4496: }
4497:
4498: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
4499:
4500: if (chaine == NULL)
4501: {
4502: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4503: return(NULL);
4504: }
4505:
4506: strcpy(chaine, "<[");
4507:
4508: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
4509: .nombre_elements; i++)
4510: {
4511: if ((((*(*((struct_tableau *) (*s_format).objet))
4512: .elements[i]).type == LST) &&
4513: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
4514: .type == LST)) ||
4515: (((*(*((struct_tableau *) (*s_format).objet))
4516: .elements[i]).type == TBL) &&
4517: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
4518: .type == TBL)))
4519: {
4520: chaine_sauvegarde = chaine;
4521:
4522: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4523: (*l_element_courant).donnee,
4524: (*l_element_courant_format).donnee,
4525: 0, 0, ' ', 'F', longueur_effective, recursivite))
4526: == NULL)
4527: {
4528: return(NULL);
4529: }
4530:
4531: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
4532: + strlen(chaine_sauvegarde) + 2)
4533: * sizeof(unsigned char));
4534:
4535: if (chaine == NULL)
4536: {
4537: (*s_etat_processus).erreur_systeme =
4538: d_es_allocation_memoire;
4539: return(NULL);
4540: }
4541:
4542: strcpy(chaine, chaine_sauvegarde);
4543: free(chaine_sauvegarde);
4544: strcat(chaine, " ");
4545: strcat(chaine, chaine_formatee);
4546: free(chaine_formatee);
4547: }
4548: else if ((*(*((struct_tableau *) (*s_format).objet))
4549: .elements[i]).type != CHN)
4550: {
4551: free(chaine);
4552:
4553: (*s_etat_processus).erreur_execution =
4554: d_ex_erreur_format_fichier;
4555: return(NULL);
4556: }
4557: else
4558: {
4559: if ((format_chaine = conversion_majuscule((unsigned char *)
4560: (*(*((struct_tableau *) (*s_format).objet))
4561: .elements[i]).objet)) == NULL)
4562: {
4563: (*s_etat_processus).erreur_systeme =
4564: d_es_allocation_memoire;
4565: return(NULL);
4566: }
4567:
4568: format_degenere = d_faux;
4569:
4570: if (strncmp("STANDARD*", format_chaine, 9) == 0)
4571: {
4572: format_sortie = 'S';
4573: position_1 = 9;
4574: format_degenere = d_vrai;
4575: }
4576: else if (strncmp("BINARY*", format_chaine, 7) == 0)
4577: {
4578: format_sortie = 'B';
4579: position_1 = 7;
4580: }
4581: else if (strncmp("FIXED*", format_chaine, 6) == 0)
4582: {
4583: format_sortie = 'F';
4584: position_1 = 6;
4585: }
4586: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
4587: {
4588: format_sortie = 'I';
4589: position_1 = 11;
4590: }
4591: else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
4592: {
4593: format_sortie = 'E';
4594: position_1 = 9;
4595: }
4596: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
4597: {
4598: format_sortie = 'C';
4599: position_1 = 10;
4600: format_degenere = d_vrai;
4601: }
4602: else
4603: {
4604: free(chaine);
4605: free(format_chaine);
4606:
4607: (*s_etat_processus).erreur_execution =
4608: d_ex_erreur_format_fichier;
4609: return(NULL);
4610: }
4611:
4612: position_3 = strlen(format_chaine);
4613: format_chaine[--position_3] = d_code_fin_chaine;
4614:
4615: position_2 = position_1;
4616:
4617: while(format_chaine[position_2] != '(')
4618: {
4619: if (format_chaine[position_2] == d_code_fin_chaine)
4620: {
4621: free(chaine);
4622: free(format_chaine);
4623:
4624: (*s_etat_processus).erreur_execution =
4625: d_ex_erreur_format_fichier;
4626: return(NULL);
4627: }
4628:
4629: position_2++;
4630: }
4631:
4632: format_chaine[position_2++] = d_code_fin_chaine;
4633:
4634: if (format_degenere == d_faux)
4635: {
4636: if (sscanf(&(format_chaine[position_1]), "%ld",
4637: &longueur) != 1)
4638: {
4639: free(chaine);
4640: free(format_chaine);
4641:
4642: (*s_etat_processus).erreur_execution =
4643: d_ex_erreur_format_fichier;
4644: return(NULL);
4645: }
4646: }
4647: else
4648: {
4649: longueur = -1;
4650: }
4651:
4652: if (strcmp(&(format_chaine[position_2]), "*") != 0)
4653: {
4654: if (sscanf(&(format_chaine[position_2]), "%ld",
4655: &longueur_champ) != 1)
4656: {
4657: free(chaine);
4658: free(format_chaine);
4659:
4660: (*s_etat_processus).erreur_execution =
4661: d_ex_erreur_format_fichier;
4662: return(NULL);
4663: }
4664: }
4665: else
4666: {
4667: longueur_champ = -1;
4668: }
4669:
4670: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
4671: longueur_champ))
4672: {
4673: free(chaine);
4674: free(format_chaine);
4675:
4676: (*s_etat_processus).erreur_execution =
4677: d_ex_erreur_format_fichier;
4678: return(NULL);
4679: }
4680:
4681: free(format_chaine);
4682:
4683: chaine_sauvegarde = chaine;
4684:
4685: if ((chaine_formatee = formateur_fichier(s_etat_processus,
4686: (*((struct_tableau *) (*s_objet).objet))
4687: .elements[i], s_format,
4688: longueur, longueur_champ, format_sortie, type,
4689: longueur_effective, recursivite)) == NULL)
4690: {
4691: return(NULL);
4692: }
4693:
4694: if ((*(*((struct_tableau *) (*s_objet).objet))
4695: .elements[i]).type == CHN)
4696: {
4697: chaine = (unsigned char *)
4698: malloc((strlen(chaine_formatee)
4699: + strlen(chaine_sauvegarde) + 4)
4700: * sizeof(unsigned char));
4701:
4702: if (chaine == NULL)
4703: {
4704: (*s_etat_processus).erreur_systeme =
4705: d_es_allocation_memoire;
4706: return(NULL);
4707: }
4708:
4709: strcpy(chaine, chaine_sauvegarde);
4710: free(chaine_sauvegarde);
4711: strcat(chaine, " \"");
4712: strcat(chaine, chaine_formatee);
4713: free(chaine_formatee);
4714: strcat(chaine, "\"");
4715: }
4716: else if ((*(*((struct_tableau *) (*s_objet).objet))
4717: .elements[i]).type == NOM)
4718: {
4719: chaine = (unsigned char *)
4720: malloc((strlen(chaine_formatee)
4721: + strlen(chaine_sauvegarde) + 2)
4722: * sizeof(unsigned char));
4723:
4724: if (chaine == NULL)
4725: {
4726: (*s_etat_processus).erreur_systeme =
4727: d_es_allocation_memoire;
4728: return(NULL);
4729: }
4730:
4731: sprintf(chaine, "%s %s", chaine_sauvegarde,
4732: chaine_formatee);
4733: free(chaine_formatee);
4734: }
4735: else
4736: {
4737: chaine = (unsigned char *)
4738: malloc((strlen(chaine_formatee)
4739: + strlen(chaine_sauvegarde) + 2)
4740: * sizeof(unsigned char));
4741:
4742: if (chaine == NULL)
4743: {
4744: (*s_etat_processus).erreur_systeme =
4745: d_es_allocation_memoire;
4746: return(NULL);
4747: }
4748:
4749: strcpy(chaine, chaine_sauvegarde);
4750: free(chaine_sauvegarde);
4751: strcat(chaine, " ");
4752: strcat(chaine, chaine_formatee);
4753: free(chaine_formatee);
4754: }
4755: }
4756: }
4757:
4758: chaine_sauvegarde = chaine;
4759: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4)
4760: * sizeof(unsigned char));
4761:
4762: if (chaine == NULL)
4763: {
4764: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
4765: return(NULL);
4766: }
4767:
4768: strcpy(chaine, chaine_sauvegarde);
4769: free(chaine_sauvegarde);
4770: strcat(chaine, " ]>");
4771: }
4772: else if ((*s_objet).type == MCX)
4773: {
4774:
4775: /*
4776: --------------------------------------------------------------------------------
4777: Matrice complexe
4778: --------------------------------------------------------------------------------
4779: */
4780:
4781: if ((format_sortie != 'S') && (format_sortie != 'F') &&
4782: (format_sortie != 'I') && (format_sortie != 'E'))
4783: {
4784: (*s_etat_processus).erreur_execution =
4785: d_ex_erreur_format_fichier;
4786: return(NULL);
4787: }
4788:
4789: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
4790: .nombre_lignes;
4791: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
4792: .nombre_colonnes;
4793:
4794: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
4795:
4796: if (chaine != NULL)
4797: {
4798: strcpy(chaine, "[[");
4799:
4800: for(i = 0; i < nombre_lignes; i++)
4801: {
4802: for(j = 0; j < nombre_colonnes; j++)
4803: {
4804: if ((chaine_formatee =
4805: formateur_fichier_nombre(s_etat_processus,
4806: (void *) &(((struct_complexe16 **)
4807: ((*((struct_matrice *)
4808: ((*s_objet).objet))).tableau))[i][j]), 'C',
4809: longueur, longueur_champ, format_sortie))
4810: == NULL)
4811: {
4812: (*s_etat_processus).erreur_systeme =
4813: d_es_allocation_memoire;
4814: return(NULL);
4815: }
4816:
4817: chaine_sauvegarde = chaine;
4818: chaine = (unsigned char *) malloc(
4819: (strlen(chaine_sauvegarde) +
4820: strlen(chaine_formatee) + 2)
4821: * sizeof(unsigned char));
4822:
4823: if (chaine == NULL)
4824: {
4825: (*s_etat_processus).erreur_systeme =
4826: d_es_allocation_memoire;
4827: return(NULL);
4828: }
4829:
4830: strcpy(chaine, chaine_sauvegarde);
4831: free(chaine_sauvegarde);
4832: strcat(chaine, " ");
4833: strcat(chaine, chaine_formatee);
4834: free(chaine_formatee);
4835: }
4836:
4837: chaine_sauvegarde = chaine;
4838: if (test_cfsf(s_etat_processus, 45) == d_vrai)
4839: {
4840: chaine = (unsigned char *) malloc(
4841: (strlen(chaine_sauvegarde) + 6)
4842: * sizeof(unsigned char));
4843:
4844: if (chaine == NULL)
4845: {
4846: (*s_etat_processus).erreur_systeme =
4847: d_es_allocation_memoire;
4848: return(NULL);
4849: }
4850:
4851: strcpy(chaine, chaine_sauvegarde);
4852: free(chaine_sauvegarde);
4853: strcat(chaine, " ]\n [");
4854: }
4855: else
4856: {
4857: chaine = (unsigned char *) malloc(
4858: (strlen(chaine_sauvegarde) + 4)
4859: * sizeof(unsigned char));
4860:
4861: if (chaine == NULL)
4862: {
4863: (*s_etat_processus).erreur_systeme =
4864: d_es_allocation_memoire;
4865: return(NULL);
4866: }
4867:
4868: strcpy(chaine, chaine_sauvegarde);
4869: free(chaine_sauvegarde);
4870: strcat(chaine, " ][");
4871: }
4872: }
4873:
4874: if (test_cfsf(s_etat_processus, 45) == d_vrai)
4875: {
4876: chaine[strlen(chaine) - 3] = ']';
4877: chaine[strlen(chaine) - 2] = 0;
4878:
4879: chaine_sauvegarde = chaine;
4880: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
4881: + 1) * sizeof(unsigned char));
4882:
4883: if (chaine == NULL)
4884: {
4885: (*s_etat_processus).erreur_systeme =
4886: d_es_allocation_memoire;
4887: return(NULL);
4888: }
4889:
4890: strcpy(chaine, chaine_sauvegarde);
4891: free(chaine_sauvegarde);
4892: }
4893: else
4894: {
4895: chaine[strlen(chaine) - 2] = ']';
4896: chaine[strlen(chaine) - 1] = 0;
4897:
4898: chaine_sauvegarde = chaine;
4899: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
4900: + 2) * sizeof(unsigned char));
4901:
4902: if (chaine == NULL)
4903: {
4904: (*s_etat_processus).erreur_systeme =
4905: d_es_allocation_memoire;
4906: return(NULL);
4907: }
4908:
4909: strcpy(chaine, chaine_sauvegarde);
4910: free(chaine_sauvegarde);
4911: strcat(chaine, "]");
4912: }
4913: }
4914: }
4915: else if ((*s_objet).type == MIN)
4916: {
4917:
4918: /*
4919: --------------------------------------------------------------------------------
4920: Matrice entière
4921: --------------------------------------------------------------------------------
4922: */
4923:
4924: if ((format_sortie != 'S') && (format_sortie != 'F') &&
4925: (format_sortie != 'I') && (format_sortie != 'E'))
4926: {
4927: (*s_etat_processus).erreur_execution =
4928: d_ex_erreur_format_fichier;
4929: return(NULL);
4930: }
4931:
4932: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
4933: .nombre_lignes;
4934: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
4935: .nombre_colonnes;
4936:
4937: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
4938:
4939: if (chaine != NULL)
4940: {
4941: strcpy(chaine, "[[");
4942:
4943: for(i = 0; i < nombre_lignes; i++)
4944: {
4945: for(j = 0; j < nombre_colonnes; j++)
4946: {
4947: if ((chaine_formatee =
4948: formateur_fichier_nombre(s_etat_processus,
4949: (void *) &(((integer8 **) ((*((struct_matrice *)
4950: ((*s_objet).objet))).tableau))[i][j]), 'I',
4951: longueur, longueur_champ, format_sortie))
4952: == NULL)
4953: {
4954: (*s_etat_processus).erreur_systeme =
4955: d_es_allocation_memoire;
4956: return(NULL);
4957: }
4958:
4959: chaine_sauvegarde = chaine;
4960: chaine = (unsigned char *) malloc(
4961: (strlen(chaine_sauvegarde) +
4962: strlen(chaine_formatee) + 2)
4963: * sizeof(unsigned char));
4964:
4965: if (chaine == NULL)
4966: {
4967: (*s_etat_processus).erreur_systeme =
4968: d_es_allocation_memoire;
4969: return(NULL);
4970: }
4971:
4972: strcpy(chaine, chaine_sauvegarde);
4973: free(chaine_sauvegarde);
4974: strcat(chaine, " ");
4975: strcat(chaine, chaine_formatee);
4976: free(chaine_formatee);
4977: }
4978:
4979: chaine_sauvegarde = chaine;
4980: if (test_cfsf(s_etat_processus, 45) == d_vrai)
4981: {
4982: chaine = (unsigned char *) malloc(
4983: (strlen(chaine_sauvegarde) + 6)
4984: * sizeof(unsigned char));
4985:
4986: if (chaine == NULL)
4987: {
4988: (*s_etat_processus).erreur_systeme =
4989: d_es_allocation_memoire;
4990: return(NULL);
4991: }
4992:
4993: strcpy(chaine, chaine_sauvegarde);
4994: free(chaine_sauvegarde);
4995: strcat(chaine, " ]\n [");
4996: }
4997: else
4998: {
4999: chaine = (unsigned char *) malloc(
5000: (strlen(chaine_sauvegarde) + 4)
5001: * sizeof(unsigned char));
5002:
5003: if (chaine == NULL)
5004: {
5005: (*s_etat_processus).erreur_systeme =
5006: d_es_allocation_memoire;
5007: return(NULL);
5008: }
5009:
5010: strcpy(chaine, chaine_sauvegarde);
5011: free(chaine_sauvegarde);
5012: strcat(chaine, " ][");
5013: }
5014: }
5015:
5016: if (test_cfsf(s_etat_processus, 45) == d_vrai)
5017: {
5018: chaine[strlen(chaine) - 3] = ']';
5019: chaine[strlen(chaine) - 2] = 0;
5020:
5021: chaine_sauvegarde = chaine;
5022: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
5023: + 1) * sizeof(unsigned char));
5024:
5025: if (chaine == NULL)
5026: {
5027: (*s_etat_processus).erreur_systeme =
5028: d_es_allocation_memoire;
5029: return(NULL);
5030: }
5031:
5032: strcpy(chaine, chaine_sauvegarde);
5033: free(chaine_sauvegarde);
5034: }
5035: else
5036: {
5037: chaine[strlen(chaine) - 2] = ']';
5038: chaine[strlen(chaine) - 1] = 0;
5039:
5040: chaine_sauvegarde = chaine;
5041: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
5042: + 2) * sizeof(unsigned char));
5043:
5044: if (chaine == NULL)
5045: {
5046: (*s_etat_processus).erreur_systeme =
5047: d_es_allocation_memoire;
5048: return(NULL);
5049: }
5050:
5051: strcpy(chaine, chaine_sauvegarde);
5052: free(chaine_sauvegarde);
5053: strcat(chaine, "]");
5054: }
5055: }
5056: }
5057: else if ((*s_objet).type == MRL)
5058: {
5059:
5060: /*
5061: --------------------------------------------------------------------------------
5062: Matrice réelle
5063: --------------------------------------------------------------------------------
5064: */
5065:
5066: if ((format_sortie != 'S') && (format_sortie != 'F') &&
5067: (format_sortie != 'I') && (format_sortie != 'E'))
5068: {
5069: (*s_etat_processus).erreur_execution =
5070: d_ex_erreur_format_fichier;
5071: return(NULL);
5072: }
5073:
5074: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
5075: .nombre_lignes;
5076: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
5077: .nombre_colonnes;
5078:
5079: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
5080:
5081: if (chaine != NULL)
5082: {
5083: strcpy(chaine, "[[");
5084:
5085: for(i = 0; i < nombre_lignes; i++)
5086: {
5087: for(j = 0; j < nombre_colonnes; j++)
5088: {
5089: if ((chaine_formatee =
5090: formateur_fichier_nombre(s_etat_processus,
5091: (void *) &(((real8 **) ((*((struct_matrice *)
5092: ((*s_objet).objet))).tableau))[i][j]), 'R',
5093: longueur, longueur_champ, format_sortie))
5094: == NULL)
5095: {
5096: (*s_etat_processus).erreur_systeme =
5097: d_es_allocation_memoire;
5098: return(NULL);
5099: }
5100:
5101: chaine_sauvegarde = chaine;
5102: chaine = (unsigned char *) malloc(
5103: (strlen(chaine_sauvegarde) +
5104: strlen(chaine_formatee) + 2)
5105: * sizeof(unsigned char));
5106:
5107: if (chaine == NULL)
5108: {
5109: (*s_etat_processus).erreur_systeme =
5110: d_es_allocation_memoire;
5111: return(NULL);
5112: }
5113:
5114: strcpy(chaine, chaine_sauvegarde);
5115: free(chaine_sauvegarde);
5116: strcat(chaine, " ");
5117: strcat(chaine, chaine_formatee);
5118: free(chaine_formatee);
5119: }
5120:
5121: chaine_sauvegarde = chaine;
5122: if (test_cfsf(s_etat_processus, 45) == d_vrai)
5123: {
5124: chaine = (unsigned char *) malloc(
5125: (strlen(chaine_sauvegarde) + 6)
5126: * sizeof(unsigned char));
5127:
5128: if (chaine == NULL)
5129: {
5130: (*s_etat_processus).erreur_systeme =
5131: d_es_allocation_memoire;
5132: return(NULL);
5133: }
5134:
5135: strcpy(chaine, chaine_sauvegarde);
5136: free(chaine_sauvegarde);
5137: strcat(chaine, " ]\n [");
5138: }
5139: else
5140: {
5141: chaine = (unsigned char *) malloc(
5142: (strlen(chaine_sauvegarde) + 4)
5143: * sizeof(unsigned char));
5144:
5145: if (chaine == NULL)
5146: {
5147: (*s_etat_processus).erreur_systeme =
5148: d_es_allocation_memoire;
5149: return(NULL);
5150: }
5151:
5152: strcpy(chaine, chaine_sauvegarde);
5153: free(chaine_sauvegarde);
5154: strcat(chaine, " ][");
5155: }
5156: }
5157:
5158: if (test_cfsf(s_etat_processus, 45) == d_vrai)
5159: {
5160: chaine[strlen(chaine) - 3] = ']';
5161: chaine[strlen(chaine) - 2] = 0;
5162:
5163: chaine_sauvegarde = chaine;
5164: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
5165: + 1) * sizeof(unsigned char));
5166:
5167: if (chaine == NULL)
5168: {
5169: (*s_etat_processus).erreur_systeme =
5170: d_es_allocation_memoire;
5171: return(NULL);
5172: }
5173:
5174: strcpy(chaine, chaine_sauvegarde);
5175: free(chaine_sauvegarde);
5176: }
5177: else
5178: {
5179: chaine[strlen(chaine) - 2] = ']';
5180: chaine[strlen(chaine) - 1] = 0;
5181:
5182: chaine_sauvegarde = chaine;
5183: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
5184: + 2) * sizeof(unsigned char));
5185:
5186: if (chaine == NULL)
5187: {
5188: (*s_etat_processus).erreur_systeme =
5189: d_es_allocation_memoire;
5190: return(NULL);
5191: }
5192:
5193: strcpy(chaine, chaine_sauvegarde);
5194: free(chaine_sauvegarde);
5195: strcat(chaine, "]");
5196: }
5197: }
5198: }
5199: else if ((*s_objet).type == NOM)
5200: {
5201:
5202: /*
5203: --------------------------------------------------------------------------------
5204: Nom
5205: --------------------------------------------------------------------------------
5206: */
5207:
5208: chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
5209: (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
5210:
5211: if (chaine == NULL)
5212: {
5213: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5214: return(NULL);
5215: }
5216:
5217: sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom);
5218: }
5219: else if ((*s_objet).type == REL)
5220: {
5221:
5222: /*
5223: --------------------------------------------------------------------------------
5224: Réel
5225: --------------------------------------------------------------------------------
5226: */
5227:
5228: if (format_sortie != 'R')
5229: {
5230: (*s_etat_processus).erreur_execution =
5231: d_ex_erreur_format_fichier;
5232: return(NULL);
5233: }
5234:
5235: if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
5236: (*s_objet).objet, 'R', longueur, longueur_effective))
5237: == NULL)
5238: {
5239: return(NULL);
5240: }
5241: }
5242: else if ((*s_objet).type == VCX)
5243: {
5244:
5245: /*
5246: --------------------------------------------------------------------------------
5247: Vecteur complexe
5248: --------------------------------------------------------------------------------
5249: */
5250:
5251: if ((format_sortie != 'S') && (format_sortie != 'F') &&
5252: (format_sortie != 'I') && (format_sortie != 'E'))
5253: {
5254: (*s_etat_processus).erreur_execution =
5255: d_ex_erreur_format_fichier;
5256: return(NULL);
5257: }
5258:
5259: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
5260: .taille;
5261:
5262: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
5263:
5264: if (chaine != NULL)
5265: {
5266: strcpy(chaine, "[");
5267:
5268: for(i = 0; i < nombre_colonnes; i++)
5269: {
5270: if ((chaine_formatee =
5271: formateur_fichier_nombre(s_etat_processus,
5272: (void *) &(((struct_complexe16 *)
5273: ((*((struct_vecteur *)
5274: ((*s_objet).objet))).tableau))[i]), 'C',
5275: longueur, longueur_champ, format_sortie)) == NULL)
5276: {
5277: (*s_etat_processus).erreur_systeme =
5278: d_es_allocation_memoire;
5279: return(NULL);
5280: }
5281:
5282: chaine_sauvegarde = chaine;
5283: chaine = (unsigned char *) malloc(
5284: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
5285: + 2) * sizeof(unsigned char));
5286:
5287: if (chaine == NULL)
5288: {
5289: (*s_etat_processus).erreur_systeme =
5290: d_es_allocation_memoire;
5291: return(NULL);
5292: }
5293:
5294: strcpy(chaine, chaine_sauvegarde);
5295: free(chaine_sauvegarde);
5296: strcat(chaine, " ");
5297: strcat(chaine, chaine_formatee);
5298: free(chaine_formatee);
5299: }
5300:
5301: chaine_sauvegarde = chaine;
5302: chaine = (unsigned char *) malloc(
5303: (strlen(chaine_sauvegarde) + 3)
5304: * sizeof(unsigned char));
5305:
5306: if (chaine == NULL)
5307: {
5308: (*s_etat_processus).erreur_systeme =
5309: d_es_allocation_memoire;
5310: return(NULL);
5311: }
5312:
5313: strcpy(chaine, chaine_sauvegarde);
5314: free(chaine_sauvegarde);
5315: strcat(chaine, " ]");
5316: }
5317: }
5318: else if ((*s_objet).type == VIN)
5319: {
5320:
5321: /*
5322: --------------------------------------------------------------------------------
5323: Vecteur entier
5324: --------------------------------------------------------------------------------
5325: */
5326:
5327: if ((format_sortie != 'S') && (format_sortie != 'F') &&
5328: (format_sortie != 'I') && (format_sortie != 'E'))
5329: {
5330: (*s_etat_processus).erreur_execution =
5331: d_ex_erreur_format_fichier;
5332: return(NULL);
5333: }
5334:
5335: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
5336: .taille;
5337:
5338: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
5339:
5340: if (chaine != NULL)
5341: {
5342: strcpy(chaine, "[");
5343:
5344: for(i = 0; i < nombre_colonnes; i++)
5345: {
5346: if ((chaine_formatee =
5347: formateur_fichier_nombre(s_etat_processus,
5348: (void *) &(((integer8 *) ((*((struct_vecteur *)
5349: ((*s_objet).objet))).tableau))[i]), 'I',
5350: longueur, longueur_champ, format_sortie)) == NULL)
5351: {
5352: (*s_etat_processus).erreur_systeme =
5353: d_es_allocation_memoire;
5354: return(NULL);
5355: }
5356:
5357: chaine_sauvegarde = chaine;
5358: chaine = (unsigned char *) malloc(
5359: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
5360: + 2) * sizeof(unsigned char));
5361:
5362: if (chaine == NULL)
5363: {
5364: (*s_etat_processus).erreur_systeme =
5365: d_es_allocation_memoire;
5366: return(NULL);
5367: }
5368:
5369: strcpy(chaine, chaine_sauvegarde);
5370: free(chaine_sauvegarde);
5371: strcat(chaine, " ");
5372: strcat(chaine, chaine_formatee);
5373: free(chaine_formatee);
5374: }
5375:
5376: chaine_sauvegarde = chaine;
5377: chaine = (unsigned char *) malloc(
5378: (strlen(chaine_sauvegarde) + 3)
5379: * sizeof(unsigned char));
5380:
5381: if (chaine == NULL)
5382: {
5383: (*s_etat_processus).erreur_systeme =
5384: d_es_allocation_memoire;
5385: return(NULL);
5386: }
5387:
5388: strcpy(chaine, chaine_sauvegarde);
5389: free(chaine_sauvegarde);
5390: strcat(chaine, " ]");
5391: }
5392: }
5393: else if ((*s_objet).type == VRL)
5394: {
5395:
5396: /*
5397: --------------------------------------------------------------------------------
5398: Vecteur réel
5399: --------------------------------------------------------------------------------
5400: */
5401:
5402: if ((format_sortie != 'S') && (format_sortie != 'F') &&
5403: (format_sortie != 'I') && (format_sortie != 'E'))
5404: {
5405: (*s_etat_processus).erreur_execution =
5406: d_ex_erreur_format_fichier;
5407: return(NULL);
5408: }
5409:
5410: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
5411: .taille;
5412:
5413: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
5414:
5415: if (chaine != NULL)
5416: {
5417: strcpy(chaine, "[");
5418:
5419: for(i = 0; i < nombre_colonnes; i++)
5420: {
5421: if ((chaine_formatee =
5422: formateur_fichier_nombre(s_etat_processus,
5423: (void *) &(((real8 *) ((*((struct_vecteur *)
5424: ((*s_objet).objet))).tableau))[i]), 'R',
5425: longueur, longueur_champ, format_sortie)) == NULL)
5426: {
5427: (*s_etat_processus).erreur_systeme =
5428: d_es_allocation_memoire;
5429: return(NULL);
5430: }
5431:
5432: chaine_sauvegarde = chaine;
5433: chaine = (unsigned char *) malloc(
5434: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
5435: + 2) * sizeof(unsigned char));
5436:
5437: if (chaine == NULL)
5438: {
5439: (*s_etat_processus).erreur_systeme =
5440: d_es_allocation_memoire;
5441: return(NULL);
5442: }
5443:
5444: strcpy(chaine, chaine_sauvegarde);
5445: free(chaine_sauvegarde);
5446: strcat(chaine, " ");
5447: strcat(chaine, chaine_formatee);
5448: free(chaine_formatee);
5449: }
5450:
5451: chaine_sauvegarde = chaine;
5452: chaine = (unsigned char *) malloc(
5453: (strlen(chaine_sauvegarde) + 3)
5454: * sizeof(unsigned char));
5455:
5456: if (chaine == NULL)
5457: {
5458: (*s_etat_processus).erreur_systeme =
5459: d_es_allocation_memoire;
5460: return(NULL);
5461: }
5462:
5463: strcpy(chaine, chaine_sauvegarde);
5464: free(chaine_sauvegarde);
5465: strcat(chaine, " ]");
5466: }
5467: }
5468: else
5469: {
5470: // Type non exportable
5471:
5472: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
5473: free(chaine);
5474:
5475: return(NULL);
5476: }
5477: }
5478:
5479: (*recursivite)--;
5480:
5481: return(chaine);
5482: }
5483:
5484:
5485: /*
5486: ================================================================================
5487: Routines qui transforment un nombre entier, réel ou complexe en chaîne de
5488: caractères suivant le format courant
5489: ================================================================================
5490: Entrées : pointeur générique sur la donnée numérique à convertir,
5491: type de l'entité (I, R ou C).
5492: --------------------------------------------------------------------------------
5493: Sorties : chaîne de caractères allouée dans la routine
5494: --------------------------------------------------------------------------------
5495: Effets de bord : néant
5496: ================================================================================
5497: */
5498:
5499: /*
5500: --------------------------------------------------------------------------------
5501: Formatage des complexes, réels et entiers
5502: --------------------------------------------------------------------------------
5503: */
5504:
5505: unsigned char *
5506: formateur_fichier_nombre(struct_processus *s_etat_processus,
5507: void *valeur_numerique, unsigned char type,
5508: long longueur, long longueur_champ, unsigned char format)
5509: {
5510: unsigned char *chaine;
5511: unsigned char *construction_chaine;
5512: unsigned char *sauvegarde;
5513: unsigned char *tampon;
5514:
5515: chaine = NULL;
5516:
5517: switch(type)
5518: {
5519: case 'C' :
5520: {
5521: construction_chaine = (unsigned char *) malloc(
5522: 2 * sizeof(unsigned char));
5523:
5524: if (construction_chaine == NULL)
5525: {
5526: (*s_etat_processus).erreur_systeme =
5527: d_es_allocation_memoire;
5528: return(NULL);
5529: }
5530:
5531: strcpy(construction_chaine, "(");
5532:
5533: tampon = formateur_fichier_reel(s_etat_processus,
5534: (void *) &((*((struct_complexe16 *)
5535: valeur_numerique)).partie_reelle), 'R',
5536: longueur, longueur_champ, format);
5537:
5538: if (tampon == NULL)
5539: {
5540: (*s_etat_processus).erreur_systeme =
5541: d_es_allocation_memoire;
5542: return(NULL);
5543: }
5544:
5545: sauvegarde = construction_chaine;
5546:
5547: construction_chaine = (unsigned char *) malloc(
5548: (strlen(sauvegarde) + strlen(tampon) + 2)
5549: * sizeof(unsigned char));
5550:
5551: if (construction_chaine == NULL)
5552: {
5553: (*s_etat_processus).erreur_systeme =
5554: d_es_allocation_memoire;
5555: return(NULL);
5556: }
5557:
5558: strcpy(construction_chaine, sauvegarde);
5559: free(sauvegarde);
5560: strcat(construction_chaine, tampon);
5561: free(tampon);
5562:
5563: strcat(construction_chaine, ",");
5564:
5565: tampon = formateur_fichier_reel(s_etat_processus,
5566: (void *) &((*((struct_complexe16 *)
5567: valeur_numerique)).partie_imaginaire), 'R',
5568: longueur, longueur_champ, format);
5569:
5570: if (tampon == NULL)
5571: {
5572: (*s_etat_processus).erreur_systeme =
5573: d_es_allocation_memoire;
5574: return(NULL);
5575: }
5576:
5577: sauvegarde = construction_chaine;
5578:
5579: construction_chaine = (unsigned char *) malloc(
5580: (strlen(sauvegarde) + strlen(tampon) + 2)
5581: * sizeof(unsigned char));
5582:
5583: if (construction_chaine == NULL)
5584: {
5585: (*s_etat_processus).erreur_systeme =
5586: d_es_allocation_memoire;
5587: return(NULL);
5588: }
5589:
5590: strcpy(construction_chaine, sauvegarde);
5591: free(sauvegarde);
5592: strcat(construction_chaine, tampon);
5593: free(tampon);
5594: strcat(construction_chaine, ")");
5595:
5596: chaine = construction_chaine;
5597:
5598: break;
5599: }
5600:
5601: case 'R' :
5602: {
5603: chaine = formateur_fichier_reel(s_etat_processus,
5604: valeur_numerique, 'R', longueur, longueur_champ,
5605: format);
5606:
5607: if (chaine == NULL)
5608: {
5609: (*s_etat_processus).erreur_systeme =
5610: d_es_allocation_memoire;
5611: return(NULL);
5612: }
5613:
5614: break;
5615: }
5616:
5617: default :
5618: case 'I' :
5619: {
5620: chaine = formateur_fichier_reel(s_etat_processus,
5621: valeur_numerique, 'I', longueur, longueur_champ,
5622: format);
5623:
5624: if (chaine == NULL)
5625: {
5626: (*s_etat_processus).erreur_systeme =
5627: d_es_allocation_memoire;
5628: return(NULL);
5629: }
5630:
5631: break;
5632: }
5633: }
5634:
5635: return(chaine);
5636: }
5637:
5638:
5639: /*
5640: --------------------------------------------------------------------------------
5641: Formateur des réels et entiers
5642: --------------------------------------------------------------------------------
5643: */
5644:
5645: unsigned char *
5646: formateur_fichier_reel(struct_processus *s_etat_processus,
5647: void *valeur_numerique, unsigned char type,
5648: long longueur, long longueur_champ,
5649: unsigned char format_sortie)
5650: {
5651: real8 mantisse;
5652: real8 tampon_reel;
5653:
5654: integer8 tampon_entier;
5655:
5656: long correction;
5657: long exposant;
5658: long longueur_utile;
5659: long longueur_utile_limite;
5660:
5661: unsigned char *chaine;
5662: unsigned char format[16 + 1];
5663: unsigned char mode[3 + 1];
5664: unsigned char tampon[16 + 1];
5665:
5666: unsigned long i;
5667:
5668: chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
5669:
5670: if (chaine == NULL)
5671: {
5672: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
5673: return(NULL);
5674: }
5675:
5676: if (type == 'R')
5677: {
5678: tampon_reel = *((real8 *) valeur_numerique);
5679:
5680: if (tampon_reel > ((real8) 0))
5681: {
5682: exposant = (long) floor(log10(tampon_reel));
5683: }
5684: else if (tampon_reel < ((real8) 0))
5685: {
5686: exposant = (long) floor(log10(-tampon_reel));
5687: }
5688: else
5689: {
5690: exposant = 0;
5691: }
5692:
5693: mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
5694: }
5695: else
5696: {
5697: tampon_entier = *((integer8 *) valeur_numerique);
5698:
5699: if (tampon_entier > ((integer8) 0))
5700: {
5701: exposant = (long) floor(log10(tampon_entier));
5702: }
5703: else if (tampon_entier < ((integer8) 0))
5704: {
5705: exposant = (long) floor(log10(-tampon_entier));
5706: }
5707: else
5708: {
5709: exposant = 0;
5710: }
5711:
5712: mantisse = (*((integer8 *) valeur_numerique)) / pow(10, exposant);
5713: }
5714:
5715: longueur_utile = longueur;
5716: longueur_utile_limite = 15;
5717:
5718: if (longueur_utile > longueur_utile_limite)
5719: {
5720: longueur_utile = longueur_utile_limite;
5721: }
5722:
5723: if (format_sortie == 'S')
5724: {
5725: strcpy(mode, "STD");
5726: }
5727: else if (format_sortie == 'C')
5728: {
5729: strcpy(mode, "SCI");
5730: }
5731: else if (format_sortie == 'F')
5732: {
5733: strcpy(mode, "FIX");
5734: }
5735: else
5736: {
5737: strcpy(mode, "ENG");
5738: }
5739:
5740: if ((strcmp(mode, "SCI") == 0) ||
5741: ((strcmp(mode, "STD") == 0) && ((exposant >
5742: longueur_utile_limite) ||
5743: (exposant < -longueur_utile_limite))) ||
5744: ((strcmp(mode, "FIX") == 0) &&
5745: ((exposant >= longueur_utile_limite) ||
5746: (exposant < -longueur_utile))))
5747: {
5748: chaine[0] = 0;
5749: format[0] = 0;
5750:
5751: if (strcmp(mode, "STD") == 0)
5752: {
5753: longueur_utile = longueur_utile_limite - 1;
5754: }
5755:
5756: sprintf(format, "%%.%luf", longueur_utile);
5757:
5758: sprintf(tampon, format, mantisse);
5759: strcpy(chaine, tampon);
5760: strcat(chaine, "E");
5761: sprintf(tampon, "%ld", exposant);
5762: strcat(chaine, tampon);
5763: }
5764: else if (strcmp(mode, "FIX") == 0)
5765: {
5766: chaine[0] = 0;
5767: format[0] = 0;
5768:
5769: if (longueur_utile + exposant >= longueur_utile_limite)
5770: {
5771: longueur_utile = longueur_utile_limite - (exposant + 1);
5772: }
5773:
5774: sprintf(format, "%%.%luf", longueur_utile);
5775:
5776: sprintf(tampon, format, (mantisse * pow(10, exposant)));
5777: strcpy(chaine, tampon);
5778: }
5779: else if (strcmp(mode, "ENG") == 0)
5780: {
5781: chaine[0] = 0;
5782: format[0] = 0;
5783:
5784: correction = labs(exposant) % 3;
5785:
5786: if (exposant < 0)
5787: {
5788: if (correction == 0)
5789: {
5790: correction = 3;
5791: }
5792:
5793: correction = 3 - correction;
5794: }
5795:
5796: longueur_utile -= correction;
5797: sprintf(format, "%%.%luf", longueur_utile);
5798:
5799: sprintf(tampon, format, (mantisse * pow(10, correction)));
5800: strcpy(chaine, tampon);
5801: strcat(chaine, "E");
5802: sprintf(tampon, "%ld", (exposant - correction));
5803: strcat(chaine, tampon);
5804: }
5805: else
5806: {
5807: if (type == 'I')
5808: {
5809: chaine[0] = 0;
5810: sprintf(tampon, "%lld", *((integer8 *) valeur_numerique));
5811: }
5812: else
5813: {
5814: chaine[0] = 0;
5815: format[0] = 0;
5816:
5817: if (exposant >= 0)
5818: {
5819: sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
5820: - 1));
5821: }
5822: else
5823: {
5824: sprintf(format, "%%.%luf", longueur_utile_limite);
5825: }
5826:
5827: sprintf(tampon, format, *((real8 *) valeur_numerique));
5828:
5829: i = strlen(tampon) - 1;
5830: while(tampon[i] == '0')
5831: {
5832: tampon[i] = 0;
5833: i--;
5834: }
5835:
5836: if (ds_imposition_separateur_decimal == d_faux)
5837: {
5838: i = strlen(tampon) - 1;
5839: if (tampon[i] == '.')
5840: {
5841: tampon[i] = 0;
5842: }
5843: }
5844: }
5845: strcpy(chaine, tampon);
5846: }
5847:
5848: if (longueur_champ >= 0)
5849: {
5850: if (strlen(chaine) > (size_t) longueur_champ)
5851: {
5852: for(i = 0; i < (unsigned long) longueur_champ; i++)
5853: {
5854: chaine[i] = '*';
5855: }
5856:
5857: chaine[i] = d_code_fin_chaine;
5858: }
5859: }
5860:
5861: return(chaine);
5862: }
5863:
5864:
5865: /*
5866: --------------------------------------------------------------------------------
5867: Mêmes fonctions mais pour les fichiers binaires
5868: --------------------------------------------------------------------------------
5869: */
5870:
5871: unsigned char *
5872: formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,
5873: void *valeur_numerique, unsigned char type, long longueur,
5874: long *longueur_conversion)
5875: {
5876: unsigned char *chaine;
5877:
5878: switch(type)
5879: {
5880: default :
5881: case 'I' :
5882: {
5883: switch(longueur)
5884: {
5885: case 1:
5886: {
5887: if ((*((integer8 *) valeur_numerique)) !=
5888: ((integer1) (*((integer8 *) valeur_numerique))))
5889: {
5890: (*s_etat_processus).erreur_execution =
5891: d_ex_representation;
5892: return(NULL);
5893: }
5894:
5895: if ((chaine = malloc(2 * sizeof(unsigned char))) == NULL)
5896: {
5897: (*s_etat_processus).erreur_systeme =
5898: d_es_allocation_memoire;
5899: return(NULL);
5900: }
5901:
5902: (*longueur_conversion) = 2;
5903: chaine[0] = 0x10;
5904: chaine[1] = (*((integer8 *) valeur_numerique)) & 0xFF;
5905: break;
5906: }
5907:
5908: case 2:
5909: {
5910: if ((*((integer8 *) valeur_numerique)) !=
5911: ((integer2) (*((integer8 *) valeur_numerique))))
5912: {
5913: (*s_etat_processus).erreur_execution =
5914: d_ex_representation;
5915: return(NULL);
5916: }
5917:
5918: if ((chaine = malloc(3 * sizeof(unsigned char))) == NULL)
5919: {
5920: (*s_etat_processus).erreur_systeme =
5921: d_es_allocation_memoire;
5922: return(NULL);
5923: }
5924:
5925: (*longueur_conversion) = 3;
5926: chaine[0] = 0x11;
5927: chaine[1] = ((*((integer8 *) valeur_numerique)) >> 8)
5928: & 0xFF;
5929: chaine[2] = (*((integer8 *) valeur_numerique)) & 0xFF;
5930: break;
5931: }
5932:
5933: case 4:
5934: {
5935: if ((*((integer8 *) valeur_numerique)) !=
5936: ((integer2) (*((integer8 *) valeur_numerique))))
5937: {
5938: (*s_etat_processus).erreur_execution =
5939: d_ex_representation;
5940: return(NULL);
5941: }
5942:
5943: if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
5944: {
5945: (*s_etat_processus).erreur_systeme =
5946: d_es_allocation_memoire;
5947: return(NULL);
5948: }
5949:
5950: (*longueur_conversion) = 5;
5951: chaine[0] = 0x12;
5952: chaine[1] = ((*((integer8 *) valeur_numerique)) >> 24)
5953: & 0xFF;
5954: chaine[2] = ((*((integer8 *) valeur_numerique)) >> 16)
5955: & 0xFF;
5956: chaine[3] = ((*((integer8 *) valeur_numerique)) >> 8)
5957: & 0xFF;
5958: chaine[4] = (*((integer8 *) valeur_numerique)) & 0xFF;
5959: break;
5960: }
5961:
5962: case 8:
5963: {
5964: if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
5965: {
5966: (*s_etat_processus).erreur_systeme =
5967: d_es_allocation_memoire;
5968: return(NULL);
5969: }
5970:
5971: (*longueur_conversion) = 9;
5972: chaine[0] = 0x13;
5973: chaine[1] = ((*((integer8 *) valeur_numerique)) >> 56)
5974: & 0xFF;
5975: chaine[2] = ((*((integer8 *) valeur_numerique)) >> 48)
5976: & 0xFF;
5977: chaine[3] = ((*((integer8 *) valeur_numerique)) >> 40)
5978: & 0xFF;
5979: chaine[4] = ((*((integer8 *) valeur_numerique)) >> 32)
5980: & 0xFF;
5981: chaine[5] = ((*((integer8 *) valeur_numerique)) >> 24)
5982: & 0xFF;
5983: chaine[6] = ((*((integer8 *) valeur_numerique)) >> 16)
5984: & 0xFF;
5985: chaine[7] = ((*((integer8 *) valeur_numerique)) >> 8)
5986: & 0xFF;
5987: chaine[8] = (*((integer8 *) valeur_numerique)) & 0xFF;
5988: break;
5989: }
5990:
5991: default :
5992: {
5993: (*s_etat_processus).erreur_execution =
5994: d_ex_erreur_format_fichier;
5995: return(NULL);
5996: }
5997: }
5998:
5999: break;
6000: }
6001:
6002: case 'R' :
6003: {
6004: switch(longueur)
6005: {
6006: case 4:
6007: {
6008: double vinf;
6009: double vsup;
6010:
6011: union
6012: {
6013: real4 r4;
6014: integer4 i4;
6015: } eq4;
6016:
6017: if ((*((real8 *) valeur_numerique)) > 0)
6018: {
6019: vinf = nextafter((*((real8 *) valeur_numerique)), 0);
6020: vsup = nextafter((*((real8 *) valeur_numerique)),
6021: (*((real8 *) valeur_numerique)) * 2);
6022: }
6023: else
6024: {
6025: vinf = nextafter((*((real8 *) valeur_numerique)),
6026: (*((real8 *) valeur_numerique)) * 2);
6027: vsup = nextafter((*((real8 *) valeur_numerique)), 0);
6028: }
6029:
6030: if (!((vinf <= ((real4) (*((real8 *) valeur_numerique)))) &&
6031: ((real4) ((*((real8 *) valeur_numerique)))
6032: <= vsup)))
6033: {
6034: (*s_etat_processus).erreur_execution =
6035: d_ex_representation;
6036: return(NULL);
6037: }
6038:
6039: if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
6040: {
6041: (*s_etat_processus).erreur_systeme =
6042: d_es_allocation_memoire;
6043: return(NULL);
6044: }
6045:
6046: eq4.r4 = (real4) (*((real8 *) valeur_numerique));
6047: (*longueur_conversion) = 5;
6048: chaine[0] = 0x12;
6049: chaine[1] = (eq4.i4 >> 24) & 0xFF;
6050: chaine[2] = (eq4.i4 >> 16) & 0xFF;
6051: chaine[3] = (eq4.i4 >> 8) & 0xFF;
6052: chaine[4] = eq4.i4 & 0xFF;
6053: break;
6054: }
6055:
6056: case 8:
6057: {
6058: union
6059: {
6060: real8 r8;
6061: integer8 i8;
6062: } eq8;
6063:
6064: if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
6065: {
6066: (*s_etat_processus).erreur_systeme =
6067: d_es_allocation_memoire;
6068: return(NULL);
6069: }
6070:
6071: eq8.r8 = (*((real8 *) valeur_numerique));
6072:
6073: (*longueur_conversion) = 9;
6074: chaine[0] = 0x13;
6075: chaine[1] = (eq8.i8 >> 56) & 0xFF;
6076: chaine[2] = (eq8.i8 >> 48) & 0xFF;
6077: chaine[3] = (eq8.i8 >> 40) & 0xFF;
6078: chaine[4] = (eq8.i8 >> 32) & 0xFF;
6079: chaine[5] = (eq8.i8 >> 24) & 0xFF;
6080: chaine[6] = (eq8.i8 >> 16) & 0xFF;
6081: chaine[7] = (eq8.i8 >> 8) & 0xFF;
6082: chaine[8] = eq8.i8 & 0xFF;
6083: break;
6084: }
6085:
6086: default :
6087: {
6088: (*s_etat_processus).erreur_execution =
6089: d_ex_erreur_format_fichier;
6090: return(NULL);
6091: }
6092: }
6093:
6094: break;
6095: }
6096:
6097: case 'C' :
6098: {
6099: switch(longueur)
6100: {
6101: case 8:
6102: {
6103: unsigned char *partie_reelle;
6104: unsigned char *partie_imaginaire;
6105:
6106: long limag;
6107: long lreel;
6108:
6109: if ((partie_reelle = formateur_fichier_binaire_nombre(
6110: s_etat_processus, &((*((complex16 *)
6111: valeur_numerique)).partie_reelle), 'R', 4, &lreel))
6112: == NULL)
6113: {
6114: return(NULL);
6115: }
6116:
6117: if ((partie_imaginaire = formateur_fichier_binaire_nombre(
6118: s_etat_processus, &((*((complex16 *)
6119: valeur_numerique)).partie_imaginaire), 'R', 4,
6120: &limag)) == NULL)
6121: {
6122: free(partie_reelle);
6123: return(NULL);
6124: }
6125:
6126: if ((chaine = malloc((lreel + limag - 1) *
6127: sizeof(unsigned char))) == NULL)
6128: {
6129: free(partie_reelle);
6130: free(partie_imaginaire);
6131:
6132: (*s_etat_processus).erreur_systeme =
6133: d_es_allocation_memoire;
6134: return(NULL);
6135: }
6136:
6137: chaine[0] = 0x18;
6138: memcpy(chaine + 1, partie_reelle + 1, lreel - 1);
6139: memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);
6140: (*longueur_conversion) = lreel + limag - 1;
6141:
6142: free(partie_reelle);
6143: free(partie_imaginaire);
6144: break;
6145: }
6146:
6147: case 16:
6148: {
6149: unsigned char *partie_reelle;
6150: unsigned char *partie_imaginaire;
6151:
6152: long limag;
6153: long lreel;
6154:
6155: if ((partie_reelle = formateur_fichier_binaire_nombre(
6156: s_etat_processus, &((*((complex16 *)
6157: valeur_numerique)).partie_reelle), 'R', 8, &lreel))
6158: == NULL)
6159: {
6160: return(NULL);
6161: }
6162:
6163: if ((partie_imaginaire = formateur_fichier_binaire_nombre(
6164: s_etat_processus, &((*((complex16 *)
6165: valeur_numerique)).partie_imaginaire), 'R', 8,
6166: &limag)) == NULL)
6167: {
6168: free(partie_reelle);
6169: return(NULL);
6170: }
6171:
6172: if ((chaine = malloc((lreel + limag - 1) *
6173: sizeof(unsigned char))) == NULL)
6174: {
6175: free(partie_reelle);
6176: free(partie_imaginaire);
6177:
6178: (*s_etat_processus).erreur_systeme =
6179: d_es_allocation_memoire;
6180: return(NULL);
6181: }
6182:
6183: chaine[0] = 0x19;
6184: memcpy(chaine + 1, partie_reelle + 1, lreel - 1);
6185: memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);
6186: (*longueur_conversion) = lreel + limag - 1;
6187:
6188: free(partie_reelle);
6189: free(partie_imaginaire);
6190: break;
6191: }
6192:
6193: default :
6194: {
6195: (*s_etat_processus).erreur_execution =
6196: d_ex_erreur_format_fichier;
6197: return(NULL);
6198: }
6199: }
6200:
6201: break;
6202: }
6203: }
6204:
6205: return(chaine);
6206: }
6207:
6208: // 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