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