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