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