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