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