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