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