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