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