1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.32
4: Copyright (C) 1989-2020 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 == REC)
3311: {
3312: chaine = (unsigned char *) malloc(4 * sizeof(unsigned char));
3313:
3314: if (chaine == NULL)
3315: {
3316: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3317: return(NULL);
3318: }
3319:
3320: strcpy(chaine, "|[ ");
3321: offset = ((integer8) strlen(chaine)) + offset_initial;
3322:
3323: // L'objet se compose de deux tables à une dimension de
3324: // mêmes tailles.
3325:
3326: chaine_sauvegarde = chaine;
3327:
3328: if ((chaine_formatee = formateur(s_etat_processus, (long) offset,
3329: (*((struct_record *) (*s_objet).objet)).noms)) == NULL)
3330: {
3331: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3332: return(NULL);
3333: }
3334:
3335: if ((chaine = (unsigned char *) malloc((strlen(chaine_formatee)
3336: + strlen(chaine_sauvegarde) + 1)
3337: * sizeof(unsigned char))) == NULL)
3338: {
3339: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3340: return(NULL);
3341: }
3342:
3343: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
3344: free(chaine_sauvegarde);
3345: free(chaine_formatee);
3346:
3347: if (test_cfsf(s_etat_processus, 45) == d_vrai)
3348: {
3349: chaine_sauvegarde = chaine;
3350:
3351: if ((chaine = (unsigned char *) malloc(
3352: (strlen(chaine_sauvegarde) + 2) * sizeof(unsigned char)))
3353: == NULL)
3354: {
3355: (*s_etat_processus).erreur_systeme =
3356: d_es_allocation_memoire;
3357: return(NULL);
3358: }
3359:
3360: strcpy(chaine, chaine_sauvegarde);
3361: free(chaine_sauvegarde);
3362: strcat(chaine, "\n");
3363:
3364: chaine_sauvegarde = chaine;
3365:
3366: chaine = (unsigned char *) malloc(
3367: (strlen(chaine_sauvegarde) + 1 + ((size_t) offset))
3368: * sizeof(unsigned char));
3369:
3370: if (chaine == NULL)
3371: {
3372: (*s_etat_processus).erreur_systeme =
3373: d_es_allocation_memoire;
3374: return(NULL);
3375: }
3376:
3377: strcpy(chaine, chaine_sauvegarde);
3378: free(chaine_sauvegarde);
3379: ptre = &(chaine[strlen(chaine)]);
3380:
3381: for(k = 0; k < offset; k++, *(ptre++) = ' ');
3382:
3383: (*ptre) = d_code_fin_chaine;
3384: }
3385: else
3386: {
3387: chaine_sauvegarde = chaine;
3388:
3389: if ((chaine = (unsigned char *) malloc(
3390: (strlen(chaine_sauvegarde) + 2)
3391: * sizeof(unsigned char))) == NULL)
3392: {
3393: (*s_etat_processus).erreur_systeme =
3394: d_es_allocation_memoire;
3395: return(NULL);
3396: }
3397:
3398: strcpy(chaine, chaine_sauvegarde);
3399: free(chaine_sauvegarde);
3400: strcat(chaine, " ");
3401: }
3402:
3403: chaine_sauvegarde = chaine;
3404:
3405: if ((chaine_formatee = formateur(s_etat_processus, (long) offset,
3406: (*((struct_record *) (*s_objet).objet)).donnees)) == NULL)
3407: {
3408: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3409: return(NULL);
3410: }
3411:
3412: if ((chaine = (unsigned char *) malloc((strlen(chaine_formatee)
3413: + strlen(chaine_sauvegarde) + 1)
3414: * sizeof(unsigned char))) == NULL)
3415: {
3416: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3417: return(NULL);
3418: }
3419:
3420: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
3421: free(chaine_sauvegarde);
3422: free(chaine_formatee);
3423:
3424: chaine_sauvegarde = chaine;
3425: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4)
3426: * sizeof(unsigned char));
3427:
3428: if (chaine == NULL)
3429: {
3430: (*s_etat_processus).erreur_systeme =
3431: d_es_allocation_memoire;
3432: return(NULL);
3433: }
3434:
3435: strcpy(chaine, chaine_sauvegarde);
3436: free(chaine_sauvegarde);
3437: strcat(chaine, " ]|");
3438: }
3439: else if ((*s_objet).type == NON)
3440: {
3441: if ((chaine = malloc((strlen("System object") + 1)
3442: * sizeof(unsigned char))) == NULL)
3443: {
3444: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3445: return(NULL);
3446: }
3447:
3448: strcpy(chaine, "System object");
3449: }
3450: else if ((*s_objet).type == EXT)
3451: {
3452: l_element_courant = (*s_etat_processus).s_bibliotheques;
3453:
3454: while(l_element_courant != NULL)
3455: {
3456: if ((*((struct_bibliotheque *) (*l_element_courant).donnee))
3457: .descripteur == (*s_objet).descripteur_bibliotheque)
3458: {
3459: if ((__type_disp = dlsym((*s_objet).descripteur_bibliotheque,
3460: "__type_disp")) == NULL)
3461: {
3462: // Symbole externe non affichable
3463:
3464: if ((chaine = malloc((strlen(
3465: "External symbol (disp function not found)") + 1)
3466: * sizeof(unsigned char))) == NULL)
3467: {
3468: (*s_etat_processus).erreur_systeme =
3469: d_es_allocation_memoire;
3470: return(NULL);
3471: }
3472:
3473: strcpy(chaine, "External symbol (disp function not found)");
3474: }
3475: else
3476: {
3477: // Symbole externe affichable
3478: void **arg;
3479:
3480: arg = (void **) &s_objet;
3481: __type_disp(s_etat_processus, arg);
3482: chaine = (unsigned char *) (*arg);
3483: }
3484:
3485: break;
3486: }
3487:
3488: l_element_courant = (*l_element_courant).suivant;
3489: }
3490:
3491: if (l_element_courant == NULL)
3492: {
3493: // Symbole externe non affichable
3494:
3495: if ((chaine = malloc((strlen("External symbol") + 1)
3496: * sizeof(unsigned char))) == NULL)
3497: {
3498: (*s_etat_processus).erreur_systeme =
3499: d_es_allocation_memoire;
3500: return(NULL);
3501: }
3502:
3503: strcpy(chaine, "External symbol");
3504: }
3505: }
3506: else
3507: {
3508: BUG(1, uprintf("Unknown symbol type\n"));
3509: }
3510:
3511: return(chaine);
3512: }
3513:
3514:
3515: /*
3516: ================================================================================
3517: Routines qui transforment un nombre entier, réel ou complexe en chaîne de
3518: caractères suivant le format courant
3519: ================================================================================
3520: Entrées : pointeur générique sur la donnée numérique à convertir,
3521: type de l'entité (I, R ou C).
3522: --------------------------------------------------------------------------------
3523: Sorties : chaîne de caractères allouée dans la routine
3524: --------------------------------------------------------------------------------
3525: Effets de bord : néant
3526: ================================================================================
3527: */
3528:
3529: /*
3530: --------------------------------------------------------------------------------
3531: Formatage des complexes, réels et entiers
3532: --------------------------------------------------------------------------------
3533: */
3534:
3535: unsigned char *
3536: formateur_nombre(struct_processus *s_etat_processus,
3537: void *valeur_numerique, unsigned char type)
3538: {
3539: unsigned char *chaine;
3540: unsigned char *construction_chaine;
3541: unsigned char *sauvegarde;
3542: unsigned char *tampon;
3543:
3544: chaine = NULL;
3545:
3546: switch(type)
3547: {
3548: case 'C' :
3549: {
3550: construction_chaine = (unsigned char *) malloc(
3551: 2 * sizeof(unsigned char));
3552:
3553: if (construction_chaine == NULL)
3554: {
3555: (*s_etat_processus).erreur_systeme =
3556: d_es_allocation_memoire;
3557: return(NULL);
3558: }
3559:
3560: strcpy(construction_chaine, "(");
3561:
3562: tampon = formateur_reel(s_etat_processus,
3563: &((*((struct_complexe16 *)
3564: valeur_numerique)).partie_reelle), 'R');
3565:
3566: if (tampon == NULL)
3567: {
3568: (*s_etat_processus).erreur_systeme =
3569: d_es_allocation_memoire;
3570: return(NULL);
3571: }
3572:
3573: sauvegarde = construction_chaine;
3574:
3575: construction_chaine = (unsigned char *) malloc(
3576: (strlen(sauvegarde) + strlen(tampon) + 2)
3577: * sizeof(unsigned char));
3578:
3579: if (construction_chaine == NULL)
3580: {
3581: (*s_etat_processus).erreur_systeme =
3582: d_es_allocation_memoire;
3583: return(NULL);
3584: }
3585:
3586: strcpy(construction_chaine, sauvegarde);
3587: free(sauvegarde);
3588: strcat(construction_chaine, tampon);
3589: free(tampon);
3590:
3591: if (test_cfsf(s_etat_processus, 48) == d_faux)
3592: {
3593: strcat(construction_chaine, ",");
3594: }
3595: else
3596: {
3597: strcat(construction_chaine, ".");
3598: }
3599:
3600: tampon = formateur_reel(s_etat_processus,
3601: &((*((struct_complexe16 *)
3602: valeur_numerique)).partie_imaginaire), 'R');
3603:
3604: if (tampon == NULL)
3605: {
3606: (*s_etat_processus).erreur_systeme =
3607: d_es_allocation_memoire;
3608: return(NULL);
3609: }
3610:
3611: sauvegarde = construction_chaine;
3612:
3613: construction_chaine = (unsigned char *) malloc(
3614: (strlen(sauvegarde) + strlen(tampon) + 2)
3615: * sizeof(unsigned char));
3616:
3617: if (construction_chaine == NULL)
3618: {
3619: (*s_etat_processus).erreur_systeme =
3620: d_es_allocation_memoire;
3621: return(NULL);
3622: }
3623:
3624: strcpy(construction_chaine, sauvegarde);
3625: free(sauvegarde);
3626: strcat(construction_chaine, tampon);
3627: free(tampon);
3628: strcat(construction_chaine, ")");
3629:
3630: chaine = construction_chaine;
3631:
3632: break;
3633: }
3634:
3635: case 'R' :
3636: {
3637: chaine = formateur_reel(s_etat_processus, valeur_numerique, 'R');
3638:
3639: if (chaine == NULL)
3640: {
3641: (*s_etat_processus).erreur_systeme =
3642: d_es_allocation_memoire;
3643: return(NULL);
3644: }
3645:
3646: break;
3647: }
3648:
3649: default :
3650: case 'I' :
3651: {
3652: chaine = formateur_reel(s_etat_processus, valeur_numerique, 'I');
3653:
3654: if (chaine == NULL)
3655: {
3656: (*s_etat_processus).erreur_systeme =
3657: d_es_allocation_memoire;
3658: return(NULL);
3659: }
3660:
3661: break;
3662: }
3663: }
3664:
3665: return(chaine);
3666: }
3667:
3668:
3669: /*
3670: --------------------------------------------------------------------------------
3671: Formateur des réels et entiers
3672: --------------------------------------------------------------------------------
3673: */
3674:
3675: unsigned char *
3676: formateur_reel(struct_processus *s_etat_processus,
3677: void *valeur_numerique, unsigned char type)
3678: {
3679: real8 mantisse;
3680: real8 tampon_reel;
3681:
3682: integer8 tampon_entier;
3683:
3684: logical1 i49;
3685: logical1 i50;
3686:
3687: long correction;
3688: long dernier_chiffre_significatif;
3689: long exposant;
3690: long i;
3691: long j;
3692: long longueur_utile;
3693: long longueur_utile_limite;
3694:
3695: unsigned char *chaine;
3696: unsigned char format[32 + 1];
3697: unsigned char mode[3 + 1];
3698: unsigned char *ptr;
3699: unsigned char tampon[32 + 1];
3700:
3701: chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
3702:
3703: if (chaine == NULL)
3704: {
3705: (*s_etat_processus).erreur_systeme =
3706: d_es_allocation_memoire;
3707: return(NULL);
3708: }
3709:
3710: if (type == 'R')
3711: {
3712: # ifdef FP_INFINITE
3713: int signe;
3714:
3715: if ((signe = isinf((*((real8 *) valeur_numerique)))) != 0)
3716: {
3717: if (signe > 0)
3718: {
3719: strcpy(chaine, "infinity");
3720: }
3721: else
3722: {
3723: strcpy(chaine, "-infinity");
3724: }
3725:
3726: return(chaine);
3727: }
3728: # endif
3729:
3730: if (isnan((*((real8 *) valeur_numerique))))
3731: {
3732: strcpy(chaine, "undef");
3733: return(chaine);
3734: }
3735:
3736: tampon_reel = *((real8 *) valeur_numerique);
3737:
3738: if (tampon_reel > ((real8) 0))
3739: {
3740: exposant = (long) floor(log10(tampon_reel));
3741: }
3742: else if (tampon_reel < ((real8) 0))
3743: {
3744: exposant = (long) floor(log10(-tampon_reel));
3745: }
3746: else
3747: {
3748: exposant = 0;
3749: }
3750:
3751: mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
3752: }
3753: else
3754: {
3755: tampon_entier = *((integer8 *) valeur_numerique);
3756:
3757: if (tampon_entier > ((integer8) 0))
3758: {
3759: exposant = (long) floor(log10((double) tampon_entier));
3760: }
3761: else if (tampon_entier < ((integer8) 0))
3762: {
3763: if (tampon_entier != INT64_MIN)
3764: {
3765: exposant = (long) floor(log10((double) -tampon_entier));
3766: }
3767: else
3768: {
3769: tampon_reel = (real8) tampon_entier;
3770: exposant = (long) floor(log10(-tampon_reel));
3771: }
3772: }
3773: else
3774: {
3775: exposant = 0;
3776: }
3777:
3778: mantisse = ((real8) (*((integer8 *) valeur_numerique))) /
3779: pow(10, (double) exposant);
3780: }
3781:
3782: longueur_utile = 0;
3783: j = 1;
3784:
3785: for(i = 53; i <= 56; i++)
3786: {
3787: longueur_utile += (test_cfsf(s_etat_processus, (unsigned char) i)
3788: == d_vrai) ? j : 0;
3789: j *= 2;
3790: }
3791:
3792: longueur_utile_limite = 15;
3793:
3794: if (longueur_utile > longueur_utile_limite)
3795: {
3796: longueur_utile = longueur_utile_limite;
3797: }
3798:
3799: i49 = test_cfsf(s_etat_processus, 49);
3800: i50 = test_cfsf(s_etat_processus, 50);
3801:
3802: if (i49 == d_faux)
3803: {
3804: if (i50 == d_faux)
3805: {
3806:
3807: /*
3808: --------------------------------------------------------------------------------
3809: Mode standard
3810: --------------------------------------------------------------------------------
3811: */
3812:
3813: strcpy(mode, "STD");
3814: }
3815: else
3816: {
3817:
3818: /*
3819: --------------------------------------------------------------------------------
3820: Mode scientifique
3821: --------------------------------------------------------------------------------
3822: */
3823:
3824: strcpy(mode, "SCI");
3825: }
3826: }
3827: else
3828: {
3829: if (i50 == d_faux)
3830: {
3831:
3832: /*
3833: --------------------------------------------------------------------------------
3834: Mode fixe
3835: --------------------------------------------------------------------------------
3836: */
3837:
3838: strcpy(mode, "FIX");
3839: }
3840: else
3841: {
3842:
3843: /*
3844: --------------------------------------------------------------------------------
3845: Mode ingénieur
3846: --------------------------------------------------------------------------------
3847: */
3848:
3849: strcpy(mode, "ENG");
3850: }
3851: }
3852:
3853: // Test portant sur le nombre de chiffres significatifs dans
3854: // le cas du format STD pour que 1.2E-15 apparaisse en notation
3855: // SCI car il y a une perte de précision dans l'affichage.
3856:
3857: if ((strcmp(mode, "STD") == 0) && (type == 'R'))
3858: {
3859: if (abs(*((real8 *) valeur_numerique)) < 1)
3860: {
3861: dernier_chiffre_significatif = -exposant;
3862: sprintf(tampon, ".%f", mantisse);
3863:
3864: ptr = &(tampon[strlen(tampon) - 1]);
3865:
3866: while((*ptr) != '.')
3867: {
3868: if ((*ptr) != '0')
3869: {
3870: dernier_chiffre_significatif++;
3871: }
3872:
3873: ptr--;
3874: }
3875: }
3876: else
3877: {
3878: dernier_chiffre_significatif = 0;
3879: }
3880: }
3881: else
3882: {
3883: dernier_chiffre_significatif = 0;
3884: }
3885:
3886: if ((strcmp(mode, "SCI") == 0) ||
3887: ((strcmp(mode, "STD") == 0) && ((exposant >
3888: longueur_utile_limite) || (dernier_chiffre_significatif > 15) ||
3889: (exposant < -longueur_utile_limite))) ||
3890: ((strcmp(mode, "FIX") == 0) &&
3891: ((exposant >= longueur_utile_limite) ||
3892: (exposant < -longueur_utile))))
3893: {
3894: chaine[0] = d_code_fin_chaine;
3895: format[0] = d_code_fin_chaine;
3896:
3897: if (strcmp(mode, "STD") == 0)
3898: {
3899: longueur_utile = longueur_utile_limite - 1;
3900: }
3901:
3902: sprintf(format, "%%.%luf", longueur_utile);
3903: sprintf(tampon, format, mantisse);
3904: strcpy(chaine, tampon);
3905:
3906: if (strcmp(mode, "STD") == 0)
3907: {
3908: ptr = &(chaine[strlen(chaine) - 1]);
3909: while(((*ptr) == '0') || ((*ptr) == '.'))
3910: {
3911: (*ptr) = d_code_fin_chaine;
3912: ptr--;
3913: }
3914: }
3915:
3916: strcat(chaine, "E");
3917: sprintf(tampon, "%ld", exposant);
3918: strcat(chaine, tampon);
3919: }
3920: else if (strcmp(mode, "FIX") == 0)
3921: {
3922: chaine[0] = d_code_fin_chaine;
3923: format[0] = d_code_fin_chaine;
3924:
3925: if (longueur_utile + exposant >= longueur_utile_limite)
3926: {
3927: longueur_utile = longueur_utile_limite - (exposant + 1);
3928: }
3929:
3930: sprintf(format, "%%.%luf", longueur_utile);
3931:
3932: sprintf(tampon, format, (mantisse * pow(10, (double) exposant)));
3933: strcpy(chaine, tampon);
3934: }
3935: else if (strcmp(mode, "ENG") == 0)
3936: {
3937: chaine[0] = d_code_fin_chaine;
3938: format[0] = d_code_fin_chaine;
3939:
3940: correction = labs(exposant) % 3;
3941:
3942: if (exposant < 0)
3943: {
3944: if (correction == 0)
3945: {
3946: correction = 3;
3947: }
3948:
3949: correction = 3 - correction;
3950: }
3951:
3952: longueur_utile -= correction;
3953: sprintf(format, "%%.%luf", longueur_utile);
3954:
3955: sprintf(tampon, format, (mantisse * pow(10, (double) correction)));
3956: strcpy(chaine, tampon);
3957: strcat(chaine, "E");
3958: sprintf(tampon, "%ld", (exposant - correction));
3959: strcat(chaine, tampon);
3960: }
3961: else
3962: {
3963: if (type == 'I')
3964: {
3965: chaine[0] = d_code_fin_chaine;
3966: sprintf(tampon, "%lld", *((integer8 *) valeur_numerique));
3967: }
3968: else
3969: {
3970: chaine[0] = d_code_fin_chaine;
3971: format[0] = d_code_fin_chaine;
3972:
3973: if (exposant >= 0)
3974: {
3975: if ((exposant + 1) < longueur_utile_limite)
3976: {
3977: sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
3978: - 1));
3979: }
3980: else
3981: {
3982: strcpy(format, "%.0f.");
3983: }
3984: }
3985: else
3986: {
3987: sprintf(format, "%%.%luf", longueur_utile_limite);
3988: }
3989:
3990: sprintf(tampon, format, *((real8 *) valeur_numerique));
3991:
3992: i = ((long) strlen(tampon)) - 1;
3993: while(tampon[i] == '0')
3994: {
3995: tampon[i] = d_code_fin_chaine;
3996: i--;
3997: }
3998:
3999: if (ds_imposition_separateur_decimal == d_faux)
4000: {
4001: i = ((long) strlen(tampon)) - 1;
4002: if (tampon[i] == '.')
4003: {
4004: tampon[i] = d_code_fin_chaine;
4005: }
4006: }
4007: }
4008:
4009: strcpy(chaine, tampon);
4010: }
4011:
4012: if (test_cfsf(s_etat_processus, 48) == d_vrai)
4013: {
4014: for(i = 0; i < (long) strlen(chaine); i++)
4015: {
4016: if (chaine[i] == '.')
4017: {
4018: chaine[i] = ',';
4019: }
4020: }
4021: }
4022:
4023: return(chaine);
4024: }
4025:
4026: // 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