1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.13
4: Copyright (C) 1989-2013 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Routine de formation des données pour l'affichage
29: ================================================================================
30: Entrées : structure sur l'état du processus et objet à afficher
31: --------------------------------------------------------------------------------
32: Sorties : chaine de caractères
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: unsigned char *
39: formateur(struct_processus *s_etat_processus, long offset_initial,
40: struct_objet *s_objet)
41: {
42: int parentheses_groupe_gauche;
43: int parentheses_groupe_droit;
44:
45: logical1 registre45;
46:
47: logical4 autorisation_parenthese;
48: logical4 presence_signe;
49:
50: logical8 masque_binaire;
51:
52: struct_liste_chainee *l_atome;
53: struct_liste_chainee *l_element_courant;
54: struct_liste_chainee *l_liste1;
55: struct_liste_chainee *l_liste2;
56:
57: struct_objet *s_sous_objet;
58: struct_objet *s_sous_objet_1;
59: struct_objet *s_sous_objet_2;
60: struct_objet *s_sous_objet_3;
61:
62: unsigned char base[1 + 1];
63: unsigned char *chaine;
64: unsigned char *chaine_fonction;
65: unsigned char *chaine_formatee;
66: unsigned char *chaine_tampon;
67: unsigned char *chaine_sauvegarde;
68: unsigned char *format;
69: unsigned char *format_majuscule;
70: unsigned char *ptre;
71: unsigned char *ptrl;
72: unsigned char *registre;
73: unsigned char tampon[1024 + 1];
74:
75: integer8 i;
76: integer8 j;
77: integer8 k;
78: integer8 longueur_chaine;
79: integer8 longueur_courante;
80: integer8 longueur_decimale_courante;
81: integer8 *longueurs_maximales;
82: integer8 nombre_arguments;
83: integer8 nombre_arguments_fonction;
84: integer8 nombre_colonnes;
85: integer8 nombre_elements;
86: integer8 nombre_lignes;
87: integer8 offset;
88:
89: chaine = NULL;
90: chaine_formatee = NULL;
91: chaine_sauvegarde = NULL;
92:
93: strcpy(base, " ");
94:
95: masque_binaire = 0;
96:
97: if ((*s_objet).type == ADR)
98: {
99:
100: /*
101: --------------------------------------------------------------------------------
102: Adresse
103: --------------------------------------------------------------------------------
104: */
105:
106: if (alsprintf(&chaine, "@ %016lX", (*((integer8 *)
107: ((*s_objet).objet)))) < 0)
108: {
109: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
110: return(NULL);
111: }
112: }
113: else if ((*s_objet).type == SLB)
114: {
115:
116: /*
117: --------------------------------------------------------------------------------
118: Bibliothèque partagée
119: --------------------------------------------------------------------------------
120: */
121:
122: if (alsprintf(&chaine, "Library $ %016lX [%s]",
123: (integer8) (*((struct_bibliotheque *)
124: (*s_objet).objet)).descripteur, (*((struct_bibliotheque *)
125: (*s_objet).objet)).nom) < 0)
126: {
127: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
128: return(NULL);
129: }
130: }
131: else if ((*s_objet).type == SPH)
132: {
133:
134: /*
135: --------------------------------------------------------------------------------
136: Sémaphore
137: --------------------------------------------------------------------------------
138: */
139:
140: if (alsprintf(&chaine, "Semaphore $ %016lX '%s'",
141: &((*((struct_semaphore *) (*s_objet).objet)).semaphore),
142: (*((struct_semaphore *) (*s_objet).objet)).nom) < 0)
143: {
144: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
145: return(NULL);
146: }
147: }
148: else if ((*s_objet).type == SQL)
149: {
150:
151: /*
152: --------------------------------------------------------------------------------
153: Connecteur SQL
154: --------------------------------------------------------------------------------
155: */
156:
157: if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type,
158: "MYSQL") == 0)
159: {
160: # ifdef MYSQL_SUPPORT
161: if (alsprintf(&chaine, "Sql $ %016lX (%s)",
162: (long unsigned int) (*((struct_connecteur_sql *)
163: (*s_objet).objet)).descripteur.mysql,
164: (*((struct_connecteur_sql *) (*s_objet).objet)).type) < 0)
165: {
166: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
167: return(NULL);
168: }
169: # else
170: if ((*s_etat_processus).langue == 'F')
171: {
172: printf("+++Attention : Support de MySQL "
173: "non compilé !\n");
174: }
175: else
176: {
177: printf("+++Warning : MySQL support "
178: "not available !\n");
179: }
180:
181: fflush(stdout);
182: # endif
183: }
184: else if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type,
185: "POSTGRESQL") == 0)
186: {
187: # ifdef POSTGRESQL_SUPPORT
188: if (alsprintf(&chaine, "Sql $ %016lX (%s)",
189: (long unsigned int) (*((struct_connecteur_sql *)
190: (*s_objet).objet)).descripteur.postgresql,
191: (*((struct_connecteur_sql *) (*s_objet).objet)).type) < 0)
192: {
193: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
194: return(NULL);
195: }
196: # else
197: if ((*s_etat_processus).langue == 'F')
198: {
199: printf("+++Attention : Support de PostgreSQL "
200: "non compilé !\n");
201: }
202: else
203: {
204: printf("+++Warning : PostgreSQL support "
205: "not available !\n");
206: }
207:
208: fflush(stdout);
209: # endif
210: }
211: else
212: {
213: BUG(1, printf("SQL type '%s' not allowed!",
214: (*((struct_connecteur_sql *) (*s_objet).objet))
215: .type));
216: }
217: }
218: else if ((*s_objet).type == PRC)
219: {
220:
221: /*
222: --------------------------------------------------------------------------------
223: Processus
224: --------------------------------------------------------------------------------
225: */
226:
227: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
228: .processus_detache == d_vrai)
229: {
230: if (alsprintf(&chaine, "Process $ %016lX", (integer8)
231: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
232: .pid) < 0)
233: {
234: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
235: return(NULL);
236: }
237: }
238: else
239: {
240: if (alsprintf(&chaine, "Light weight process $ %016lX/%016lX",
241: (integer8) (*(*((struct_processus_fils *)
242: (*s_objet).objet)).thread).pid,
243: (integer8) (*(*((struct_processus_fils *)
244: (*s_objet).objet)).thread).tid) < 0)
245: {
246: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
247: return(NULL);
248: }
249: }
250: }
251: else if ((*s_objet).type == FCH)
252: {
253:
254: /*
255: --------------------------------------------------------------------------------
256: Fichier
257: --------------------------------------------------------------------------------
258: */
259:
260: if (alsprintf(&chaine, "File $ %016lX", (unsigned long)
261: (*((struct_fichier *) ((*s_objet).objet))).descripteur) < 0)
262: {
263: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
264: return(NULL);
265: }
266:
267: registre45 = test_cfsf(s_etat_processus, 45);
268: cf(s_etat_processus, 45);
269:
270: if ((format = formateur(s_etat_processus, 0, (*((struct_fichier *)
271: ((*s_objet).objet))).format)) == NULL)
272: {
273: return(NULL);
274: }
275:
276: if (registre45 == d_vrai)
277: {
278: sf(s_etat_processus, 45);
279: }
280: else
281: {
282: cf(s_etat_processus, 45);
283: }
284:
285: if ((format_majuscule = conversion_majuscule(format)) == NULL)
286: {
287: return(NULL);
288: }
289:
290: free(format);
291:
292: registre = chaine;
293:
294: if ((chaine = malloc((strlen(registre) + 1 +
295: strlen(format_majuscule) + 1) * sizeof(unsigned char)))
296: == NULL)
297: {
298: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
299: return(NULL);
300: }
301:
302: sprintf(chaine, "%s %s", registre, format_majuscule);
303: free(registre);
304:
305: tampon[0] = d_code_fin_chaine;
306:
307: if ((*((struct_fichier *) ((*s_objet).objet))).acces == 'S')
308: {
309: strcat(tampon, "SEQUENTIAL, ");
310: }
311: else if ((*((struct_fichier *) ((*s_objet).objet))).acces == 'D')
312: {
313: strcat(tampon, "DIRECT, ");
314: }
315: else
316: {
317: strcat(tampon, "KEYED, ");
318: }
319:
320: if ((*((struct_fichier *) ((*s_objet).objet))).binaire == 'N')
321: {
322: strcat(tampon, "FORMATTED, ");
323: }
324: else if ((*((struct_fichier *) ((*s_objet).objet))).binaire == 'Y')
325: {
326: strcat(tampon, "UNFORMATTED, ");
327: }
328: else
329: {
330: strcat(tampon, "FLOW, ");
331: }
332:
333: if ((*((struct_fichier *) ((*s_objet).objet))).ouverture == 'N')
334: {
335: strcat(tampon, "NEW, ");
336: }
337: else if ((*((struct_fichier *) ((*s_objet).objet))).ouverture == 'O')
338: {
339: strcat(tampon, "OLD, ");
340: }
341: else if ((*((struct_fichier *) ((*s_objet).objet))).ouverture == 'R')
342: {
343: strcat(tampon, "REPLACE, ");
344: }
345: else if ((*((struct_fichier *) ((*s_objet).objet))).ouverture == 'U')
346: {
347: strcat(tampon, "UNKNOWN, ");
348: }
349: else
350: {
351: strcat(tampon, "SCRATCH, ");
352: }
353:
354: if ((*((struct_fichier *) ((*s_objet).objet))).protection == 'R')
355: {
356: strcat(tampon, "READONLY");
357: }
358: else if ((*((struct_fichier *) ((*s_objet).objet))).protection == 'W')
359: {
360: strcat(tampon, "WRITEONLY");
361: }
362: else
363: {
364: strcat(tampon, "READWRITE");
365: }
366:
367: registre = chaine;
368:
369: if ((chaine = malloc((strlen(chaine) + 6 + strlen(tampon) +
370: strlen((*((struct_fichier *) ((*s_objet).objet))).nom) + 1) *
371: sizeof(unsigned char))) == NULL)
372: {
373: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
374: return(NULL);
375: }
376:
377: sprintf(chaine, "%s [%s <%s>]", registre, (*((struct_fichier *)
378: ((*s_objet).objet))).nom, tampon);
379: free(registre);
380:
381: free(format_majuscule);
382: }
383: else if ((*s_objet).type == SCK)
384: {
385:
386: /*
387: --------------------------------------------------------------------------------
388: Socket
389: --------------------------------------------------------------------------------
390: */
391:
392: if (alsprintf(&chaine, "Socket $ %016lX",
393: (unsigned long) (*((struct_socket *)
394: ((*s_objet).objet))).socket) < 0)
395: {
396: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
397: return(NULL);
398: }
399:
400: registre45 = test_cfsf(s_etat_processus, 45);
401: cf(s_etat_processus, 45);
402:
403: if ((format = formateur(s_etat_processus, 0, (*((struct_socket *)
404: ((*s_objet).objet))).format)) == NULL)
405: {
406: return(NULL);
407: }
408:
409: if (registre45 == d_vrai)
410: {
411: sf(s_etat_processus, 45);
412: }
413: else
414: {
415: cf(s_etat_processus, 45);
416: }
417:
418: if ((format_majuscule = conversion_majuscule(format)) == NULL)
419: {
420: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
421: return(NULL);
422: }
423:
424: free(format);
425:
426: registre = chaine;
427:
428: if ((chaine = malloc((strlen(registre) + 1 +
429: strlen(format_majuscule) + 1) * sizeof(unsigned char)))
430: == NULL)
431: {
432: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
433: return(NULL);
434: }
435:
436: sprintf(chaine, "%s %s", registre, format_majuscule);
437: free(registre);
438:
439: tampon[0] = d_code_fin_chaine;
440:
441: strcat(tampon, (*((struct_socket *) ((*s_objet).objet))).type);
442: strcat(tampon, ", ");
443:
444: if ((*((struct_socket *) ((*s_objet).objet))).domaine == PF_UNIX)
445: {
446: strcat(tampon, "UNIX, ");
447: }
448: else if ((*((struct_socket *) ((*s_objet).objet))).domaine == PF_INET)
449: {
450: strcat(tampon, "IPV4, ");
451: }
452: else if ((*((struct_socket *) ((*s_objet).objet))).domaine == PF_INET6)
453: {
454: strcat(tampon, "IPV6, ");
455: }
456:
457: if ((*((struct_socket *) ((*s_objet).objet))).localisation == 'L')
458: {
459: strcat(tampon, "LOCAL, ");
460: }
461: else
462: {
463: strcat(tampon, "FOREIGN, ");
464: }
465:
466: if ((*((struct_socket *) ((*s_objet).objet))).binaire == 'N')
467: {
468: strcat(tampon, "FORMATTED, ");
469: }
470: else if ((*((struct_socket *) ((*s_objet).objet))).binaire == 'Y')
471: {
472: strcat(tampon, "UNFORMATTED, ");
473: }
474: else
475: {
476: strcat(tampon, "FLOW, ");
477: }
478:
479: if ((*((struct_socket *) ((*s_objet).objet))).protection == 'R')
480: {
481: strcat(tampon, "READONLY");
482: }
483: else if ((*((struct_fichier *) ((*s_objet).objet))).protection == 'W')
484: {
485: strcat(tampon, "WRITEONLY");
486: }
487: else
488: {
489: strcat(tampon, "READWRITE");
490: }
491:
492: registre = chaine;
493:
494: if ((*((struct_socket *) ((*s_objet).objet))).localisation == 'L')
495: { // Socket locale
496: if ((strcmp((*((struct_socket *) ((*s_objet).objet))).type,
497: "STREAM") == 0) || (strcmp((*((struct_socket *)
498: ((*s_objet).objet))).type, "SEQUENTIAL DATAGRAM") == 0))
499: {
500: if (strcmp((*((struct_socket *) ((*s_objet).objet)))
501: .adresse_distante, "") == 0)
502: { // Socket connectée en écoute
503: if ((chaine = malloc((strlen(registre) + 16 +
504: strlen(tampon) + strlen((*((struct_socket *)
505: ((*s_objet).objet))).adresse) +
506: + 1) * sizeof(unsigned char))) == NULL)
507: {
508: (*s_etat_processus).erreur_systeme =
509: d_es_allocation_memoire;
510: return(NULL);
511: }
512:
513: sprintf(chaine, "%s [%s LISTENING <%s>]", registre,
514: (*((struct_socket *) ((*s_objet).objet))).adresse,
515: tampon);
516: }
517: else
518: { // Socket connecté
519: if ((chaine = malloc((strlen(registre) + 12 +
520: strlen(tampon) + strlen((*((struct_socket *)
521: ((*s_objet).objet))).adresse) +
522: strlen((*((struct_socket *) ((*s_objet).objet)))
523: .adresse_distante)
524: + 1) * sizeof(unsigned char))) == NULL)
525: {
526: (*s_etat_processus).erreur_systeme =
527: d_es_allocation_memoire;
528: return(NULL);
529: }
530:
531: sprintf(chaine, "%s [%s FROM %s <%s>]", registre,
532: (*((struct_socket *) ((*s_objet).objet))).adresse,
533: (*((struct_socket *) ((*s_objet).objet)))
534: .adresse_distante, tampon);
535: }
536: }
537: else // Socket non connectée
538: {
539: if ((chaine = malloc((strlen(registre) + 6 +
540: strlen(tampon) + strlen((*((struct_socket *)
541: ((*s_objet).objet))).adresse) +
542: + 1) * sizeof(unsigned char))) == NULL)
543: {
544: (*s_etat_processus).erreur_systeme =
545: d_es_allocation_memoire;
546: return(NULL);
547: }
548:
549: sprintf(chaine, "%s [%s <%s>]", registre,
550: (*((struct_socket *) ((*s_objet).objet))).adresse,
551: tampon);
552: }
553: }
554: else
555: { // Socket distante
556: if ((strcmp((*((struct_socket *) ((*s_objet).objet))).type,
557: "STREAM") == 0) || (strcmp((*((struct_socket *)
558: ((*s_objet).objet))).type, "SEQUENTIAL DATAGRAM") == 0))
559: {
560: if ((chaine = malloc((strlen(registre) + 9 +
561: strlen((*((struct_socket *) ((*s_objet).objet)))
562: .adresse) + strlen(tampon)
563: + 1) * sizeof(unsigned char))) == NULL)
564: {
565: (*s_etat_processus).erreur_systeme =
566: d_es_allocation_memoire;
567: return(NULL);
568: }
569:
570: sprintf(chaine, "%s [TO %s <%s>]", registre,
571: (*((struct_socket *) ((*s_objet).objet)))
572: .adresse, tampon);
573: }
574: else
575: {
576: if (strcmp((*((struct_socket *) ((*s_objet).objet)))
577: .adresse_distante, "") == 0)
578: {
579: if ((chaine = malloc((strlen(registre) + 5 +
580: strlen(tampon) + 1) * sizeof(unsigned char)))
581: == NULL)
582: {
583: (*s_etat_processus).erreur_systeme =
584: d_es_allocation_memoire;
585: return(NULL);
586: }
587:
588: sprintf(chaine, "%s [<%s>]", registre, tampon);
589: }
590: else
591: {
592: if ((chaine = malloc((strlen(registre) + 9 +
593: strlen((*((struct_socket *) ((*s_objet).objet)))
594: .adresse_distante) + strlen(tampon)
595: + 1) * sizeof(unsigned char))) == NULL)
596: {
597: (*s_etat_processus).erreur_systeme =
598: d_es_allocation_memoire;
599: return(NULL);
600: }
601:
602: sprintf(chaine, "%s [TO %s <%s>]", registre,
603: (*((struct_socket *) ((*s_objet).objet)))
604: .adresse_distante, tampon);
605: }
606: }
607: }
608:
609: free(registre);
610: free(format_majuscule);
611: }
612: else if ((*s_objet).type == ALG)
613: {
614:
615: /*
616: --------------------------------------------------------------------------------
617: Expression algébrique
618: --------------------------------------------------------------------------------
619: */
620:
621: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
622:
623: while(l_element_courant != NULL)
624: {
625: if ((*(*l_element_courant).donnee).type == FCT)
626: {
627: if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
628: .donnee).objet)).nom_fonction, "<<") != 0) &&
629: (strcmp((*((struct_fonction *) (*(*l_element_courant)
630: .donnee).objet)).nom_fonction, ">>") != 0))
631: {
632: if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
633: .donnee).objet)).nom_fonction, "+") == 0) ||
634: (strcmp((*((struct_fonction *)
635: (*(*l_element_courant).donnee).objet))
636: .nom_fonction, "-") == 0) || (strcmp(
637: (*((struct_fonction *) (*(*l_element_courant)
638: .donnee).objet)).nom_fonction, "*") == 0) ||
639: (strcmp((*((struct_fonction *)
640: (*(*l_element_courant).donnee).objet)).nom_fonction,
641: "/") == 0) || (strcmp((*((struct_fonction *)
642: (*(*l_element_courant).donnee).objet)).nom_fonction,
643: "^") == 0) || (strcmp((*((struct_fonction *)
644: (*(*l_element_courant).donnee).objet)).nom_fonction,
645: "<") == 0) || (strcmp((*((struct_fonction *)
646: (*(*l_element_courant).donnee).objet)).nom_fonction,
647: ">") == 0) || (strcmp((*((struct_fonction *)
648: (*(*l_element_courant).donnee).objet)).nom_fonction,
649: "==") == 0) || (strcmp((*((struct_fonction *)
650: (*(*l_element_courant).donnee).objet)).nom_fonction,
651: "<>") == 0) || (strcmp((*((struct_fonction *)
652: (*(*l_element_courant).donnee).objet)).nom_fonction,
653: "<=") == 0) || (strcmp((*((struct_fonction *)
654: (*(*l_element_courant).donnee).objet)).nom_fonction,
655: "=<") == 0) || (strcmp((*((struct_fonction *)
656: (*(*l_element_courant).donnee).objet)).nom_fonction,
657: ">=") == 0) || (strcmp((*((struct_fonction *)
658: (*(*l_element_courant).donnee).objet)).nom_fonction,
659: "=>") == 0))
660: {
661: if (depilement(s_etat_processus, &((*s_etat_processus)
662: .l_base_pile), &s_sous_objet_2) == d_erreur)
663: {
664: return(NULL);
665: }
666:
667: chaine_sauvegarde = (*s_etat_processus)
668: .instruction_courante;
669:
670: if (((*s_etat_processus).instruction_courante =
671: (unsigned char *) malloc((strlen(
672: (unsigned char *) (*s_sous_objet_2).objet) + 2
673: + 1) * sizeof(unsigned char))) == NULL)
674: {
675: (*s_etat_processus).instruction_courante =
676: chaine_sauvegarde;
677: (*s_etat_processus).erreur_systeme =
678: d_es_allocation_memoire;
679: return(NULL);
680: }
681:
682: sprintf((*s_etat_processus).instruction_courante,
683: "'%s'", (unsigned char *)
684: (*s_sous_objet_2).objet);
685:
686: presence_signe = (((*s_etat_processus)
687: .instruction_courante[1] == '+')
688: || ((*s_etat_processus).instruction_courante[1]
689: == '-')) ? d_vrai : d_faux;
690:
691: recherche_type(s_etat_processus);
692:
693: if ((*s_etat_processus).erreur_execution != d_ex)
694: {
695: // Aucune erreur d'exécution ne peut être
696: // retournée, car l'argument est cohérent.
697:
698: return(NULL);
699: }
700:
701: if (depilement(s_etat_processus, &((*s_etat_processus)
702: .l_base_pile), &s_sous_objet_3) == d_erreur)
703: {
704: return(NULL);
705: }
706:
707: free((*s_etat_processus).instruction_courante);
708:
709: (*s_etat_processus).instruction_courante =
710: chaine_sauvegarde;
711:
712: autorisation_parenthese = d_faux;
713:
714: if ((*s_sous_objet_3).type == ALG)
715: {
716: l_atome = (struct_liste_chainee *)
717: (*s_sous_objet_3).objet;
718: chaine_fonction = "";
719: nombre_arguments_fonction = 0;
720:
721: while(l_atome != NULL)
722: {
723: if ((*(*l_atome).donnee).type == FCT)
724: {
725: if (strcmp((*((struct_fonction *)
726: (*(*l_atome).donnee).objet))
727: .nom_fonction, ">>") != 0)
728: {
729: chaine_fonction = (*((struct_fonction *)
730: (*(*l_atome).donnee).objet))
731: .nom_fonction;
732: nombre_arguments_fonction =
733: (*((struct_fonction *)
734: (*(*l_atome).donnee).objet))
735: .nombre_arguments;
736: }
737: }
738:
739: l_atome = (*l_atome).suivant;
740: }
741:
742: if (strcmp((*((struct_fonction *)
743: (*(*l_element_courant).donnee).objet))
744: .nom_fonction, "+") == 0)
745: {
746: if ((strcmp(chaine_fonction, "AND") == 0) ||
747: (strcmp(chaine_fonction, "XOR") == 0) ||
748: (strcmp(chaine_fonction, "OR") == 0))
749: {
750: autorisation_parenthese = d_vrai;
751: }
752: }
753: else if (strcmp((*((struct_fonction *)
754: (*(*l_element_courant).donnee).objet))
755: .nom_fonction, "-") == 0)
756: {
757: if (nombre_arguments_fonction != 0)
758: {
759: autorisation_parenthese = d_faux;
760: }
761: else
762: {
763: autorisation_parenthese = d_vrai;
764: }
765: }
766: else if (strcmp((*((struct_fonction *)
767: (*(*l_element_courant).donnee).objet))
768: .nom_fonction, "*") == 0)
769: {
770: if ((strcmp(chaine_fonction, "+") == 0) ||
771: (strcmp(chaine_fonction, "-") == 0) ||
772: (strcmp(chaine_fonction, "AND") == 0) ||
773: (strcmp(chaine_fonction, "XOR") == 0) ||
774: (strcmp(chaine_fonction, "OR") == 0))
775: {
776: autorisation_parenthese = d_vrai;
777: }
778: }
779: else if (strcmp((*((struct_fonction *)
780: (*(*l_element_courant).donnee).objet))
781: .nom_fonction, "/") == 0)
782: {
783: if (nombre_arguments_fonction != 0)
784: {
785: autorisation_parenthese = d_faux;
786: }
787: else
788: {
789: autorisation_parenthese = d_vrai;
790: }
791: }
792: else if ((strcmp((*((struct_fonction *)
793: (*(*l_element_courant).donnee).objet))
794: .nom_fonction, "^") == 0))
795: {
796: if (nombre_arguments_fonction != 0)
797: {
798: autorisation_parenthese = d_faux;
799: }
800: else
801: {
802: autorisation_parenthese = d_vrai;
803: }
804: }
805: }
806:
807: if ((autorisation_parenthese == d_vrai) ||
808: (presence_signe == d_vrai))
809: {
810: chaine_sauvegarde = (unsigned char *)
811: (*s_sous_objet_2).objet;
812:
813: if (((*s_sous_objet_2).objet =
814: malloc((strlen(chaine_sauvegarde) + 2 + 1)
815: * sizeof(unsigned char))) == NULL)
816: {
817: (*s_etat_processus).erreur_systeme =
818: d_es_allocation_memoire;
819: return(NULL);
820: }
821:
822: sprintf((unsigned char *) (*s_sous_objet_2).objet,
823: "(%s)", chaine_sauvegarde);
824: free(chaine_sauvegarde);
825: }
826:
827: liberation(s_etat_processus, s_sous_objet_3);
828:
829: if (depilement(s_etat_processus, &((*s_etat_processus)
830: .l_base_pile), &s_sous_objet_1) == d_erreur)
831: {
832: return(NULL);
833: }
834:
835: chaine_sauvegarde = (*s_etat_processus)
836: .instruction_courante;
837:
838: if (((*s_etat_processus).instruction_courante =
839: (unsigned char *) malloc((strlen(
840: (unsigned char *) (*s_sous_objet_1).objet) + 2
841: + 1) * sizeof(unsigned char))) == NULL)
842: {
843: (*s_etat_processus).instruction_courante =
844: chaine_sauvegarde;
845: (*s_etat_processus).erreur_systeme =
846: d_es_allocation_memoire;
847: return(NULL);
848: }
849:
850: sprintf((*s_etat_processus).instruction_courante,
851: "'%s'", (unsigned char *)
852: (*s_sous_objet_1).objet);
853:
854: recherche_type(s_etat_processus);
855:
856: if ((*s_etat_processus).erreur_execution != d_ex)
857: {
858: // Aucune erreur d'exécution ne peut être
859: // retournée, car l'argument est cohérent.
860:
861: return(NULL);
862: }
863:
864: if (depilement(s_etat_processus, &((*s_etat_processus)
865: .l_base_pile), &s_sous_objet_3) == d_erreur)
866: {
867: return(NULL);
868: }
869:
870: free((*s_etat_processus).instruction_courante);
871:
872: (*s_etat_processus).instruction_courante =
873: chaine_sauvegarde;
874:
875: autorisation_parenthese = d_faux;
876:
877: if ((*s_sous_objet_3).type == ALG)
878: {
879: l_atome = (struct_liste_chainee *)
880: (*s_sous_objet_3).objet;
881: chaine_fonction = "";
882:
883: while(l_atome != NULL)
884: {
885: if ((*(*l_atome).donnee).type == FCT)
886: {
887: if (strcmp((*((struct_fonction *)
888: (*(*l_atome).donnee).objet))
889: .nom_fonction, ">>") != 0)
890: {
891: chaine_fonction = (*((struct_fonction *)
892: (*(*l_atome).donnee).objet))
893: .nom_fonction;
894: }
895: }
896:
897: l_atome = (*l_atome).suivant;
898: }
899:
900: if ((strcmp((*((struct_fonction *)
901: (*(*l_element_courant).donnee).objet))
902: .nom_fonction, "+") == 0) ||
903: (strcmp((*((struct_fonction *)
904: (*(*l_element_courant).donnee).objet))
905: .nom_fonction, "-") == 0))
906: {
907: if ((strcmp(chaine_fonction, "AND") == 0) ||
908: (strcmp(chaine_fonction, "XOR") == 0) ||
909: (strcmp(chaine_fonction, "OR") == 0))
910: {
911: autorisation_parenthese = d_vrai;
912: }
913: }
914: else if ((strcmp((*((struct_fonction *)
915: (*(*l_element_courant).donnee).objet))
916: .nom_fonction, "*") == 0) ||
917: (strcmp((*((struct_fonction *)
918: (*(*l_element_courant).donnee).objet))
919: .nom_fonction, "/") == 0))
920: {
921: if ((strcmp(chaine_fonction, "+") == 0) ||
922: (strcmp(chaine_fonction, "-") == 0) ||
923: (strcmp(chaine_fonction, "AND") == 0) ||
924: (strcmp(chaine_fonction, "XOR") == 0) ||
925: (strcmp(chaine_fonction, "OR") == 0))
926: {
927: autorisation_parenthese = d_vrai;
928: }
929: }
930: else if ((strcmp((*((struct_fonction *)
931: (*(*l_element_courant).donnee).objet))
932: .nom_fonction, "^") == 0))
933: {
934: autorisation_parenthese = d_vrai;
935: }
936: }
937:
938: if (autorisation_parenthese == d_vrai)
939: {
940: chaine_sauvegarde = (unsigned char *)
941: (*s_sous_objet_1).objet;
942:
943: if (((*s_sous_objet_1).objet =
944: malloc((strlen(chaine_sauvegarde) + 2 + 1)
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_1).objet,
953: "(%s)", chaine_sauvegarde);
954: free(chaine_sauvegarde);
955: }
956:
957: liberation(s_etat_processus, s_sous_objet_3);
958:
959: if ((s_sous_objet = allocation(s_etat_processus, CHN))
960: == NULL)
961: {
962: (*s_etat_processus).erreur_systeme =
963: d_es_allocation_memoire;
964: return(NULL);
965: }
966:
967: if (((*s_sous_objet).objet = malloc((strlen(
968: (unsigned char *) (*s_sous_objet_1).objet) +
969: strlen((*((struct_fonction *)
970: (*(*l_element_courant).donnee).objet))
971: .nom_fonction) + strlen((unsigned char *)
972: (*s_sous_objet_2).objet) + 1) *
973: sizeof(unsigned char))) == NULL)
974: {
975: (*s_etat_processus).erreur_systeme =
976: d_es_allocation_memoire;
977: return(NULL);
978: }
979:
980: sprintf((unsigned char *) (*s_sous_objet).objet,
981: "%s%s%s", (unsigned char *)
982: (*s_sous_objet_1)
983: .objet, (*((struct_fonction *)
984: (*(*l_element_courant).donnee).objet))
985: .nom_fonction, (unsigned char *)
986: (*s_sous_objet_2).objet);
987:
988: liberation(s_etat_processus, s_sous_objet_1);
989: liberation(s_etat_processus, s_sous_objet_2);
990:
991: if (empilement(s_etat_processus, &((*s_etat_processus)
992: .l_base_pile), s_sous_objet) == d_erreur)
993: {
994: return(NULL);
995: }
996: }
997: else if (strcmp((*((struct_fonction *)
998: (*(*l_element_courant).donnee).objet)).nom_fonction,
999: "=") == 0)
1000: {
1001: if (depilement(s_etat_processus, &((*s_etat_processus)
1002: .l_base_pile), &s_sous_objet_2) == d_erreur)
1003: {
1004: return(NULL);
1005: }
1006:
1007: if (depilement(s_etat_processus, &((*s_etat_processus)
1008: .l_base_pile), &s_sous_objet_1) == d_erreur)
1009: {
1010: return(NULL);
1011: }
1012:
1013: if ((s_sous_objet = allocation(s_etat_processus, CHN))
1014: == NULL)
1015: {
1016: (*s_etat_processus).erreur_systeme =
1017: d_es_allocation_memoire;
1018: return(NULL);
1019: }
1020:
1021: autorisation_parenthese = d_vrai;
1022: l_atome = l_element_courant;
1023:
1024: if (l_atome != NULL)
1025: {
1026: if ((*l_atome).suivant != NULL)
1027: {
1028: l_atome = (*l_atome).suivant;
1029:
1030: if ((*(*l_atome).donnee).type == FCT)
1031: {
1032: if (strcmp((*((struct_fonction *)
1033: (*(*l_atome).donnee).objet))
1034: .nom_fonction, ">>") == 0)
1035: {
1036: if ((*l_atome).suivant == NULL)
1037: {
1038: autorisation_parenthese = d_faux;
1039: }
1040: }
1041: }
1042: }
1043: }
1044:
1045: if (autorisation_parenthese == d_vrai)
1046: {
1047: if (((*s_sous_objet).objet =
1048: malloc((strlen(
1049: (unsigned char *) (*s_sous_objet_1).objet) +
1050: strlen((*((struct_fonction *)
1051: (*(*l_element_courant).donnee).objet))
1052: .nom_fonction) + strlen((unsigned char *)
1053: (*s_sous_objet_2).objet) + 2 + 1) *
1054: sizeof(unsigned char))) == NULL)
1055: {
1056: (*s_etat_processus).erreur_systeme =
1057: d_es_allocation_memoire;
1058: return(NULL);
1059: }
1060:
1061: sprintf((unsigned char *) (*s_sous_objet).objet,
1062: "(%s%s%s)", (unsigned char *)
1063: (*s_sous_objet_1)
1064: .objet, (*((struct_fonction *)
1065: (*(*l_element_courant).donnee).objet))
1066: .nom_fonction, (unsigned char *)
1067: (*s_sous_objet_2).objet);
1068: }
1069: else
1070: {
1071: if (((*s_sous_objet).objet =
1072: malloc((strlen(
1073: (unsigned char *) (*s_sous_objet_1).objet) +
1074: strlen((*((struct_fonction *)
1075: (*(*l_element_courant).donnee).objet))
1076: .nom_fonction) + strlen((unsigned char *)
1077: (*s_sous_objet_2).objet) + 1) *
1078: sizeof(unsigned char))) == NULL)
1079: {
1080: (*s_etat_processus).erreur_systeme =
1081: d_es_allocation_memoire;
1082: return(NULL);
1083: }
1084:
1085: sprintf((unsigned char *) (*s_sous_objet).objet,
1086: "%s%s%s", (unsigned char *)
1087: (*s_sous_objet_1)
1088: .objet, (*((struct_fonction *)
1089: (*(*l_element_courant).donnee).objet))
1090: .nom_fonction, (unsigned char *)
1091: (*s_sous_objet_2).objet);
1092: }
1093:
1094: liberation(s_etat_processus, s_sous_objet_1);
1095: liberation(s_etat_processus, s_sous_objet_2);
1096:
1097: if (empilement(s_etat_processus, &((*s_etat_processus)
1098: .l_base_pile), s_sous_objet) == d_erreur)
1099: {
1100: return(NULL);
1101: }
1102: }
1103: else if (strcmp((*((struct_fonction *)
1104: (*(*l_element_courant).donnee).objet)).nom_fonction,
1105: "NOT") == 0)
1106: {
1107: if (depilement(s_etat_processus, &((*s_etat_processus)
1108: .l_base_pile), &s_sous_objet_1) == d_erreur)
1109: {
1110: return(NULL);
1111: }
1112:
1113: if ((s_sous_objet = allocation(s_etat_processus, CHN))
1114: == NULL)
1115: {
1116: (*s_etat_processus).erreur_systeme =
1117: d_es_allocation_memoire;
1118: return(NULL);
1119: }
1120:
1121: if (((*s_sous_objet).objet = (unsigned char *) malloc(
1122: (strlen((unsigned char *) (*s_sous_objet_1)
1123: .objet) + 5 + 1) * sizeof(unsigned char))) ==
1124: NULL)
1125: {
1126: (*s_etat_processus).erreur_systeme =
1127: d_es_allocation_memoire;
1128: return(NULL);
1129: }
1130:
1131: sprintf((unsigned char *) (*s_sous_objet).objet,
1132: "%s(%s)", (*((struct_fonction *)
1133: (*(*l_element_courant).donnee).objet))
1134: .nom_fonction, (unsigned char *)
1135: (*s_sous_objet_1).objet );
1136:
1137: liberation(s_etat_processus, s_sous_objet_1);
1138:
1139: if (empilement(s_etat_processus, &((*s_etat_processus)
1140: .l_base_pile), s_sous_objet) == d_erreur)
1141: {
1142: return(NULL);
1143: }
1144: }
1145: else if ((strcmp((*((struct_fonction *)
1146: (*(*l_element_courant).donnee).objet)).nom_fonction,
1147: "OR") == 0) || (strcmp((*((struct_fonction *)
1148: (*(*l_element_courant).donnee).objet)).nom_fonction,
1149: "XOR") == 0) || (strcmp((*((struct_fonction *)
1150: (*(*l_element_courant).donnee).objet)).nom_fonction,
1151: "AND") == 0))
1152: {
1153: if (depilement(s_etat_processus, &((*s_etat_processus)
1154: .l_base_pile), &s_sous_objet_2) == d_erreur)
1155: {
1156: return(NULL);
1157: }
1158:
1159: if (depilement(s_etat_processus, &((*s_etat_processus)
1160: .l_base_pile), &s_sous_objet_1) == d_erreur)
1161: {
1162: return(NULL);
1163: }
1164:
1165: if ((s_sous_objet = allocation(s_etat_processus, CHN))
1166: == NULL)
1167: {
1168: (*s_etat_processus).erreur_systeme =
1169: d_es_allocation_memoire;
1170: return(NULL);
1171: }
1172:
1173: parentheses_groupe_gauche = 0;
1174: parentheses_groupe_droit = 0;
1175:
1176: chaine_sauvegarde = (*s_etat_processus)
1177: .instruction_courante;
1178:
1179: if (((*s_etat_processus).instruction_courante =
1180: (unsigned char *) malloc((strlen(
1181: (unsigned char *) (*s_sous_objet_1).objet) + 2
1182: + 1) * sizeof(unsigned char))) == NULL)
1183: {
1184: (*s_etat_processus).instruction_courante =
1185: chaine_sauvegarde;
1186: (*s_etat_processus).erreur_systeme =
1187: d_es_allocation_memoire;
1188: return(NULL);
1189: }
1190:
1191: sprintf((*s_etat_processus).instruction_courante,
1192: "'%s'", (unsigned char *)
1193: (*s_sous_objet_1).objet);
1194:
1195: recherche_type(s_etat_processus);
1196:
1197: if ((*s_etat_processus).erreur_execution != d_ex)
1198: {
1199: // Aucune erreur d'exécution ne peut être
1200: // retournée, car l'argument est cohérent.
1201:
1202: return(NULL);
1203: }
1204:
1205: if (depilement(s_etat_processus, &((*s_etat_processus)
1206: .l_base_pile), &s_sous_objet_3) == d_erreur)
1207: {
1208: return(NULL);
1209: }
1210:
1211: free((*s_etat_processus).instruction_courante);
1212:
1213: (*s_etat_processus).instruction_courante =
1214: chaine_sauvegarde;
1215:
1216: if ((*s_sous_objet_3).type == ALG)
1217: {
1218: l_atome = (struct_liste_chainee *)
1219: (*s_sous_objet_3).objet;
1220: chaine_fonction = "";
1221:
1222: while(l_atome != NULL)
1223: {
1224: if ((*(*l_atome).donnee).type == FCT)
1225: {
1226: if (strcmp((*((struct_fonction *)
1227: (*(*l_atome).donnee).objet))
1228: .nom_fonction, ">>") != 0)
1229: {
1230: chaine_fonction = (*((struct_fonction *)
1231: (*(*l_atome).donnee).objet))
1232: .nom_fonction;
1233: }
1234: }
1235:
1236: l_atome = (*l_atome).suivant;
1237: }
1238:
1239: if (((strcmp(chaine_fonction, "OR") == 0) ||
1240: (strcmp(chaine_fonction, "XOR") == 0)) &&
1241: (strcmp((*((struct_fonction *)
1242: (*(*l_element_courant).donnee).objet))
1243: .nom_fonction, "AND") == 0))
1244: {
1245: parentheses_groupe_gauche = 2;
1246: }
1247: }
1248:
1249: liberation(s_etat_processus, s_sous_objet_3);
1250:
1251: chaine_sauvegarde = (*s_etat_processus)
1252: .instruction_courante;
1253:
1254: if (((*s_etat_processus).instruction_courante =
1255: (unsigned char *) malloc((strlen(
1256: (unsigned char *) (*s_sous_objet_2).objet) + 2
1257: + 1) * sizeof(unsigned char))) == NULL)
1258: {
1259: (*s_etat_processus).instruction_courante =
1260: chaine_sauvegarde;
1261: (*s_etat_processus).erreur_systeme =
1262: d_es_allocation_memoire;
1263: return(NULL);
1264: }
1265:
1266: sprintf((*s_etat_processus).instruction_courante,
1267: "'%s'", (unsigned char *)
1268: (*s_sous_objet_2).objet);
1269:
1270: recherche_type(s_etat_processus);
1271:
1272: if ((*s_etat_processus).erreur_execution != d_ex)
1273: {
1274: // Aucune erreur d'exécution ne peut être
1275: // retournée, car l'argument est cohérent.
1276:
1277: return(NULL);
1278: }
1279:
1280: if (depilement(s_etat_processus, &((*s_etat_processus)
1281: .l_base_pile), &s_sous_objet_3) == d_erreur)
1282: {
1283: return(NULL);
1284: }
1285:
1286: free((*s_etat_processus).instruction_courante);
1287:
1288: (*s_etat_processus).instruction_courante =
1289: chaine_sauvegarde;
1290:
1291: if ((*s_sous_objet_3).type == ALG)
1292: {
1293: l_atome = (struct_liste_chainee *)
1294: (*s_sous_objet_3).objet;
1295: chaine_fonction = "";
1296:
1297: while(l_atome != NULL)
1298: {
1299: if ((*(*l_atome).donnee).type == FCT)
1300: {
1301: if (strcmp((*((struct_fonction *)
1302: (*(*l_atome).donnee).objet))
1303: .nom_fonction, ">>") != 0)
1304: {
1305: chaine_fonction = (*((struct_fonction *)
1306: (*(*l_atome).donnee).objet))
1307: .nom_fonction;
1308: }
1309: }
1310:
1311: l_atome = (*l_atome).suivant;
1312: }
1313:
1314: if (((strcmp(chaine_fonction, "OR") == 0) ||
1315: (strcmp(chaine_fonction, "XOR") == 0)) &&
1316: (strcmp((*((struct_fonction *)
1317: (*(*l_element_courant).donnee).objet))
1318: .nom_fonction, "AND") == 0))
1319: {
1320: parentheses_groupe_droit = 2;
1321: }
1322: }
1323:
1324: liberation(s_etat_processus, s_sous_objet_3);
1325:
1326: if (((*s_sous_objet).objet = malloc((strlen(
1327: (unsigned char *) (*s_sous_objet_1).objet) +
1328: strlen((*((struct_fonction *)
1329: (*(*l_element_courant).donnee).objet))
1330: .nom_fonction) + strlen((unsigned char *)
1331: (*s_sous_objet_2).objet) + 2 + 1 +
1332: ((size_t) parentheses_groupe_gauche) +
1333: ((size_t) parentheses_groupe_droit)) *
1334: sizeof(unsigned char))) == NULL)
1335: {
1336: (*s_etat_processus).erreur_systeme =
1337: d_es_allocation_memoire;
1338: return(NULL);
1339: }
1340:
1341: sprintf((unsigned char *) (*s_sous_objet).objet,
1342: (parentheses_groupe_gauche == 0)
1343: ? ((parentheses_groupe_droit == 0)
1344: ? "%s %s %s"
1345: : "%s %s (%s)")
1346: : ((parentheses_groupe_droit == 0)
1347: ? "(%s) %s %s"
1348: : "(%s) %s (%s)"),
1349: (unsigned char *) (*s_sous_objet_1)
1350: .objet, (*((struct_fonction *)
1351: (*(*l_element_courant).donnee).objet))
1352: .nom_fonction, (unsigned char *)
1353: (*s_sous_objet_2).objet);
1354:
1355: liberation(s_etat_processus, s_sous_objet_1);
1356: liberation(s_etat_processus, s_sous_objet_2);
1357:
1358: if (empilement(s_etat_processus, &((*s_etat_processus)
1359: .l_base_pile), s_sous_objet) == d_erreur)
1360: {
1361: (*s_etat_processus).erreur_systeme =
1362: d_es_allocation_memoire;
1363: return(NULL);
1364: }
1365: }
1366: else
1367: {
1368: nombre_arguments = (*((struct_fonction *)
1369: (*(*l_element_courant).donnee).objet))
1370: .nombre_arguments;
1371:
1372: if ((chaine = (unsigned char *)
1373: malloc(sizeof(unsigned char))) == NULL)
1374: {
1375: (*s_etat_processus).erreur_systeme =
1376: d_es_allocation_memoire;
1377: return(NULL);
1378: }
1379:
1380: chaine[0] = d_code_fin_chaine;
1381:
1382: for(i = 0; i < nombre_arguments; i++)
1383: {
1384: if ((nombre_arguments - i) > 1)
1385: {
1386: l_liste1 = (*s_etat_processus).l_base_pile;
1387:
1388: for(j = 2; j < (nombre_arguments - i); j++)
1389: {
1390: l_liste1 = (*l_liste1).suivant;
1391: }
1392:
1393: l_liste2 = (*l_liste1).suivant;
1394: (*l_liste1).suivant = (*l_liste2).suivant;
1395: (*l_liste2).suivant = (*s_etat_processus)
1396: .l_base_pile;
1397: (*s_etat_processus).l_base_pile = l_liste2;
1398: }
1399:
1400: if (depilement(s_etat_processus,
1401: &((*s_etat_processus).l_base_pile),
1402: &s_sous_objet) == d_erreur)
1403: {
1404: return(NULL);
1405: }
1406:
1407: chaine_sauvegarde = chaine;
1408:
1409: if (strlen(chaine_sauvegarde) == 0)
1410: {
1411: if ((chaine = (unsigned char *) malloc((strlen(
1412: (unsigned char *) (*s_sous_objet).objet)
1413: + 1) * sizeof(unsigned char))) == NULL)
1414: {
1415: (*s_etat_processus).erreur_systeme =
1416: d_es_allocation_memoire;
1417: return(NULL);
1418: }
1419:
1420: sprintf(chaine, "%s", (unsigned char *)
1421: (*s_sous_objet).objet);
1422: }
1423: else
1424: {
1425: if ((chaine = (unsigned char *) malloc((strlen(
1426: chaine_sauvegarde) + 1 + strlen(
1427: (unsigned char *) (*s_sous_objet).objet)
1428: + 1) * sizeof(unsigned char))) == NULL)
1429: {
1430: (*s_etat_processus).erreur_systeme =
1431: d_es_allocation_memoire;
1432: return(NULL);
1433: }
1434:
1435: sprintf(chaine, "%s,%s", chaine_sauvegarde,
1436: (unsigned char *) (*s_sous_objet)
1437: .objet);
1438: }
1439:
1440: free(chaine_sauvegarde);
1441: liberation(s_etat_processus, s_sous_objet);
1442: }
1443:
1444: chaine_sauvegarde = chaine;
1445:
1446: if ((chaine = (unsigned char *) malloc((strlen(
1447: (*((struct_fonction *) (*(*l_element_courant)
1448: .donnee).objet)).nom_fonction) + 2 +
1449: strlen(chaine_sauvegarde) + 1) *
1450: sizeof(unsigned char))) == NULL)
1451: {
1452: (*s_etat_processus).erreur_systeme =
1453: d_es_allocation_memoire;
1454: return(NULL);
1455: }
1456:
1457: sprintf(chaine, "%s(%s)", (*((struct_fonction *)
1458: (*(*l_element_courant).donnee).objet))
1459: .nom_fonction, chaine_sauvegarde);
1460: free(chaine_sauvegarde);
1461:
1462: if ((s_sous_objet = allocation(s_etat_processus, CHN))
1463: == NULL)
1464: {
1465: (*s_etat_processus).erreur_systeme =
1466: d_es_allocation_memoire;
1467: return(NULL);
1468: }
1469:
1470: (*s_sous_objet).objet = chaine;
1471:
1472: if (empilement(s_etat_processus, &((*s_etat_processus)
1473: .l_base_pile), s_sous_objet) == d_erreur)
1474: {
1475: return(NULL);
1476: }
1477: }
1478: }
1479: }
1480: else
1481: {
1482: if ((s_sous_objet = allocation(s_etat_processus, CHN))
1483: == NULL)
1484: {
1485: (*s_etat_processus).erreur_systeme =
1486: d_es_allocation_memoire;
1487: return(NULL);
1488: }
1489:
1490: if (((*s_sous_objet).objet = formateur(
1491: s_etat_processus, 0, (*l_element_courant).donnee))
1492: == NULL)
1493: {
1494: (*s_etat_processus).erreur_systeme =
1495: d_es_allocation_memoire;
1496: return(NULL);
1497: }
1498:
1499: if (((*(*l_element_courant).donnee).type == ALG)
1500: || (((*(*l_element_courant).donnee).type == NOM)
1501: && ((*((struct_nom *) (*(*l_element_courant)
1502: .donnee).objet)).symbole == d_vrai)))
1503: {
1504: chaine_sauvegarde = (unsigned char *) (*s_sous_objet).objet;
1505:
1506: if (((*s_sous_objet).objet = malloc((strlen(
1507: chaine_sauvegarde) - 1) *
1508: sizeof(unsigned char))) == NULL)
1509: {
1510: (*s_etat_processus).erreur_systeme =
1511: d_es_allocation_memoire;
1512: return(NULL);
1513: }
1514:
1515: ptrl = chaine_sauvegarde;
1516: ptre = (unsigned char *) (*s_sous_objet).objet;
1517:
1518: for(ptrl++, i = ((integer8) strlen(chaine_sauvegarde)) - 2;
1519: i > 0; i--, *ptre++ = *ptrl++);
1520:
1521: (*ptre) = d_code_fin_chaine;
1522:
1523: free(chaine_sauvegarde);
1524: }
1525: else if ((*(*l_element_courant).donnee).type == CHN)
1526: {
1527: chaine_sauvegarde = (unsigned char *) (*s_sous_objet).objet;
1528:
1529: if (((*s_sous_objet).objet = malloc((strlen(
1530: chaine_sauvegarde) + 3) *
1531: sizeof(unsigned char))) == NULL)
1532: {
1533: (*s_etat_processus).erreur_systeme =
1534: d_es_allocation_memoire;
1535: return(NULL);
1536: }
1537:
1538: sprintf((unsigned char *) (*s_sous_objet).objet,
1539: "\"%s\"", chaine_sauvegarde);
1540:
1541: free(chaine_sauvegarde);
1542: }
1543:
1544: if (empilement(s_etat_processus, &((*s_etat_processus)
1545: .l_base_pile), s_sous_objet) == d_erreur)
1546: {
1547: return(NULL);
1548: }
1549: }
1550:
1551: l_element_courant = (*l_element_courant).suivant;
1552: }
1553:
1554: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1555: &s_sous_objet) == d_erreur)
1556: {
1557: return(NULL);
1558: }
1559:
1560: if ((chaine = (unsigned char *) malloc((strlen((unsigned char *)
1561: (*s_sous_objet).objet) + 2 + 1) * sizeof(unsigned char)))
1562: == NULL)
1563: {
1564: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1565: return(NULL);
1566: }
1567:
1568: sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet);
1569: liberation(s_etat_processus, s_sous_objet);
1570: }
1571: else if ((*s_objet).type == BIN)
1572: {
1573:
1574: /*
1575: --------------------------------------------------------------------------------
1576: Entier binaire en base 2, 8, 10 ou 16
1577: --------------------------------------------------------------------------------
1578: */
1579:
1580: masque_binaire = masque_entiers_binaires(s_etat_processus);
1581:
1582: if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
1583: (test_cfsf(s_etat_processus, 44) == d_faux))
1584: {
1585:
1586: /*
1587: -- Base décimale ---------------------------------------------------------------
1588: */
1589:
1590: sprintf(tampon, "%llu", (*((logical8 *)
1591: ((*s_objet).objet))) & masque_binaire);
1592: strcpy(base, "d");
1593: }
1594: else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&
1595: (test_cfsf(s_etat_processus, 44) == d_faux))
1596: {
1597:
1598: /*
1599: -- Base octale -----------------------------------------------------------------
1600: */
1601:
1602: sprintf(tampon, "%llo", (*((logical8 *)
1603: ((*s_objet).objet))) & masque_binaire);
1604: strcpy(base, "o");
1605: }
1606: else if (test_cfsf(s_etat_processus, 44) == d_vrai)
1607: {
1608:
1609: /*
1610: -- Bases hexadécimale et binaire -----------------------------------------------
1611: */
1612:
1613: sprintf(tampon, "%llX", (*((logical8 *)
1614: ((*s_objet).objet))) & masque_binaire);
1615:
1616: if (test_cfsf(s_etat_processus, 43) == d_vrai)
1617: {
1618: strcpy(base, "h");
1619: }
1620: else
1621: {
1622: chaine = (unsigned char *) malloc((strlen(tampon) + 1)
1623: * sizeof(unsigned char));
1624:
1625: if (chaine == NULL)
1626: {
1627: (*s_etat_processus).erreur_systeme =
1628: d_es_allocation_memoire;
1629: return(NULL);
1630: }
1631:
1632: strcpy(chaine, tampon);
1633: tampon[0] = 0;
1634:
1635: for(i = 0; i < (integer8) strlen(chaine); i++)
1636: {
1637: switch(chaine[i])
1638: {
1639: case '0' :
1640: {
1641: strcat(tampon, (i != 0) ? "0000" : "0");
1642: break;
1643: }
1644: case '1' :
1645: {
1646: strcat(tampon, (i != 0) ? "0001" : "1");
1647: break;
1648: }
1649: case '2' :
1650: {
1651: strcat(tampon, (i != 0) ? "0010" : "10");
1652: break;
1653: }
1654: case '3' :
1655: {
1656: strcat(tampon, (i != 0) ? "0011" : "11");
1657: break;
1658: }
1659: case '4' :
1660: {
1661: strcat(tampon, (i != 0) ? "0100" : "100");
1662: break;
1663: }
1664: case '5' :
1665: {
1666: strcat(tampon, (i != 0) ? "0101" : "101");
1667: break;
1668: }
1669: case '6' :
1670: {
1671: strcat(tampon, (i != 0) ? "0110" : "110");
1672: break;
1673: }
1674: case '7' :
1675: {
1676: strcat(tampon, (i != 0) ? "0111" : "111");
1677: break;
1678: }
1679: case '8' :
1680: {
1681: strcat(tampon, "1000");
1682: break;
1683: }
1684: case '9' :
1685: {
1686: strcat(tampon, "1001");
1687: break;
1688: }
1689: case 'A' :
1690: {
1691: strcat(tampon, "1010");
1692: break;
1693: }
1694: case 'B' :
1695: {
1696: strcat(tampon, "1011");
1697: break;
1698: }
1699: case 'C' :
1700: {
1701: strcat(tampon, "1100");
1702: break;
1703: }
1704: case 'D' :
1705: {
1706: strcat(tampon, "1101");
1707: break;
1708: }
1709: case 'E' :
1710: {
1711: strcat(tampon, "1110");
1712: break;
1713: }
1714: case 'F' :
1715: {
1716: strcat(tampon, "1111");
1717: break;
1718: }
1719: }
1720: }
1721:
1722: free(chaine);
1723: strcpy(base, "b");
1724: }
1725: }
1726:
1727: chaine = (unsigned char *) malloc((strlen(tampon) + 4)
1728: * sizeof(unsigned char));
1729:
1730: if (chaine == NULL)
1731: {
1732: (*s_etat_processus).erreur_systeme =
1733: d_es_allocation_memoire;
1734: return(NULL);
1735: }
1736:
1737: strcpy(chaine, "# ");
1738:
1739: strcat(chaine, tampon);
1740: strcat(chaine, base);
1741: }
1742: else if ((*s_objet).type == CHN)
1743: {
1744:
1745: /*
1746: --------------------------------------------------------------------------------
1747: Chaîne de caractères
1748: --------------------------------------------------------------------------------
1749: */
1750:
1751: if (((*s_etat_processus).autorisation_conversion_chaine == 'Y') &&
1752: (test_cfsf(s_etat_processus, 34) == d_vrai))
1753: {
1754: if ((chaine = formateur_flux(s_etat_processus,
1755: (unsigned char *) (*s_objet).objet, &longueur_chaine))
1756: == NULL)
1757: {
1758: return(NULL);
1759: }
1760: }
1761: else
1762: {
1763: if ((chaine = malloc((strlen((unsigned char *)
1764: ((*s_objet).objet)) + 1) * sizeof(unsigned char))) == NULL)
1765: {
1766: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1767: return(NULL);
1768: }
1769:
1770: strcpy(chaine, (unsigned char *) ((*s_objet).objet));
1771: }
1772: }
1773: else if ((*s_objet).type == CPL)
1774: {
1775:
1776: /*
1777: --------------------------------------------------------------------------------
1778: Complexe
1779: --------------------------------------------------------------------------------
1780: */
1781:
1782: chaine_formatee = formateur_nombre(s_etat_processus,
1783: ((struct_complexe16 *) ((*s_objet).objet)), 'C');
1784:
1785: if (chaine_formatee == NULL)
1786: {
1787: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1788: return(NULL);
1789: }
1790:
1791: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
1792: + 1) * sizeof(unsigned char));
1793:
1794: if (chaine == NULL)
1795: {
1796: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1797: return(NULL);
1798: }
1799:
1800: strcpy(chaine, chaine_formatee);
1801: free(chaine_formatee);
1802: }
1803: else if ((*s_objet).type == RPN)
1804: {
1805:
1806: /*
1807: --------------------------------------------------------------------------------
1808: Définition
1809: --------------------------------------------------------------------------------
1810: */
1811:
1812: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
1813: chaine_sauvegarde = chaine;
1814:
1815: while(l_element_courant != NULL)
1816: {
1817: if ((chaine_formatee = formateur(s_etat_processus, offset_initial,
1818: (*l_element_courant).donnee)) == NULL)
1819: {
1820: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1821: return(NULL);
1822: }
1823:
1824: if ((*(*l_element_courant).donnee).type == CHN)
1825: {
1826: chaine_tampon = chaine_formatee;
1827:
1828: if ((chaine_formatee = (unsigned char *) malloc((strlen(
1829: chaine_tampon) + 3) * sizeof(unsigned char))) == NULL)
1830: {
1831: (*s_etat_processus).erreur_systeme =
1832: d_es_allocation_memoire;
1833: return(NULL);
1834: }
1835:
1836: sprintf(chaine_formatee, "\"%s\"", chaine_tampon);
1837: free(chaine_tampon);
1838: }
1839:
1840: l_element_courant = (*l_element_courant).suivant;
1841:
1842: if (chaine != NULL)
1843: {
1844: chaine_sauvegarde = chaine;
1845:
1846: if ((chaine = (unsigned char *) malloc((strlen(
1847: chaine_sauvegarde) + strlen(chaine_formatee) + 2) *
1848: sizeof(unsigned char))) == NULL)
1849: {
1850: (*s_etat_processus).erreur_systeme =
1851: d_es_allocation_memoire;
1852: return(NULL);
1853: }
1854:
1855: strcpy(chaine, chaine_sauvegarde);
1856: free(chaine_sauvegarde);
1857: strcat(chaine, " ");
1858: strcat(chaine, chaine_formatee);
1859: free(chaine_formatee);
1860: }
1861: else
1862: {
1863: chaine = chaine_formatee;
1864: }
1865: }
1866:
1867: chaine_sauvegarde = chaine;
1868: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) *
1869: sizeof(unsigned char));
1870:
1871: if (chaine == NULL)
1872: {
1873: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1874: return(NULL);
1875: }
1876:
1877: chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine;
1878: strcpy(chaine, chaine_sauvegarde);
1879: free(chaine_sauvegarde);
1880: }
1881: else if ((*s_objet).type == INT)
1882: {
1883:
1884: /*
1885: --------------------------------------------------------------------------------
1886: Entier
1887: --------------------------------------------------------------------------------
1888: */
1889:
1890: chaine_formatee = formateur_nombre(s_etat_processus,
1891: ((integer8 *) ((*s_objet).objet)), 'I');
1892:
1893: if (chaine_formatee == NULL)
1894: {
1895: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1896: return(NULL);
1897: }
1898:
1899: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1)
1900: * sizeof(unsigned char));
1901:
1902: if (chaine == NULL)
1903: {
1904: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1905: return(NULL);
1906: }
1907:
1908: strcpy(chaine, chaine_formatee);
1909: free(chaine_formatee);
1910: }
1911: else if ((*s_objet).type == FCT)
1912: {
1913:
1914: /*
1915: --------------------------------------------------------------------------------
1916: Fonction
1917: --------------------------------------------------------------------------------
1918: */
1919:
1920: chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
1921: ((*s_objet).objet))).nom_fonction) + 1) *
1922: sizeof(unsigned char));
1923:
1924: if (chaine == NULL)
1925: {
1926: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1927: return(NULL);
1928: }
1929:
1930: strcpy(chaine, (unsigned char *) (*((struct_fonction *)
1931: ((*s_objet).objet))).nom_fonction);
1932: }
1933: else if ((*s_objet).type == TBL)
1934: {
1935:
1936: /*
1937: --------------------------------------------------------------------------------
1938: Tableau
1939: --------------------------------------------------------------------------------
1940: */
1941:
1942: chaine = (unsigned char *) malloc(4 * sizeof(unsigned char));
1943:
1944: if (chaine == NULL)
1945: {
1946: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1947: return(NULL);
1948: }
1949:
1950: strcpy(chaine, "<[ ");
1951: offset = ((integer8) strlen(chaine)) + offset_initial;
1952:
1953: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
1954: .nombre_elements; i++)
1955: {
1956: chaine_sauvegarde = chaine;
1957: chaine_formatee = formateur(s_etat_processus, offset,
1958: (*((struct_tableau *) (*s_objet).objet)).elements[i]);
1959:
1960: if (chaine_formatee == NULL)
1961: {
1962: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1963: return(NULL);
1964: }
1965:
1966: if ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
1967: .type == CHN)
1968: {
1969: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
1970: + strlen(chaine_sauvegarde) + 3)
1971: * sizeof(unsigned char));
1972:
1973: if (chaine == NULL)
1974: {
1975: (*s_etat_processus).erreur_systeme =
1976: d_es_allocation_memoire;
1977: return(NULL);
1978: }
1979:
1980: strcpy(chaine, chaine_sauvegarde);
1981: free(chaine_sauvegarde);
1982: strcat(chaine, "\"");
1983: strcat(chaine, chaine_formatee);
1984: free(chaine_formatee);
1985: strcat(chaine, "\"");
1986: }
1987: else if ((*(*((struct_tableau *) (*s_objet).objet))
1988: .elements[i]).type == CHN)
1989: {
1990: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
1991: + strlen(chaine_sauvegarde) + 1)
1992: * sizeof(unsigned char));
1993:
1994: if (chaine == NULL)
1995: {
1996: (*s_etat_processus).erreur_systeme =
1997: d_es_allocation_memoire;
1998: return(NULL);
1999: }
2000:
2001: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
2002: free(chaine_sauvegarde);
2003: free(chaine_formatee);
2004: }
2005: else
2006: {
2007: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
2008: + strlen(chaine_sauvegarde) + 1)
2009: * sizeof(unsigned char));
2010:
2011: if (chaine == NULL)
2012: {
2013: (*s_etat_processus).erreur_systeme =
2014: d_es_allocation_memoire;
2015: return(NULL);
2016: }
2017:
2018: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
2019: free(chaine_sauvegarde);
2020: free(chaine_formatee);
2021: }
2022:
2023: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2024: {
2025: chaine_sauvegarde = chaine;
2026:
2027: chaine = (unsigned char *) malloc(
2028: (strlen(chaine_sauvegarde) + 2)
2029: * sizeof(unsigned char));
2030:
2031: if (chaine == NULL)
2032: {
2033: (*s_etat_processus).erreur_systeme =
2034: d_es_allocation_memoire;
2035: return(NULL);
2036: }
2037:
2038: strcpy(chaine, chaine_sauvegarde);
2039: free(chaine_sauvegarde);
2040: strcat(chaine, "\n");
2041:
2042: if ((*((struct_tableau *) (*s_objet).objet))
2043: .nombre_elements != (i + 1))
2044: {
2045: chaine_sauvegarde = chaine;
2046:
2047: chaine = (unsigned char *) malloc(
2048: (strlen(chaine_sauvegarde) + 1 + ((size_t) offset))
2049: * sizeof(unsigned char));
2050:
2051: if (chaine == NULL)
2052: {
2053: (*s_etat_processus).erreur_systeme =
2054: d_es_allocation_memoire;
2055: return(NULL);
2056: }
2057:
2058: strcpy(chaine, chaine_sauvegarde);
2059: free(chaine_sauvegarde);
2060: ptre = &(chaine[strlen(chaine)]);
2061:
2062: for(k = 0; k < offset; k++, *(ptre++) = ' ');
2063:
2064: (*ptre) = d_code_fin_chaine;
2065: }
2066: }
2067: else
2068: {
2069: if ((*((struct_tableau *) (*s_objet).objet))
2070: .nombre_elements != (i + 1))
2071: {
2072: chaine_sauvegarde = chaine;
2073:
2074: chaine = (unsigned char *) malloc(
2075: (strlen(chaine_sauvegarde) + 2)
2076: * sizeof(unsigned char));
2077:
2078: if (chaine == NULL)
2079: {
2080: (*s_etat_processus).erreur_systeme =
2081: d_es_allocation_memoire;
2082: return(NULL);
2083: }
2084:
2085: strcpy(chaine, chaine_sauvegarde);
2086: free(chaine_sauvegarde);
2087: strcat(chaine, " ");
2088: }
2089: }
2090: }
2091:
2092: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2093: {
2094: if (chaine[strlen(chaine) - 1] == '\n')
2095: {
2096: chaine[strlen(chaine) - 1] = d_code_fin_chaine;
2097: }
2098: }
2099:
2100: if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements != 0)
2101: {
2102: chaine_sauvegarde = chaine;
2103: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4)
2104: * sizeof(unsigned char));
2105:
2106: if (chaine == NULL)
2107: {
2108: (*s_etat_processus).erreur_systeme =
2109: d_es_allocation_memoire;
2110: return(NULL);
2111: }
2112:
2113: strcpy(chaine, chaine_sauvegarde);
2114: free(chaine_sauvegarde);
2115: strcat(chaine, " ]>");
2116: }
2117: else
2118: {
2119: chaine_sauvegarde = chaine;
2120: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3)
2121: * sizeof(unsigned char));
2122:
2123: if (chaine == NULL)
2124: {
2125: (*s_etat_processus).erreur_systeme =
2126: d_es_allocation_memoire;
2127: return(NULL);
2128: }
2129:
2130: strcpy(chaine, chaine_sauvegarde);
2131: free(chaine_sauvegarde);
2132: strcat(chaine, "]>");
2133: }
2134: }
2135: else if ((*s_objet).type == LST)
2136: {
2137:
2138: /*
2139: --------------------------------------------------------------------------------
2140: Liste
2141: --------------------------------------------------------------------------------
2142: */
2143:
2144: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2145:
2146: if (chaine == NULL)
2147: {
2148: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2149: return(NULL);
2150: }
2151:
2152: strcpy(chaine, "{ ");
2153:
2154: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
2155: nombre_elements = 0;
2156: offset = ((integer8) strlen(chaine)) + offset_initial;
2157:
2158: while(l_element_courant != NULL)
2159: {
2160: chaine_sauvegarde = chaine;
2161: chaine_formatee = formateur(s_etat_processus, offset,
2162: (*l_element_courant).donnee);
2163:
2164: if (chaine_formatee == NULL)
2165: {
2166: (*s_etat_processus).erreur_systeme =
2167: d_es_allocation_memoire;
2168: return(NULL);
2169: }
2170:
2171: if ((*(*l_element_courant).donnee).type == CHN)
2172: {
2173: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
2174: + strlen(chaine_sauvegarde) + 3)
2175: * sizeof(unsigned char));
2176:
2177: if (chaine == NULL)
2178: {
2179: (*s_etat_processus).erreur_systeme =
2180: d_es_allocation_memoire;
2181: return(NULL);
2182: }
2183:
2184: strcpy(chaine, chaine_sauvegarde);
2185: free(chaine_sauvegarde);
2186: strcat(chaine, "\"");
2187: strcat(chaine, chaine_formatee);
2188: free(chaine_formatee);
2189: strcat(chaine, "\"");
2190: }
2191: else if ((*(*l_element_courant).donnee).type == NOM)
2192: {
2193: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
2194: + strlen(chaine_sauvegarde) + 1)
2195: * sizeof(unsigned char));
2196:
2197: if (chaine == NULL)
2198: {
2199: (*s_etat_processus).erreur_systeme =
2200: d_es_allocation_memoire;
2201: return(NULL);
2202: }
2203:
2204: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
2205: free(chaine_sauvegarde);
2206: free(chaine_formatee);
2207: }
2208: else
2209: {
2210: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
2211: + strlen(chaine_sauvegarde) + 1)
2212: * sizeof(unsigned char));
2213:
2214: if (chaine == NULL)
2215: {
2216: (*s_etat_processus).erreur_systeme =
2217: d_es_allocation_memoire;
2218: return(NULL);
2219: }
2220:
2221: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
2222: free(chaine_sauvegarde);
2223: free(chaine_formatee);
2224: }
2225:
2226: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2227: {
2228: chaine_sauvegarde = chaine;
2229:
2230: chaine = (unsigned char *) malloc(
2231: (strlen(chaine_sauvegarde) + 2)
2232: * sizeof(unsigned char));
2233:
2234: if (chaine == NULL)
2235: {
2236: (*s_etat_processus).erreur_systeme =
2237: d_es_allocation_memoire;
2238: return(NULL);
2239: }
2240:
2241: strcpy(chaine, chaine_sauvegarde);
2242: free(chaine_sauvegarde);
2243: strcat(chaine, "\n");
2244:
2245: if ((*l_element_courant).suivant != NULL)
2246: {
2247: chaine_sauvegarde = chaine;
2248:
2249: chaine = (unsigned char *) malloc(
2250: (strlen(chaine_sauvegarde) + 1 + ((size_t) offset))
2251: * sizeof(unsigned char));
2252:
2253: if (chaine == NULL)
2254: {
2255: (*s_etat_processus).erreur_systeme =
2256: d_es_allocation_memoire;
2257: return(NULL);
2258: }
2259:
2260: strcpy(chaine, chaine_sauvegarde);
2261: free(chaine_sauvegarde);
2262: ptre = &(chaine[strlen(chaine)]);
2263:
2264: for(k = 0; k < offset; k++, *(ptre++) = ' ');
2265:
2266: (*ptre) = d_code_fin_chaine;
2267: }
2268: }
2269: else
2270: {
2271: if ((*l_element_courant).suivant != NULL)
2272: {
2273: chaine_sauvegarde = chaine;
2274:
2275: chaine = (unsigned char *) malloc(
2276: (strlen(chaine_sauvegarde) + 2)
2277: * sizeof(unsigned char));
2278:
2279: if (chaine == NULL)
2280: {
2281: (*s_etat_processus).erreur_systeme =
2282: d_es_allocation_memoire;
2283: return(NULL);
2284: }
2285:
2286: strcpy(chaine, chaine_sauvegarde);
2287: free(chaine_sauvegarde);
2288: strcat(chaine, " ");
2289: }
2290: }
2291:
2292: nombre_elements++;
2293: l_element_courant = (*l_element_courant).suivant;
2294: }
2295:
2296: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2297: {
2298: if (chaine[strlen(chaine) - 1] == '\n')
2299: {
2300: chaine[strlen(chaine) - 1] = d_code_fin_chaine;
2301: }
2302: }
2303:
2304: if (nombre_elements != 0)
2305: {
2306: chaine_sauvegarde = chaine;
2307: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3)
2308: * sizeof(unsigned char));
2309:
2310: if (chaine == NULL)
2311: {
2312: (*s_etat_processus).erreur_systeme =
2313: d_es_allocation_memoire;
2314: return(NULL);
2315: }
2316:
2317: strcpy(chaine, chaine_sauvegarde);
2318: free(chaine_sauvegarde);
2319: strcat(chaine, " }");
2320: }
2321: else
2322: {
2323: chaine_sauvegarde = chaine;
2324: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 2)
2325: * sizeof(unsigned char));
2326:
2327: if (chaine == NULL)
2328: {
2329: (*s_etat_processus).erreur_systeme =
2330: d_es_allocation_memoire;
2331: return(NULL);
2332: }
2333:
2334: strcpy(chaine, chaine_sauvegarde);
2335: free(chaine_sauvegarde);
2336: strcat(chaine, "}");
2337: }
2338: }
2339: else if ((*s_objet).type == MCX)
2340: {
2341:
2342: /*
2343: --------------------------------------------------------------------------------
2344: Matrice complexe
2345: --------------------------------------------------------------------------------
2346: */
2347:
2348: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
2349: .nombre_lignes;
2350: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
2351: .nombre_colonnes;
2352:
2353: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2354:
2355: if (chaine != NULL)
2356: {
2357: strcpy(chaine, "[[");
2358: offset = ((integer8) strlen(chaine)) + offset_initial - 1;
2359:
2360: if ((longueurs_maximales = malloc(sizeof(unsigned long) * 2 *
2361: ((size_t) nombre_colonnes))) == NULL)
2362: {
2363: (*s_etat_processus).erreur_systeme =
2364: d_es_allocation_memoire;
2365: return(NULL);
2366: }
2367:
2368: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2369: {
2370: for(j = 0; j < (2 * nombre_colonnes); j++)
2371: {
2372: longueurs_maximales[j] = 0;
2373: }
2374:
2375: for(i = 0; i < nombre_lignes; i++)
2376: {
2377: for(j = 0; j < nombre_colonnes; j++)
2378: {
2379: chaine_formatee = formateur_nombre(s_etat_processus,
2380: &(((struct_complexe16 **)
2381: ((*((struct_matrice *)
2382: ((*s_objet).objet))).tableau))[i][j]), 'C');
2383:
2384: if (chaine_formatee == NULL)
2385: {
2386: (*s_etat_processus).erreur_systeme =
2387: d_es_allocation_memoire;
2388: return(NULL);
2389: }
2390:
2391: longueur_courante = (integer8) strlen(chaine_formatee);
2392: longueur_decimale_courante = 0;
2393:
2394: if ((ptrl = index(chaine_formatee,
2395: (test_cfsf(s_etat_processus, 48) == d_vrai)
2396: ? '.' : ',')) != NULL)
2397: {
2398: longueur_decimale_courante = longueur_courante
2399: - (ptrl - chaine_formatee);
2400: longueur_courante = ptrl - chaine_formatee;
2401: }
2402:
2403: free(chaine_formatee);
2404:
2405: if (longueurs_maximales[2 * j] < longueur_courante)
2406: {
2407: longueurs_maximales[2 * j] = longueur_courante;
2408: }
2409:
2410: if (longueurs_maximales[(2 * j) + 1] <
2411: longueur_decimale_courante)
2412: {
2413: longueurs_maximales[(2 * j) + 1] =
2414: longueur_decimale_courante;
2415: }
2416: }
2417: }
2418: }
2419:
2420: for(i = 0; i < nombre_lignes; i++)
2421: {
2422: for(j = 0; j < nombre_colonnes; j++)
2423: {
2424: chaine_formatee = formateur_nombre(s_etat_processus,
2425: &(((struct_complexe16 **)
2426: ((*((struct_matrice *)
2427: ((*s_objet).objet))).tableau))[i][j]), 'C');
2428:
2429: if (chaine_formatee == NULL)
2430: {
2431: (*s_etat_processus).erreur_systeme =
2432: d_es_allocation_memoire;
2433: return(NULL);
2434: }
2435:
2436: longueur_courante = (integer8) strlen(chaine_formatee);
2437: longueur_decimale_courante = 0;
2438:
2439: if ((ptrl = index(chaine_formatee,
2440: (test_cfsf(s_etat_processus, 48) == d_vrai)
2441: ? '.' : ',')) != NULL)
2442: {
2443: longueur_decimale_courante = longueur_courante
2444: - (ptrl - chaine_formatee);
2445: longueur_courante = ptrl - chaine_formatee;
2446: }
2447:
2448: chaine_sauvegarde = chaine;
2449:
2450: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2451: {
2452:
2453: chaine = (unsigned char *) malloc(
2454: (strlen(chaine_sauvegarde) +
2455: ((size_t) longueur_courante) +
2456: ((size_t) longueur_decimale_courante) +
2457: ((size_t) longueurs_maximales[2 * j]) +
2458: ((size_t) longueurs_maximales[(2 * j) + 1]) + 2)
2459: * sizeof(unsigned char));
2460:
2461: if (chaine == NULL)
2462: {
2463: (*s_etat_processus).erreur_systeme =
2464: d_es_allocation_memoire;
2465: return(NULL);
2466: }
2467:
2468: strcpy(chaine, chaine_sauvegarde);
2469: free(chaine_sauvegarde);
2470: strcat(chaine, " ");
2471:
2472: ptre = &(chaine[strlen(chaine)]);
2473:
2474: for (k = 0; k < (longueurs_maximales[2 * j]
2475: - longueur_courante); k++, *(ptre++) = ' ');
2476:
2477: (*ptre) = d_code_fin_chaine;
2478: strcat(chaine, chaine_formatee);
2479: ptre = &(chaine[strlen(chaine)]);
2480:
2481: for(k = 0; k < (longueurs_maximales[(2 * j) + 1]
2482: - longueur_decimale_courante);
2483: k++, *(ptre++) = ' ');
2484:
2485: (*ptre) = d_code_fin_chaine;
2486: }
2487: else
2488: {
2489: chaine = (unsigned char *) malloc(
2490: (strlen(chaine_sauvegarde) +
2491: ((size_t) longueur_courante) +
2492: ((size_t) longueur_decimale_courante)
2493: + 2) * sizeof(unsigned char));
2494:
2495: if (chaine == NULL)
2496: {
2497: (*s_etat_processus).erreur_systeme =
2498: d_es_allocation_memoire;
2499: return(NULL);
2500: }
2501:
2502: strcpy(chaine, chaine_sauvegarde);
2503: free(chaine_sauvegarde);
2504: strcat(chaine, " ");
2505: strcat(chaine, chaine_formatee);
2506: }
2507:
2508: free(chaine_formatee);
2509: }
2510:
2511: chaine_sauvegarde = chaine;
2512:
2513: if (i != (nombre_lignes - 1))
2514: {
2515: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2516: {
2517: chaine = (unsigned char *) malloc(
2518: (strlen(chaine_sauvegarde) + 5 +
2519: ((size_t) offset)) * sizeof(unsigned char));
2520:
2521: if (chaine == NULL)
2522: {
2523: (*s_etat_processus).erreur_systeme =
2524: d_es_allocation_memoire;
2525: return(NULL);
2526: }
2527:
2528: strcpy(chaine, chaine_sauvegarde);
2529: free(chaine_sauvegarde);
2530: strcat(chaine, " ]\n");
2531: ptre = &(chaine[strlen(chaine)]);
2532:
2533: for(k = 0; k < offset; k++, *(ptre++) = ' ');
2534:
2535: (*ptre) = d_code_fin_chaine;
2536: strcat(chaine, "[");
2537: }
2538: else
2539: {
2540: chaine = (unsigned char *) malloc(
2541: (strlen(chaine_sauvegarde) + 4)
2542: * sizeof(unsigned char));
2543:
2544: if (chaine == NULL)
2545: {
2546: (*s_etat_processus).erreur_systeme =
2547: d_es_allocation_memoire;
2548: return(NULL);
2549: }
2550:
2551: strcpy(chaine, chaine_sauvegarde);
2552: free(chaine_sauvegarde);
2553: strcat(chaine, " ][");
2554: }
2555: }
2556: }
2557:
2558: free(longueurs_maximales);
2559:
2560: chaine_sauvegarde = chaine;
2561: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2562: + 4) * sizeof(unsigned char));
2563:
2564: if (chaine == NULL)
2565: {
2566: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2567: return(NULL);
2568: }
2569:
2570: strcpy(chaine, chaine_sauvegarde);
2571: free(chaine_sauvegarde);
2572: strcat(chaine, " ]]");
2573: }
2574: }
2575: else if ((*s_objet).type == MIN)
2576: {
2577:
2578: /*
2579: --------------------------------------------------------------------------------
2580: Matrice entière
2581: --------------------------------------------------------------------------------
2582: */
2583:
2584: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
2585: .nombre_lignes;
2586: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
2587: .nombre_colonnes;
2588:
2589: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2590:
2591: if (chaine != NULL)
2592: {
2593: strcpy(chaine, "[[");
2594: offset = ((integer8) strlen(chaine)) + offset_initial - 1;
2595:
2596: if ((longueurs_maximales = malloc(sizeof(unsigned long) *
2597: ((size_t) nombre_colonnes))) == NULL)
2598: {
2599: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2600: return(NULL);
2601: }
2602:
2603: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2604: {
2605: for(j = 0; j < nombre_colonnes; j++)
2606: {
2607: longueurs_maximales[j] = 0;
2608: }
2609:
2610: for(i = 0; i < nombre_lignes; i++)
2611: {
2612: for(j = 0; j < nombre_colonnes; j++)
2613: {
2614: chaine_formatee = formateur_nombre(s_etat_processus,
2615: &(((integer8 **) ((*((struct_matrice *)
2616: ((*s_objet).objet))).tableau))[i][j]), 'I');
2617:
2618: if (chaine_formatee == NULL)
2619: {
2620: (*s_etat_processus).erreur_systeme =
2621: d_es_allocation_memoire;
2622: return(NULL);
2623: }
2624:
2625: longueur_courante = (integer8) strlen(chaine_formatee);
2626: free(chaine_formatee);
2627:
2628: if (longueurs_maximales[j] < longueur_courante)
2629: {
2630: longueurs_maximales[j] = longueur_courante;
2631: }
2632: }
2633: }
2634: }
2635:
2636: for(i = 0; i < nombre_lignes; i++)
2637: {
2638: for(j = 0; j < nombre_colonnes; j++)
2639: {
2640: chaine_formatee = formateur_nombre(s_etat_processus,
2641: &(((integer8 **) ((*((struct_matrice *)
2642: ((*s_objet).objet))).tableau))[i][j]), 'I');
2643:
2644: if (chaine_formatee == NULL)
2645: {
2646: (*s_etat_processus).erreur_systeme =
2647: d_es_allocation_memoire;
2648: return(NULL);
2649: }
2650:
2651: longueur_courante = (integer8) strlen(chaine_formatee);
2652: chaine_sauvegarde = chaine;
2653:
2654: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2655: {
2656: chaine = (unsigned char *) malloc(
2657: (strlen(chaine_sauvegarde) +
2658: ((size_t) longueur_courante)
2659: + ((size_t) longueurs_maximales[j]) + 2)
2660: * sizeof(unsigned char));
2661:
2662: if (chaine == NULL)
2663: {
2664: (*s_etat_processus).erreur_systeme =
2665: d_es_allocation_memoire;
2666: return(NULL);
2667: }
2668:
2669: strcpy(chaine, chaine_sauvegarde);
2670: free(chaine_sauvegarde);
2671: strcat(chaine, " ");
2672:
2673: ptre = &(chaine[strlen(chaine)]);
2674:
2675: for(k = 0; k < (longueurs_maximales[j]
2676: - longueur_courante); k++, *(ptre++) = ' ');
2677:
2678: (*ptre) = d_code_fin_chaine;
2679: }
2680: else
2681: {
2682: chaine = (unsigned char *) malloc(
2683: (strlen(chaine_sauvegarde) +
2684: ((size_t) longueur_courante)
2685: + 2) * sizeof(unsigned char));
2686:
2687: if (chaine == NULL)
2688: {
2689: (*s_etat_processus).erreur_systeme =
2690: d_es_allocation_memoire;
2691: return(NULL);
2692: }
2693:
2694: strcpy(chaine, chaine_sauvegarde);
2695: free(chaine_sauvegarde);
2696: strcat(chaine, " ");
2697: }
2698:
2699: strcat(chaine, chaine_formatee);
2700: free(chaine_formatee);
2701: }
2702:
2703: chaine_sauvegarde = chaine;
2704:
2705: if (i != (nombre_lignes - 1))
2706: {
2707: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2708: {
2709: chaine = (unsigned char *) malloc(
2710: (strlen(chaine_sauvegarde) + 5 +
2711: ((size_t) offset)) * sizeof(unsigned char));
2712:
2713: if (chaine == NULL)
2714: {
2715: (*s_etat_processus).erreur_systeme =
2716: d_es_allocation_memoire;
2717: return(NULL);
2718: }
2719:
2720: strcpy(chaine, chaine_sauvegarde);
2721: free(chaine_sauvegarde);
2722: strcat(chaine, " ]\n");
2723: ptre = &(chaine[strlen(chaine)]);
2724:
2725: for(k = 0; k < offset; k++, *(ptre++) = ' ');
2726:
2727: (*ptre) = d_code_fin_chaine;
2728: strcat(chaine, "[");
2729: }
2730: else
2731: {
2732: chaine = (unsigned char *) malloc(
2733: (strlen(chaine_sauvegarde) + 4)
2734: * sizeof(unsigned char));
2735:
2736: if (chaine == NULL)
2737: {
2738: (*s_etat_processus).erreur_systeme =
2739: d_es_allocation_memoire;
2740: return(NULL);
2741: }
2742:
2743: strcpy(chaine, chaine_sauvegarde);
2744: free(chaine_sauvegarde);
2745: strcat(chaine, " ][");
2746: }
2747: }
2748: }
2749:
2750: free(longueurs_maximales);
2751:
2752: chaine_sauvegarde = chaine;
2753: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2754: + 4) * sizeof(unsigned char));
2755:
2756: if (chaine == NULL)
2757: {
2758: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2759: return(NULL);
2760: }
2761:
2762: strcpy(chaine, chaine_sauvegarde);
2763: free(chaine_sauvegarde);
2764: strcat(chaine, " ]]");
2765: }
2766: }
2767: else if ((*s_objet).type == MRL)
2768: {
2769:
2770: /*
2771: --------------------------------------------------------------------------------
2772: Matrice réelle
2773: --------------------------------------------------------------------------------
2774: */
2775:
2776: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
2777: .nombre_lignes;
2778: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
2779: .nombre_colonnes;
2780:
2781: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2782:
2783: if (chaine != NULL)
2784: {
2785: strcpy(chaine, "[[");
2786: offset = ((integer8) strlen(chaine)) + offset_initial - 1;
2787:
2788: if ((longueurs_maximales = malloc(sizeof(unsigned long) * 2 *
2789: ((size_t) nombre_colonnes))) == NULL)
2790: {
2791: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2792: return(NULL);
2793: }
2794:
2795: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2796: {
2797: for(j = 0; j < (2 * nombre_colonnes); j++)
2798: {
2799: longueurs_maximales[j] = 0;
2800: }
2801:
2802: for(i = 0; i < nombre_lignes; i++)
2803: {
2804: for(j = 0; j < nombre_colonnes; j++)
2805: {
2806: chaine_formatee = formateur_nombre(s_etat_processus,
2807: &(((real8 **) ((*((struct_matrice *)
2808: ((*s_objet).objet))).tableau))[i][j]), 'R');
2809:
2810: if (chaine_formatee == NULL)
2811: {
2812: (*s_etat_processus).erreur_systeme =
2813: d_es_allocation_memoire;
2814: return(NULL);
2815: }
2816:
2817: longueur_courante = (integer8) strlen(chaine_formatee);
2818: longueur_decimale_courante = 0;
2819:
2820: if ((ptrl = index(chaine_formatee,
2821: (test_cfsf(s_etat_processus, 48) == d_vrai)
2822: ? ',' : '.')) != NULL)
2823: {
2824: longueur_decimale_courante = longueur_courante
2825: - (ptrl - chaine_formatee);
2826: longueur_courante = ptrl - chaine_formatee;
2827: }
2828:
2829: free(chaine_formatee);
2830:
2831: if (longueurs_maximales[2 * j] < longueur_courante)
2832: {
2833: longueurs_maximales[2 * j] = longueur_courante;
2834: }
2835:
2836: if (longueurs_maximales[(2 * j) + 1] <
2837: longueur_decimale_courante)
2838: {
2839: longueurs_maximales[(2 * j) + 1] =
2840: longueur_decimale_courante;
2841: }
2842: }
2843: }
2844: }
2845:
2846: for(i = 0; i < nombre_lignes; i++)
2847: {
2848: for(j = 0; j < nombre_colonnes; j++)
2849: {
2850: chaine_formatee = formateur_nombre(s_etat_processus,
2851: &(((real8 **) ((*((struct_matrice *)
2852: ((*s_objet).objet))).tableau))[i][j]), 'R');
2853:
2854: if (chaine_formatee == NULL)
2855: {
2856: (*s_etat_processus).erreur_systeme =
2857: d_es_allocation_memoire;
2858: return(NULL);
2859: }
2860:
2861: longueur_courante = (integer8) strlen(chaine_formatee);
2862: longueur_decimale_courante = 0;
2863:
2864: if ((ptrl = index(chaine_formatee,
2865: (test_cfsf(s_etat_processus, 48) == d_vrai)
2866: ? ',' : '.')) != NULL)
2867: {
2868: longueur_decimale_courante = longueur_courante
2869: - (ptrl - chaine_formatee);
2870: longueur_courante = ptrl - chaine_formatee;
2871: }
2872:
2873: chaine_sauvegarde = chaine;
2874:
2875: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2876: {
2877: chaine = (unsigned char *) malloc(
2878: (strlen(chaine_sauvegarde) +
2879: ((size_t) longueur_courante) +
2880: ((size_t) longueur_decimale_courante) +
2881: ((size_t) longueurs_maximales[2 * j]) +
2882: ((size_t) longueurs_maximales[(2 * j) + 1]) + 2)
2883: * sizeof(unsigned char));
2884:
2885: if (chaine == NULL)
2886: {
2887: (*s_etat_processus).erreur_systeme =
2888: d_es_allocation_memoire;
2889: return(NULL);
2890: }
2891:
2892: strcpy(chaine, chaine_sauvegarde);
2893: free(chaine_sauvegarde);
2894: strcat(chaine, " ");
2895:
2896: ptre = &(chaine[strlen(chaine)]);
2897:
2898: for(k = 0; k < (longueurs_maximales[2 * j]
2899: - longueur_courante); k++, *(ptre++) = ' ');
2900:
2901: (*ptre) = d_code_fin_chaine;
2902: strcat(chaine, chaine_formatee);
2903: ptre = &(chaine[strlen(chaine)]);
2904:
2905: for(k = 0; k < (longueurs_maximales[(2 * j) + 1]
2906: - longueur_decimale_courante);
2907: k++, *(ptre++) = ' ');
2908:
2909: (*ptre) = d_code_fin_chaine;
2910: }
2911: else
2912: {
2913: chaine = (unsigned char *) malloc(
2914: (strlen(chaine_sauvegarde) +
2915: ((size_t) longueur_courante) +
2916: ((size_t) longueur_decimale_courante)
2917: + 2) * sizeof(unsigned char));
2918:
2919: if (chaine == NULL)
2920: {
2921: (*s_etat_processus).erreur_systeme =
2922: d_es_allocation_memoire;
2923: return(NULL);
2924: }
2925:
2926: strcpy(chaine, chaine_sauvegarde);
2927: free(chaine_sauvegarde);
2928: strcat(chaine, " ");
2929: strcat(chaine, chaine_formatee);
2930: }
2931:
2932: free(chaine_formatee);
2933: }
2934:
2935: chaine_sauvegarde = chaine;
2936:
2937: if (i != (nombre_lignes - 1))
2938: {
2939: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2940: {
2941: chaine = (unsigned char *) malloc(
2942: (strlen(chaine_sauvegarde) + 5 +
2943: ((size_t) offset)) * sizeof(unsigned char));
2944:
2945: if (chaine == NULL)
2946: {
2947: (*s_etat_processus).erreur_systeme =
2948: d_es_allocation_memoire;
2949: return(NULL);
2950: }
2951:
2952: strcpy(chaine, chaine_sauvegarde);
2953: free(chaine_sauvegarde);
2954: strcat(chaine, " ]\n");
2955: ptre = &(chaine[strlen(chaine)]);
2956:
2957: for(k = 0; k < offset; k++, *(ptre++) = ' ');
2958:
2959: (*ptre) = d_code_fin_chaine;
2960: strcat(chaine, "[");
2961: }
2962: else
2963: {
2964: chaine = (unsigned char *) malloc(
2965: (strlen(chaine_sauvegarde) + 4)
2966: * sizeof(unsigned char));
2967:
2968: if (chaine == NULL)
2969: {
2970: (*s_etat_processus).erreur_systeme =
2971: d_es_allocation_memoire;
2972: return(NULL);
2973: }
2974:
2975: strcpy(chaine, chaine_sauvegarde);
2976: free(chaine_sauvegarde);
2977: strcat(chaine, " ][");
2978: }
2979: }
2980: }
2981:
2982: free(longueurs_maximales);
2983:
2984: chaine_sauvegarde = chaine;
2985: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2986: + 4) * sizeof(unsigned char));
2987:
2988: if (chaine == NULL)
2989: {
2990: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2991: return(NULL);
2992: }
2993:
2994: strcpy(chaine, chaine_sauvegarde);
2995: free(chaine_sauvegarde);
2996: strcat(chaine, " ]]");
2997: }
2998: }
2999: else if ((*s_objet).type == MTX)
3000: {
3001: if (alsprintf(&chaine, "Mutex $ %016lX owned by $ %016lX",
3002: (unsigned long) &((*((struct_mutex *) (*s_objet).objet)).mutex),
3003: (unsigned long) (*((struct_mutex *) (*s_objet).objet)).tid) < 0)
3004: {
3005: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3006: return(NULL);
3007: }
3008: }
3009: else if ((*s_objet).type == NOM)
3010: {
3011:
3012: /*
3013: --------------------------------------------------------------------------------
3014: Nom
3015: --------------------------------------------------------------------------------
3016: */
3017:
3018: if ((*((struct_nom *) (*s_objet).objet)).symbole == d_vrai)
3019: {
3020: chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
3021: (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
3022:
3023: if (chaine == NULL)
3024: {
3025: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3026: return(NULL);
3027: }
3028:
3029: sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom);
3030: }
3031: else
3032: {
3033: chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
3034: (*s_objet).objet)).nom) + 1) * sizeof(unsigned char));
3035:
3036: if (chaine == NULL)
3037: {
3038: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3039: return(NULL);
3040: }
3041:
3042: sprintf(chaine, "%s", (*((struct_nom *) (*s_objet).objet)).nom);
3043: }
3044: }
3045: else if ((*s_objet).type == REL)
3046: {
3047:
3048: /*
3049: --------------------------------------------------------------------------------
3050: Réel
3051: --------------------------------------------------------------------------------
3052: */
3053:
3054: chaine_formatee = formateur_nombre(s_etat_processus,
3055: ((real8 *) ((*s_objet).objet)), 'R');
3056:
3057: if (chaine_formatee == NULL)
3058: {
3059: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3060: return(NULL);
3061: }
3062:
3063: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1)
3064: * sizeof(unsigned char));
3065:
3066: if (chaine == NULL)
3067: {
3068: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3069: return(NULL);
3070: }
3071:
3072: strcpy(chaine, chaine_formatee);
3073: free(chaine_formatee);
3074: }
3075: else if ((*s_objet).type == VCX)
3076: {
3077:
3078: /*
3079: --------------------------------------------------------------------------------
3080: Vecteur complexe
3081: --------------------------------------------------------------------------------
3082: */
3083:
3084: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
3085: .taille;
3086:
3087: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
3088:
3089: if (chaine != NULL)
3090: {
3091: strcpy(chaine, "[");
3092:
3093: for(i = 0; i < nombre_colonnes; i++)
3094: {
3095: chaine_formatee = formateur_nombre(s_etat_processus,
3096: &(((struct_complexe16 *) ((*((struct_vecteur *)
3097: ((*s_objet).objet))).tableau))[i]), 'C');
3098:
3099: if (chaine_formatee == NULL)
3100: {
3101: (*s_etat_processus).erreur_systeme =
3102: d_es_allocation_memoire;
3103: return(NULL);
3104: }
3105:
3106: chaine_sauvegarde = chaine;
3107: chaine = (unsigned char *) malloc(
3108: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
3109: + 2) * sizeof(unsigned char));
3110:
3111: if (chaine == NULL)
3112: {
3113: (*s_etat_processus).erreur_systeme =
3114: d_es_allocation_memoire;
3115: return(NULL);
3116: }
3117:
3118: strcpy(chaine, chaine_sauvegarde);
3119: free(chaine_sauvegarde);
3120: strcat(chaine, " ");
3121: strcat(chaine, chaine_formatee);
3122: free(chaine_formatee);
3123: }
3124:
3125: chaine_sauvegarde = chaine;
3126: chaine = (unsigned char *) malloc(
3127: (strlen(chaine_sauvegarde) + 3)
3128: * sizeof(unsigned char));
3129:
3130: if (chaine == NULL)
3131: {
3132: (*s_etat_processus).erreur_systeme =
3133: d_es_allocation_memoire;
3134: return(NULL);
3135: }
3136:
3137: strcpy(chaine, chaine_sauvegarde);
3138: free(chaine_sauvegarde);
3139: strcat(chaine, " ]");
3140: }
3141: }
3142: else if ((*s_objet).type == VIN)
3143: {
3144:
3145: /*
3146: --------------------------------------------------------------------------------
3147: Vecteur entier
3148: --------------------------------------------------------------------------------
3149: */
3150:
3151: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
3152: .taille;
3153:
3154: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
3155:
3156: if (chaine != NULL)
3157: {
3158: strcpy(chaine, "[");
3159:
3160: for(i = 0; i < nombre_colonnes; i++)
3161: {
3162: chaine_formatee = formateur_nombre(s_etat_processus,
3163: &(((integer8 *) ((*((struct_vecteur *)
3164: ((*s_objet).objet))).tableau))[i]), 'I');
3165:
3166: if (chaine_formatee == NULL)
3167: {
3168: (*s_etat_processus).erreur_systeme =
3169: d_es_allocation_memoire;
3170: return(NULL);
3171: }
3172:
3173: chaine_sauvegarde = chaine;
3174: chaine = (unsigned char *) malloc(
3175: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
3176: + 2) * sizeof(unsigned char));
3177:
3178: if (chaine == NULL)
3179: {
3180: (*s_etat_processus).erreur_systeme =
3181: d_es_allocation_memoire;
3182: return(NULL);
3183: }
3184:
3185: strcpy(chaine, chaine_sauvegarde);
3186: free(chaine_sauvegarde);
3187: strcat(chaine, " ");
3188: strcat(chaine, chaine_formatee);
3189: free(chaine_formatee);
3190: }
3191:
3192: chaine_sauvegarde = chaine;
3193: chaine = (unsigned char *) malloc(
3194: (strlen(chaine_sauvegarde) + 3)
3195: * sizeof(unsigned char));
3196:
3197: if (chaine == NULL)
3198: {
3199: (*s_etat_processus).erreur_systeme =
3200: d_es_allocation_memoire;
3201: return(NULL);
3202: }
3203:
3204: strcpy(chaine, chaine_sauvegarde);
3205: free(chaine_sauvegarde);
3206: strcat(chaine, " ]");
3207: }
3208: }
3209: else if ((*s_objet).type == VRL)
3210: {
3211:
3212: /*
3213: --------------------------------------------------------------------------------
3214: Vecteur réel
3215: --------------------------------------------------------------------------------
3216: */
3217:
3218: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
3219: .taille;
3220:
3221: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
3222:
3223: if (chaine != NULL)
3224: {
3225: strcpy(chaine, "[");
3226:
3227: for(i = 0; i < nombre_colonnes; i++)
3228: {
3229: chaine_formatee = formateur_nombre(s_etat_processus,
3230: &(((real8 *) ((*((struct_vecteur *)
3231: ((*s_objet).objet))).tableau))[i]), 'R');
3232:
3233: if (chaine_formatee == NULL)
3234: {
3235: (*s_etat_processus).erreur_systeme =
3236: d_es_allocation_memoire;
3237: return(NULL);
3238: }
3239:
3240: chaine_sauvegarde = chaine;
3241: chaine = (unsigned char *) malloc(
3242: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
3243: + 2) * sizeof(unsigned char));
3244:
3245: if (chaine == NULL)
3246: {
3247: (*s_etat_processus).erreur_systeme =
3248: d_es_allocation_memoire;
3249: return(NULL);
3250: }
3251:
3252: strcpy(chaine, chaine_sauvegarde);
3253: free(chaine_sauvegarde);
3254: strcat(chaine, " ");
3255: strcat(chaine, chaine_formatee);
3256: free(chaine_formatee);
3257: }
3258:
3259: chaine_sauvegarde = chaine;
3260: chaine = (unsigned char *) malloc(
3261: (strlen(chaine_sauvegarde) + 3)
3262: * sizeof(unsigned char));
3263:
3264: if (chaine == NULL)
3265: {
3266: (*s_etat_processus).erreur_systeme =
3267: d_es_allocation_memoire;
3268: return(NULL);
3269: }
3270:
3271: strcpy(chaine, chaine_sauvegarde);
3272: free(chaine_sauvegarde);
3273: strcat(chaine, " ]");
3274: }
3275: }
3276:
3277: return(chaine);
3278: }
3279:
3280:
3281: /*
3282: ================================================================================
3283: Routines qui transforment un nombre entier, réel ou complexe en chaîne de
3284: caractères suivant le format courant
3285: ================================================================================
3286: Entrées : pointeur générique sur la donnée numérique à convertir,
3287: type de l'entité (I, R ou C).
3288: --------------------------------------------------------------------------------
3289: Sorties : chaîne de caractères allouée dans la routine
3290: --------------------------------------------------------------------------------
3291: Effets de bord : néant
3292: ================================================================================
3293: */
3294:
3295: /*
3296: --------------------------------------------------------------------------------
3297: Formatage des complexes, réels et entiers
3298: --------------------------------------------------------------------------------
3299: */
3300:
3301: unsigned char *
3302: formateur_nombre(struct_processus *s_etat_processus,
3303: void *valeur_numerique, unsigned char type)
3304: {
3305: unsigned char *chaine;
3306: unsigned char *construction_chaine;
3307: unsigned char *sauvegarde;
3308: unsigned char *tampon;
3309:
3310: chaine = NULL;
3311:
3312: switch(type)
3313: {
3314: case 'C' :
3315: {
3316: construction_chaine = (unsigned char *) malloc(
3317: 2 * sizeof(unsigned char));
3318:
3319: if (construction_chaine == NULL)
3320: {
3321: (*s_etat_processus).erreur_systeme =
3322: d_es_allocation_memoire;
3323: return(NULL);
3324: }
3325:
3326: strcpy(construction_chaine, "(");
3327:
3328: tampon = formateur_reel(s_etat_processus,
3329: &((*((struct_complexe16 *)
3330: valeur_numerique)).partie_reelle), 'R');
3331:
3332: if (tampon == NULL)
3333: {
3334: (*s_etat_processus).erreur_systeme =
3335: d_es_allocation_memoire;
3336: return(NULL);
3337: }
3338:
3339: sauvegarde = construction_chaine;
3340:
3341: construction_chaine = (unsigned char *) malloc(
3342: (strlen(sauvegarde) + strlen(tampon) + 2)
3343: * sizeof(unsigned char));
3344:
3345: if (construction_chaine == NULL)
3346: {
3347: (*s_etat_processus).erreur_systeme =
3348: d_es_allocation_memoire;
3349: return(NULL);
3350: }
3351:
3352: strcpy(construction_chaine, sauvegarde);
3353: free(sauvegarde);
3354: strcat(construction_chaine, tampon);
3355: free(tampon);
3356:
3357: if (test_cfsf(s_etat_processus, 48) == d_faux)
3358: {
3359: strcat(construction_chaine, ",");
3360: }
3361: else
3362: {
3363: strcat(construction_chaine, ".");
3364: }
3365:
3366: tampon = formateur_reel(s_etat_processus,
3367: &((*((struct_complexe16 *)
3368: valeur_numerique)).partie_imaginaire), 'R');
3369:
3370: if (tampon == NULL)
3371: {
3372: (*s_etat_processus).erreur_systeme =
3373: d_es_allocation_memoire;
3374: return(NULL);
3375: }
3376:
3377: sauvegarde = construction_chaine;
3378:
3379: construction_chaine = (unsigned char *) malloc(
3380: (strlen(sauvegarde) + strlen(tampon) + 2)
3381: * sizeof(unsigned char));
3382:
3383: if (construction_chaine == NULL)
3384: {
3385: (*s_etat_processus).erreur_systeme =
3386: d_es_allocation_memoire;
3387: return(NULL);
3388: }
3389:
3390: strcpy(construction_chaine, sauvegarde);
3391: free(sauvegarde);
3392: strcat(construction_chaine, tampon);
3393: free(tampon);
3394: strcat(construction_chaine, ")");
3395:
3396: chaine = construction_chaine;
3397:
3398: break;
3399: }
3400:
3401: case 'R' :
3402: {
3403: chaine = formateur_reel(s_etat_processus, valeur_numerique, 'R');
3404:
3405: if (chaine == NULL)
3406: {
3407: (*s_etat_processus).erreur_systeme =
3408: d_es_allocation_memoire;
3409: return(NULL);
3410: }
3411:
3412: break;
3413: }
3414:
3415: default :
3416: case 'I' :
3417: {
3418: chaine = formateur_reel(s_etat_processus, valeur_numerique, 'I');
3419:
3420: if (chaine == NULL)
3421: {
3422: (*s_etat_processus).erreur_systeme =
3423: d_es_allocation_memoire;
3424: return(NULL);
3425: }
3426:
3427: break;
3428: }
3429: }
3430:
3431: return(chaine);
3432: }
3433:
3434:
3435: /*
3436: --------------------------------------------------------------------------------
3437: Formateur des réels et entiers
3438: --------------------------------------------------------------------------------
3439: */
3440:
3441: unsigned char *
3442: formateur_reel(struct_processus *s_etat_processus,
3443: void *valeur_numerique, unsigned char type)
3444: {
3445: real8 mantisse;
3446: real8 tampon_reel;
3447:
3448: integer8 tampon_entier;
3449:
3450: logical1 i49;
3451: logical1 i50;
3452:
3453: long correction;
3454: long dernier_chiffre_significatif;
3455: long exposant;
3456: long i;
3457: long j;
3458: long longueur_utile;
3459: long longueur_utile_limite;
3460:
3461: unsigned char *chaine;
3462: unsigned char format[32 + 1];
3463: unsigned char mode[3 + 1];
3464: unsigned char *ptr;
3465: unsigned char tampon[32 + 1];
3466:
3467: chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
3468:
3469: if (chaine == NULL)
3470: {
3471: (*s_etat_processus).erreur_systeme =
3472: d_es_allocation_memoire;
3473: return(NULL);
3474: }
3475:
3476: if (type == 'R')
3477: {
3478: # ifdef FP_INFINITE
3479: int signe;
3480:
3481: if ((signe = isinf((*((real8 *) valeur_numerique)))) != 0)
3482: {
3483: if (signe > 0)
3484: {
3485: strcpy(chaine, "infinity");
3486: }
3487: else
3488: {
3489: strcpy(chaine, "-infinity");
3490: }
3491:
3492: return(chaine);
3493: }
3494: # endif
3495:
3496: if (isnan((*((real8 *) valeur_numerique))))
3497: {
3498: strcpy(chaine, "undef");
3499: return(chaine);
3500: }
3501:
3502: tampon_reel = *((real8 *) valeur_numerique);
3503:
3504: if (tampon_reel > ((real8) 0))
3505: {
3506: exposant = (long) floor(log10(tampon_reel));
3507: }
3508: else if (tampon_reel < ((real8) 0))
3509: {
3510: exposant = (long) floor(log10(-tampon_reel));
3511: }
3512: else
3513: {
3514: exposant = 0;
3515: }
3516:
3517: mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
3518: }
3519: else
3520: {
3521: tampon_entier = *((integer8 *) valeur_numerique);
3522:
3523: if (tampon_entier > ((integer8) 0))
3524: {
3525: exposant = (long) floor(log10((double) tampon_entier));
3526: }
3527: else if (tampon_entier < ((integer8) 0))
3528: {
3529: if (tampon_entier != INT64_MIN)
3530: {
3531: exposant = (long) floor(log10((double) -tampon_entier));
3532: }
3533: else
3534: {
3535: tampon_reel = (real8) tampon_entier;
3536: exposant = (long) floor(log10(-tampon_reel));
3537: }
3538: }
3539: else
3540: {
3541: exposant = 0;
3542: }
3543:
3544: mantisse = ((real8) (*((integer8 *) valeur_numerique))) /
3545: pow(10, (double) exposant);
3546: }
3547:
3548: longueur_utile = 0;
3549: j = 1;
3550:
3551: for(i = 53; i <= 56; i++)
3552: {
3553: longueur_utile += (test_cfsf(s_etat_processus, (unsigned char) i)
3554: == d_vrai) ? j : 0;
3555: j *= 2;
3556: }
3557:
3558: longueur_utile_limite = 15;
3559:
3560: if (longueur_utile > longueur_utile_limite)
3561: {
3562: longueur_utile = longueur_utile_limite;
3563: }
3564:
3565: i49 = test_cfsf(s_etat_processus, 49);
3566: i50 = test_cfsf(s_etat_processus, 50);
3567:
3568: if (i49 == d_faux)
3569: {
3570: if (i50 == d_faux)
3571: {
3572:
3573: /*
3574: --------------------------------------------------------------------------------
3575: Mode standard
3576: --------------------------------------------------------------------------------
3577: */
3578:
3579: strcpy(mode, "STD");
3580: }
3581: else
3582: {
3583:
3584: /*
3585: --------------------------------------------------------------------------------
3586: Mode scientifique
3587: --------------------------------------------------------------------------------
3588: */
3589:
3590: strcpy(mode, "SCI");
3591: }
3592: }
3593: else
3594: {
3595: if (i50 == d_faux)
3596: {
3597:
3598: /*
3599: --------------------------------------------------------------------------------
3600: Mode fixe
3601: --------------------------------------------------------------------------------
3602: */
3603:
3604: strcpy(mode, "FIX");
3605: }
3606: else
3607: {
3608:
3609: /*
3610: --------------------------------------------------------------------------------
3611: Mode ingénieur
3612: --------------------------------------------------------------------------------
3613: */
3614:
3615: strcpy(mode, "ENG");
3616: }
3617: }
3618:
3619: // Test portant sur le nombre de chiffres significatifs dans
3620: // le cas du format STD pour que 1.2E-15 apparaisse en notation
3621: // SCI car il y a une perte de précision dans l'affichage.
3622:
3623: if ((strcmp(mode, "STD") == 0) && (type == 'R'))
3624: {
3625: if (abs(*((real8 *) valeur_numerique)) < 1)
3626: {
3627: dernier_chiffre_significatif = -exposant;
3628: sprintf(tampon, ".%f", mantisse);
3629:
3630: ptr = &(tampon[strlen(tampon) - 1]);
3631:
3632: while((*ptr) != '.')
3633: {
3634: if ((*ptr) != '0')
3635: {
3636: dernier_chiffre_significatif++;
3637: }
3638:
3639: ptr--;
3640: }
3641: }
3642: else
3643: {
3644: dernier_chiffre_significatif = 0;
3645: }
3646: }
3647: else
3648: {
3649: dernier_chiffre_significatif = 0;
3650: }
3651:
3652: if ((strcmp(mode, "SCI") == 0) ||
3653: ((strcmp(mode, "STD") == 0) && ((exposant >
3654: longueur_utile_limite) || (dernier_chiffre_significatif > 15) ||
3655: (exposant < -longueur_utile_limite))) ||
3656: ((strcmp(mode, "FIX") == 0) &&
3657: ((exposant >= longueur_utile_limite) ||
3658: (exposant < -longueur_utile))))
3659: {
3660: chaine[0] = d_code_fin_chaine;
3661: format[0] = d_code_fin_chaine;
3662:
3663: if (strcmp(mode, "STD") == 0)
3664: {
3665: longueur_utile = longueur_utile_limite - 1;
3666: }
3667:
3668: sprintf(format, "%%.%luf", longueur_utile);
3669: sprintf(tampon, format, mantisse);
3670: strcpy(chaine, tampon);
3671:
3672: if (strcmp(mode, "STD") == 0)
3673: {
3674: ptr = &(chaine[strlen(chaine) - 1]);
3675: while(((*ptr) == '0') || ((*ptr) == '.'))
3676: {
3677: (*ptr) = d_code_fin_chaine;
3678: ptr--;
3679: }
3680: }
3681:
3682: strcat(chaine, "E");
3683: sprintf(tampon, "%ld", exposant);
3684: strcat(chaine, tampon);
3685: }
3686: else if (strcmp(mode, "FIX") == 0)
3687: {
3688: chaine[0] = d_code_fin_chaine;
3689: format[0] = d_code_fin_chaine;
3690:
3691: if (longueur_utile + exposant >= longueur_utile_limite)
3692: {
3693: longueur_utile = longueur_utile_limite - (exposant + 1);
3694: }
3695:
3696: sprintf(format, "%%.%luf", longueur_utile);
3697:
3698: sprintf(tampon, format, (mantisse * pow(10, (double) exposant)));
3699: strcpy(chaine, tampon);
3700: }
3701: else if (strcmp(mode, "ENG") == 0)
3702: {
3703: chaine[0] = d_code_fin_chaine;
3704: format[0] = d_code_fin_chaine;
3705:
3706: correction = labs(exposant) % 3;
3707:
3708: if (exposant < 0)
3709: {
3710: if (correction == 0)
3711: {
3712: correction = 3;
3713: }
3714:
3715: correction = 3 - correction;
3716: }
3717:
3718: longueur_utile -= correction;
3719: sprintf(format, "%%.%luf", longueur_utile);
3720:
3721: sprintf(tampon, format, (mantisse * pow(10, (double) correction)));
3722: strcpy(chaine, tampon);
3723: strcat(chaine, "E");
3724: sprintf(tampon, "%ld", (exposant - correction));
3725: strcat(chaine, tampon);
3726: }
3727: else
3728: {
3729: if (type == 'I')
3730: {
3731: chaine[0] = d_code_fin_chaine;
3732: sprintf(tampon, "%lld", *((integer8 *) valeur_numerique));
3733: }
3734: else
3735: {
3736: chaine[0] = d_code_fin_chaine;
3737: format[0] = d_code_fin_chaine;
3738:
3739: if (exposant >= 0)
3740: {
3741: if ((exposant + 1) < longueur_utile_limite)
3742: {
3743: sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
3744: - 1));
3745: }
3746: else
3747: {
3748: strcpy(format, "%.0f.");
3749: }
3750: }
3751: else
3752: {
3753: sprintf(format, "%%.%luf", longueur_utile_limite);
3754: }
3755:
3756: sprintf(tampon, format, *((real8 *) valeur_numerique));
3757:
3758: i = ((long) strlen(tampon)) - 1;
3759: while(tampon[i] == '0')
3760: {
3761: tampon[i] = d_code_fin_chaine;
3762: i--;
3763: }
3764:
3765: if (ds_imposition_separateur_decimal == d_faux)
3766: {
3767: i = ((long) strlen(tampon)) - 1;
3768: if (tampon[i] == '.')
3769: {
3770: tampon[i] = d_code_fin_chaine;
3771: }
3772: }
3773: }
3774:
3775: strcpy(chaine, tampon);
3776: }
3777:
3778: if (test_cfsf(s_etat_processus, 48) == d_vrai)
3779: {
3780: for(i = 0; i < (long) strlen(chaine); i++)
3781: {
3782: if (chaine[i] == '.')
3783: {
3784: chaine[i] = ',';
3785: }
3786: }
3787: }
3788:
3789: return(chaine);
3790: }
3791:
3792: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to formateur.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src