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