![[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.10 ! bertrand 3: RPL/2 (R) version 4.0.14
1.1 bertrand 4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl.conv.h"
24:
25:
26: /*
27: ================================================================================
28: Routine de formation des données pour l'affichage
29: ================================================================================
30: Entrées : structure sur l'état du processus et objet à afficher
31: --------------------------------------------------------------------------------
32: Sorties : chaine de caractères
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: unsigned char *
39: formateur(struct_processus *s_etat_processus, long offset_initial,
40: struct_objet *s_objet)
41: {
42: int parentheses_groupe_gauche;
43: int parentheses_groupe_droit;
44:
45: logical1 registre45;
46:
47: logical4 autorisation_parenthese;
48: logical4 presence_signe;
49:
50: struct_liste_chainee *l_atome;
51: struct_liste_chainee *l_element_courant;
52: struct_liste_chainee *l_liste1;
53: struct_liste_chainee *l_liste2;
54:
55: struct_objet *s_sous_objet;
56: struct_objet *s_sous_objet_1;
57: struct_objet *s_sous_objet_2;
58: struct_objet *s_sous_objet_3;
59:
60: unsigned char base[1 + 1];
61: unsigned char *chaine;
62: unsigned char *chaine_fonction;
63: unsigned char *chaine_formatee;
64: unsigned char *chaine_tampon;
65: unsigned char *chaine_sauvegarde;
66: unsigned char *format;
67: unsigned char *format_majuscule;
68: unsigned char *ptre;
69: unsigned char *ptrl;
1.5 bertrand 70: unsigned char *ptr_ecriture;
71: unsigned char *ptr_lecture;
1.1 bertrand 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.3 bertrand 395: if (alsprintf(&chaine, "Socket %016lX",
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.5 bertrand 1755: if ((chaine = malloc((strlen((unsigned char *)
1756: ((*s_objet).objet)) + 1) * sizeof(unsigned char))) == NULL)
1.1 bertrand 1757: {
1758: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1759: return(NULL);
1760: }
1761:
1.5 bertrand 1762: if ((*s_etat_processus).autorisation_conversion_chaine == 'Y')
1763: {
1764: ptr_lecture = (unsigned char *) (*s_objet).objet;
1765: ptr_ecriture = chaine;
1766:
1767: while((*ptr_lecture) != d_code_fin_chaine)
1768: {
1769: (*ptr_ecriture) = (*ptr_lecture);
1770:
1771: // Début de la séquence d'échappement
1772:
1773: if ((*ptr_lecture) == '\\')
1774: {
1775: if ((*(ptr_lecture + 1)) == '"')
1776: {
1777: ptr_lecture++;
1778: (*ptr_ecriture) = '\"';
1779: }
1780: else if ((*(ptr_lecture + 1)) == 'b')
1781: {
1782: ptr_lecture++;
1783: (*ptr_ecriture) = '\b';
1784: }
1785: else if ((*(ptr_lecture + 1)) == 'n')
1786: {
1787: ptr_lecture++;
1788: (*ptr_ecriture) = '\n';
1789: }
1790: else if ((*(ptr_lecture + 1)) == 't')
1791: {
1792: ptr_lecture++;
1793: (*ptr_ecriture) = '\t';
1794: }
1795: else if ((*(ptr_lecture + 1)) == '\\')
1796: {
1797: ptr_lecture++;
1798: }
1799: else
1800: {
1801: if ((*s_etat_processus).langue == 'F')
1802: {
1803: printf("+++Information : Séquence d'échappement "
1804: "inconnue [%d]\n", (int) getpid());
1805: }
1806: else
1807: {
1808: printf("+++Warning : Unknown escape code "
1809: "[%d]\n", (int) getpid());
1810: }
1811: }
1812: }
1813:
1814: ptr_ecriture++;
1815: ptr_lecture++;
1816: }
1817:
1818: (*ptr_ecriture) = d_code_fin_chaine;
1819:
1820: if ((chaine = realloc(chaine, (strlen(chaine) + 1) *
1821: sizeof(unsigned char))) == NULL)
1822: {
1823: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1824: return(NULL);
1825: }
1826: }
1827: else
1828: {
1829: strcpy(chaine, (unsigned char *) ((*s_objet).objet));
1830: }
1.1 bertrand 1831: }
1832: else if ((*s_objet).type == CPL)
1833: {
1834:
1835: /*
1836: --------------------------------------------------------------------------------
1837: Complexe
1838: --------------------------------------------------------------------------------
1839: */
1840:
1841: chaine_formatee = formateur_nombre(s_etat_processus, (void *)
1842: ((struct_complexe16 *) ((*s_objet).objet)), 'C');
1843:
1844: if (chaine_formatee == NULL)
1845: {
1846: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1847: return(NULL);
1848: }
1849:
1850: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
1851: + 1) * sizeof(unsigned char));
1852:
1853: if (chaine == NULL)
1854: {
1855: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1856: return(NULL);
1857: }
1858:
1859: strcpy(chaine, chaine_formatee);
1860: free(chaine_formatee);
1861: }
1862: else if ((*s_objet).type == RPN)
1863: {
1864:
1865: /*
1866: --------------------------------------------------------------------------------
1867: Définition
1868: --------------------------------------------------------------------------------
1869: */
1870:
1871: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
1872: chaine_sauvegarde = chaine;
1873:
1874: while(l_element_courant != NULL)
1875: {
1876: if ((chaine_formatee = formateur(s_etat_processus, 0,
1877: (*l_element_courant).donnee)) == NULL)
1878: {
1879: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1880: return(NULL);
1881: }
1882:
1883: if ((*(*l_element_courant).donnee).type == CHN)
1884: {
1885: chaine_tampon = chaine_formatee;
1886:
1887: if ((chaine_formatee = (unsigned char *) malloc((strlen(
1888: chaine_tampon) + 3) * sizeof(unsigned char))) == NULL)
1889: {
1890: (*s_etat_processus).erreur_systeme =
1891: d_es_allocation_memoire;
1892: return(NULL);
1893: }
1894:
1895: sprintf(chaine_formatee, "\"%s\"", chaine_tampon);
1896: free(chaine_tampon);
1897: }
1898:
1899: l_element_courant = (*l_element_courant).suivant;
1900:
1901: if (chaine != NULL)
1902: {
1903: chaine_sauvegarde = chaine;
1904:
1905: if ((chaine = (unsigned char *) malloc((strlen(
1906: chaine_sauvegarde) + strlen(chaine_formatee) + 2) *
1907: sizeof(unsigned char))) == NULL)
1908: {
1909: (*s_etat_processus).erreur_systeme =
1910: d_es_allocation_memoire;
1911: return(NULL);
1912: }
1913:
1914: strcpy(chaine, chaine_sauvegarde);
1915: free(chaine_sauvegarde);
1916: strcat(chaine, " ");
1917: strcat(chaine, chaine_formatee);
1918: free(chaine_formatee);
1919: }
1920: else
1921: {
1922: chaine = chaine_formatee;
1923: }
1924: }
1925:
1926: chaine_sauvegarde = chaine;
1927: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) *
1928: sizeof(unsigned char));
1929:
1930: if (chaine == NULL)
1931: {
1932: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1933: return(NULL);
1934: }
1935:
1936: chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine;
1937: strcpy(chaine, chaine_sauvegarde);
1938: free(chaine_sauvegarde);
1939: }
1940: else if ((*s_objet).type == INT)
1941: {
1942:
1943: /*
1944: --------------------------------------------------------------------------------
1945: Entier
1946: --------------------------------------------------------------------------------
1947: */
1948:
1949: chaine_formatee = formateur_nombre(s_etat_processus, (void *)
1950: ((integer8 *) ((*s_objet).objet)), 'I');
1951:
1952: if (chaine_formatee == NULL)
1953: {
1954: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1955: return(NULL);
1956: }
1957:
1958: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1)
1959: * sizeof(unsigned char));
1960:
1961: if (chaine == NULL)
1962: {
1963: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1964: return(NULL);
1965: }
1966:
1967: strcpy(chaine, chaine_formatee);
1968: free(chaine_formatee);
1969: }
1970: else if ((*s_objet).type == FCT)
1971: {
1972:
1973: /*
1974: --------------------------------------------------------------------------------
1975: Fonction
1976: --------------------------------------------------------------------------------
1977: */
1978:
1979: chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
1980: ((*s_objet).objet))).nom_fonction) + 1) *
1981: sizeof(unsigned char));
1982:
1983: if (chaine == NULL)
1984: {
1985: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1986: return(NULL);
1987: }
1988:
1989: strcpy(chaine, (unsigned char *) (*((struct_fonction *)
1990: ((*s_objet).objet))).nom_fonction);
1991: }
1992: else if ((*s_objet).type == TBL)
1993: {
1994:
1995: /*
1996: --------------------------------------------------------------------------------
1997: Tableau
1998: --------------------------------------------------------------------------------
1999: */
2000:
2001: chaine = (unsigned char *) malloc(4 * sizeof(unsigned char));
2002:
2003: if (chaine == NULL)
2004: {
2005: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2006: return(NULL);
2007: }
2008:
2009: strcpy(chaine, "<[ ");
2010: offset = strlen(chaine) + offset_initial;
2011:
2012: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
2013: .nombre_elements; i++)
2014: {
2015: chaine_sauvegarde = chaine;
2016: chaine_formatee = formateur(s_etat_processus, offset,
2017: (*((struct_tableau *) (*s_objet).objet)).elements[i]);
2018:
2019: if (chaine_formatee == NULL)
2020: {
2021: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2022: return(NULL);
2023: }
2024:
2025: if ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
2026: .type == CHN)
2027: {
2028: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
2029: + strlen(chaine_sauvegarde) + 3)
2030: * sizeof(unsigned char));
2031:
2032: if (chaine == NULL)
2033: {
2034: (*s_etat_processus).erreur_systeme =
2035: d_es_allocation_memoire;
2036: return(NULL);
2037: }
2038:
2039: strcpy(chaine, chaine_sauvegarde);
2040: free(chaine_sauvegarde);
2041: strcat(chaine, "\"");
2042: strcat(chaine, chaine_formatee);
2043: free(chaine_formatee);
2044: strcat(chaine, "\"");
2045: }
2046: else if ((*(*((struct_tableau *) (*s_objet).objet))
2047: .elements[i]).type == CHN)
2048: {
2049: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
2050: + strlen(chaine_sauvegarde) + 1)
2051: * sizeof(unsigned char));
2052:
2053: if (chaine == NULL)
2054: {
2055: (*s_etat_processus).erreur_systeme =
2056: d_es_allocation_memoire;
2057: return(NULL);
2058: }
2059:
2060: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
2061: free(chaine_sauvegarde);
2062: free(chaine_formatee);
2063: }
2064: else
2065: {
2066: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
2067: + strlen(chaine_sauvegarde) + 1)
2068: * sizeof(unsigned char));
2069:
2070: if (chaine == NULL)
2071: {
2072: (*s_etat_processus).erreur_systeme =
2073: d_es_allocation_memoire;
2074: return(NULL);
2075: }
2076:
2077: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
2078: free(chaine_sauvegarde);
2079: free(chaine_formatee);
2080: }
2081:
2082: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2083: {
2084: chaine_sauvegarde = chaine;
2085:
2086: chaine = (unsigned char *) malloc(
2087: (strlen(chaine_sauvegarde) + 2)
2088: * sizeof(unsigned char));
2089:
2090: if (chaine == NULL)
2091: {
2092: (*s_etat_processus).erreur_systeme =
2093: d_es_allocation_memoire;
2094: return(NULL);
2095: }
2096:
2097: strcpy(chaine, chaine_sauvegarde);
2098: free(chaine_sauvegarde);
2099: strcat(chaine, "\n");
2100:
2101: if ((*((struct_tableau *) (*s_objet).objet))
2102: .nombre_elements != (i + 1))
2103: {
2104: chaine_sauvegarde = chaine;
2105:
2106: chaine = (unsigned char *) malloc(
2107: (strlen(chaine_sauvegarde) + 1 + offset)
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: ptre = &(chaine[strlen(chaine)]);
2120:
2121: for(k = 0; k < offset; k++, *(ptre++) = ' ');
2122:
2123: (*ptre) = d_code_fin_chaine;
2124: }
2125: }
2126: else
2127: {
2128: if ((*((struct_tableau *) (*s_objet).objet))
2129: .nombre_elements != (i + 1))
2130: {
2131: chaine_sauvegarde = chaine;
2132:
2133: chaine = (unsigned char *) malloc(
2134: (strlen(chaine_sauvegarde) + 2)
2135: * sizeof(unsigned char));
2136:
2137: if (chaine == NULL)
2138: {
2139: (*s_etat_processus).erreur_systeme =
2140: d_es_allocation_memoire;
2141: return(NULL);
2142: }
2143:
2144: strcpy(chaine, chaine_sauvegarde);
2145: free(chaine_sauvegarde);
2146: strcat(chaine, " ");
2147: }
2148: }
2149: }
2150:
2151: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2152: {
2153: if (chaine[strlen(chaine) - 1] == '\n')
2154: {
2155: chaine[strlen(chaine) - 1] = d_code_fin_chaine;
2156: }
2157: }
2158:
2159: if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements != 0)
2160: {
2161: chaine_sauvegarde = chaine;
2162: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4)
2163: * sizeof(unsigned char));
2164:
2165: if (chaine == NULL)
2166: {
2167: (*s_etat_processus).erreur_systeme =
2168: d_es_allocation_memoire;
2169: return(NULL);
2170: }
2171:
2172: strcpy(chaine, chaine_sauvegarde);
2173: free(chaine_sauvegarde);
2174: strcat(chaine, " ]>");
2175: }
2176: else
2177: {
2178: chaine_sauvegarde = chaine;
2179: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3)
2180: * sizeof(unsigned char));
2181:
2182: if (chaine == NULL)
2183: {
2184: (*s_etat_processus).erreur_systeme =
2185: d_es_allocation_memoire;
2186: return(NULL);
2187: }
2188:
2189: strcpy(chaine, chaine_sauvegarde);
2190: free(chaine_sauvegarde);
2191: strcat(chaine, "]>");
2192: }
2193: }
2194: else if ((*s_objet).type == LST)
2195: {
2196:
2197: /*
2198: --------------------------------------------------------------------------------
2199: Liste
2200: --------------------------------------------------------------------------------
2201: */
2202:
2203: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2204:
2205: if (chaine == NULL)
2206: {
2207: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2208: return(NULL);
2209: }
2210:
2211: strcpy(chaine, "{ ");
2212:
2213: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
2214: nombre_elements = 0;
2215: offset = strlen(chaine) + offset_initial;
2216:
2217: while(l_element_courant != NULL)
2218: {
2219: chaine_sauvegarde = chaine;
2220: chaine_formatee = formateur(s_etat_processus, offset,
2221: (*l_element_courant).donnee);
2222:
2223: if (chaine_formatee == NULL)
2224: {
2225: (*s_etat_processus).erreur_systeme =
2226: d_es_allocation_memoire;
2227: return(NULL);
2228: }
2229:
2230: if ((*(*l_element_courant).donnee).type == CHN)
2231: {
2232: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
2233: + strlen(chaine_sauvegarde) + 3)
2234: * sizeof(unsigned char));
2235:
2236: if (chaine == NULL)
2237: {
2238: (*s_etat_processus).erreur_systeme =
2239: d_es_allocation_memoire;
2240: return(NULL);
2241: }
2242:
2243: strcpy(chaine, chaine_sauvegarde);
2244: free(chaine_sauvegarde);
2245: strcat(chaine, "\"");
2246: strcat(chaine, chaine_formatee);
2247: free(chaine_formatee);
2248: strcat(chaine, "\"");
2249: }
2250: else if ((*(*l_element_courant).donnee).type == NOM)
2251: {
2252: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
2253: + strlen(chaine_sauvegarde) + 1)
2254: * sizeof(unsigned char));
2255:
2256: if (chaine == NULL)
2257: {
2258: (*s_etat_processus).erreur_systeme =
2259: d_es_allocation_memoire;
2260: return(NULL);
2261: }
2262:
2263: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
2264: free(chaine_sauvegarde);
2265: free(chaine_formatee);
2266: }
2267: else
2268: {
2269: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
2270: + strlen(chaine_sauvegarde) + 1)
2271: * sizeof(unsigned char));
2272:
2273: if (chaine == NULL)
2274: {
2275: (*s_etat_processus).erreur_systeme =
2276: d_es_allocation_memoire;
2277: return(NULL);
2278: }
2279:
2280: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
2281: free(chaine_sauvegarde);
2282: free(chaine_formatee);
2283: }
2284:
2285: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2286: {
2287: chaine_sauvegarde = chaine;
2288:
2289: chaine = (unsigned char *) malloc(
2290: (strlen(chaine_sauvegarde) + 2)
2291: * sizeof(unsigned char));
2292:
2293: if (chaine == NULL)
2294: {
2295: (*s_etat_processus).erreur_systeme =
2296: d_es_allocation_memoire;
2297: return(NULL);
2298: }
2299:
2300: strcpy(chaine, chaine_sauvegarde);
2301: free(chaine_sauvegarde);
2302: strcat(chaine, "\n");
2303:
2304: if ((*l_element_courant).suivant != NULL)
2305: {
2306: chaine_sauvegarde = chaine;
2307:
2308: chaine = (unsigned char *) malloc(
2309: (strlen(chaine_sauvegarde) + 1 + offset)
2310: * sizeof(unsigned char));
2311:
2312: if (chaine == NULL)
2313: {
2314: (*s_etat_processus).erreur_systeme =
2315: d_es_allocation_memoire;
2316: return(NULL);
2317: }
2318:
2319: strcpy(chaine, chaine_sauvegarde);
2320: free(chaine_sauvegarde);
2321: ptre = &(chaine[strlen(chaine)]);
2322:
2323: for(k = 0; k < offset; k++, *(ptre++) = ' ');
2324:
2325: (*ptre) = d_code_fin_chaine;
2326: }
2327: }
2328: else
2329: {
2330: if ((*l_element_courant).suivant != NULL)
2331: {
2332: chaine_sauvegarde = chaine;
2333:
2334: chaine = (unsigned char *) malloc(
2335: (strlen(chaine_sauvegarde) + 2)
2336: * sizeof(unsigned char));
2337:
2338: if (chaine == NULL)
2339: {
2340: (*s_etat_processus).erreur_systeme =
2341: d_es_allocation_memoire;
2342: return(NULL);
2343: }
2344:
2345: strcpy(chaine, chaine_sauvegarde);
2346: free(chaine_sauvegarde);
2347: strcat(chaine, " ");
2348: }
2349: }
2350:
2351: nombre_elements++;
2352: l_element_courant = (*l_element_courant).suivant;
2353: }
2354:
2355: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2356: {
2357: if (chaine[strlen(chaine) - 1] == '\n')
2358: {
2359: chaine[strlen(chaine) - 1] = d_code_fin_chaine;
2360: }
2361: }
2362:
2363: if (nombre_elements != 0)
2364: {
2365: chaine_sauvegarde = chaine;
2366: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3)
2367: * sizeof(unsigned char));
2368:
2369: if (chaine == NULL)
2370: {
2371: (*s_etat_processus).erreur_systeme =
2372: d_es_allocation_memoire;
2373: return(NULL);
2374: }
2375:
2376: strcpy(chaine, chaine_sauvegarde);
2377: free(chaine_sauvegarde);
2378: strcat(chaine, " }");
2379: }
2380: else
2381: {
2382: chaine_sauvegarde = chaine;
2383: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 2)
2384: * sizeof(unsigned char));
2385:
2386: if (chaine == NULL)
2387: {
2388: (*s_etat_processus).erreur_systeme =
2389: d_es_allocation_memoire;
2390: return(NULL);
2391: }
2392:
2393: strcpy(chaine, chaine_sauvegarde);
2394: free(chaine_sauvegarde);
2395: strcat(chaine, "}");
2396: }
2397: }
2398: else if ((*s_objet).type == MCX)
2399: {
2400:
2401: /*
2402: --------------------------------------------------------------------------------
2403: Matrice complexe
2404: --------------------------------------------------------------------------------
2405: */
2406:
2407: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
2408: .nombre_lignes;
2409: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
2410: .nombre_colonnes;
2411:
2412: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2413:
2414: if (chaine != NULL)
2415: {
2416: strcpy(chaine, "[[");
2417: offset = strlen(chaine) + offset_initial - 1;
2418:
2419: if ((longueurs_maximales = malloc(sizeof(unsigned long) * 2 *
2420: nombre_colonnes)) == NULL)
2421: {
2422: (*s_etat_processus).erreur_systeme =
2423: d_es_allocation_memoire;
2424: return(NULL);
2425: }
2426:
2427: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2428: {
2429: for(j = 0; j < (2 * nombre_colonnes); j++)
2430: {
2431: longueurs_maximales[j] = 0;
2432: }
2433:
2434: for(i = 0; i < nombre_lignes; i++)
2435: {
2436: for(j = 0; j < nombre_colonnes; j++)
2437: {
2438: chaine_formatee = formateur_nombre(s_etat_processus,
2439: (void *) &(((struct_complexe16 **)
2440: ((*((struct_matrice *)
2441: ((*s_objet).objet))).tableau))[i][j]), 'C');
2442:
2443: if (chaine_formatee == NULL)
2444: {
2445: (*s_etat_processus).erreur_systeme =
2446: d_es_allocation_memoire;
2447: return(NULL);
2448: }
2449:
2450: longueur_courante = strlen(chaine_formatee);
2451: longueur_decimale_courante = 0;
2452:
2453: if ((ptrl = index(chaine_formatee,
2454: (test_cfsf(s_etat_processus, 48) == d_vrai)
2455: ? '.' : ',')) != NULL)
2456: {
2457: longueur_decimale_courante = longueur_courante
2458: - (ptrl - chaine_formatee);
2459: longueur_courante = ptrl - chaine_formatee;
2460: }
2461:
2462: free(chaine_formatee);
2463:
2464: if (longueurs_maximales[2 * j] < longueur_courante)
2465: {
2466: longueurs_maximales[2 * j] = longueur_courante;
2467: }
2468:
2469: if (longueurs_maximales[(2 * j) + 1] <
2470: longueur_decimale_courante)
2471: {
2472: longueurs_maximales[(2 * j) + 1] =
2473: longueur_decimale_courante;
2474: }
2475: }
2476: }
2477: }
2478:
2479: for(i = 0; i < nombre_lignes; i++)
2480: {
2481: for(j = 0; j < nombre_colonnes; j++)
2482: {
2483: chaine_formatee = formateur_nombre(s_etat_processus,
2484: (void *) &(((struct_complexe16 **)
2485: ((*((struct_matrice *)
2486: ((*s_objet).objet))).tableau))[i][j]), 'C');
2487:
2488: if (chaine_formatee == NULL)
2489: {
2490: (*s_etat_processus).erreur_systeme =
2491: d_es_allocation_memoire;
2492: return(NULL);
2493: }
2494:
2495: longueur_courante = strlen(chaine_formatee);
2496: longueur_decimale_courante = 0;
2497:
2498: if ((ptrl = index(chaine_formatee,
2499: (test_cfsf(s_etat_processus, 48) == d_vrai)
2500: ? '.' : ',')) != NULL)
2501: {
2502: longueur_decimale_courante = longueur_courante
2503: - (ptrl - chaine_formatee);
2504: longueur_courante = ptrl - chaine_formatee;
2505: }
2506:
2507: chaine_sauvegarde = chaine;
2508:
2509: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2510: {
2511:
2512: chaine = (unsigned char *) malloc(
2513: (strlen(chaine_sauvegarde) +
2514: longueur_courante + longueur_decimale_courante +
2515: longueurs_maximales[2 * j] +
2516: longueurs_maximales[(2 * j) + 1] + 2)
2517: * sizeof(unsigned char));
2518:
2519: if (chaine == NULL)
2520: {
2521: (*s_etat_processus).erreur_systeme =
2522: d_es_allocation_memoire;
2523: return(NULL);
2524: }
2525:
2526: strcpy(chaine, chaine_sauvegarde);
2527: free(chaine_sauvegarde);
2528: strcat(chaine, " ");
2529:
2530: ptre = &(chaine[strlen(chaine)]);
2531:
2532: for (k = 0; k < (longueurs_maximales[2 * j]
2533: - longueur_courante); k++, *(ptre++) = ' ');
2534:
2535: (*ptre) = d_code_fin_chaine;
2536: strcat(chaine, chaine_formatee);
2537: ptre = &(chaine[strlen(chaine)]);
2538:
2539: for(k = 0; k < (longueurs_maximales[(2 * j) + 1]
2540: - longueur_decimale_courante);
2541: k++, *(ptre++) = ' ');
2542:
2543: (*ptre) = d_code_fin_chaine;
2544: }
2545: else
2546: {
2547: chaine = (unsigned char *) malloc(
2548: (strlen(chaine_sauvegarde) +
2549: longueur_courante + longueur_decimale_courante
2550: + 2) * sizeof(unsigned char));
2551:
2552: if (chaine == NULL)
2553: {
2554: (*s_etat_processus).erreur_systeme =
2555: d_es_allocation_memoire;
2556: return(NULL);
2557: }
2558:
2559: strcpy(chaine, chaine_sauvegarde);
2560: free(chaine_sauvegarde);
2561: strcat(chaine, " ");
2562: strcat(chaine, chaine_formatee);
2563: }
2564:
2565: free(chaine_formatee);
2566: }
2567:
2568: chaine_sauvegarde = chaine;
2569:
2570: if (i != (nombre_lignes - 1))
2571: {
2572: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2573: {
2574: chaine = (unsigned char *) malloc(
2575: (strlen(chaine_sauvegarde) + 5 + offset)
2576: * sizeof(unsigned char));
2577:
2578: if (chaine == NULL)
2579: {
2580: (*s_etat_processus).erreur_systeme =
2581: d_es_allocation_memoire;
2582: return(NULL);
2583: }
2584:
2585: strcpy(chaine, chaine_sauvegarde);
2586: free(chaine_sauvegarde);
2587: strcat(chaine, " ]\n");
2588: ptre = &(chaine[strlen(chaine)]);
2589:
2590: for(k = 0; k < offset; k++, *(ptre++) = ' ');
2591:
2592: (*ptre) = d_code_fin_chaine;
2593: strcat(chaine, "[");
2594: }
2595: else
2596: {
2597: chaine = (unsigned char *) malloc(
2598: (strlen(chaine_sauvegarde) + 4)
2599: * sizeof(unsigned char));
2600:
2601: if (chaine == NULL)
2602: {
2603: (*s_etat_processus).erreur_systeme =
2604: d_es_allocation_memoire;
2605: return(NULL);
2606: }
2607:
2608: strcpy(chaine, chaine_sauvegarde);
2609: free(chaine_sauvegarde);
2610: strcat(chaine, " ][");
2611: }
2612: }
2613: }
2614:
2615: free(longueurs_maximales);
2616:
2617: chaine_sauvegarde = chaine;
2618: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2619: + 4) * sizeof(unsigned char));
2620:
2621: if (chaine == NULL)
2622: {
2623: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2624: return(NULL);
2625: }
2626:
2627: strcpy(chaine, chaine_sauvegarde);
2628: free(chaine_sauvegarde);
2629: strcat(chaine, " ]]");
2630: }
2631: }
2632: else if ((*s_objet).type == MIN)
2633: {
2634:
2635: /*
2636: --------------------------------------------------------------------------------
2637: Matrice entière
2638: --------------------------------------------------------------------------------
2639: */
2640:
2641: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
2642: .nombre_lignes;
2643: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
2644: .nombre_colonnes;
2645:
2646: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2647:
2648: if (chaine != NULL)
2649: {
2650: strcpy(chaine, "[[");
2651: offset = strlen(chaine) + offset_initial - 1;
2652:
2653: if ((longueurs_maximales = malloc(sizeof(unsigned long) *
2654: nombre_colonnes)) == NULL)
2655: {
2656: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2657: return(NULL);
2658: }
2659:
2660: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2661: {
2662: for(j = 0; j < nombre_colonnes; j++)
2663: {
2664: longueurs_maximales[j] = 0;
2665: }
2666:
2667: for(i = 0; i < nombre_lignes; i++)
2668: {
2669: for(j = 0; j < nombre_colonnes; j++)
2670: {
2671: chaine_formatee = formateur_nombre(s_etat_processus,
2672: (void *) &(((integer8 **) ((*((struct_matrice *)
2673: ((*s_objet).objet))).tableau))[i][j]), 'I');
2674:
2675: if (chaine_formatee == NULL)
2676: {
2677: (*s_etat_processus).erreur_systeme =
2678: d_es_allocation_memoire;
2679: return(NULL);
2680: }
2681:
2682: longueur_courante = strlen(chaine_formatee);
2683: free(chaine_formatee);
2684:
2685: if (longueurs_maximales[j] < longueur_courante)
2686: {
2687: longueurs_maximales[j] = longueur_courante;
2688: }
2689: }
2690: }
2691: }
2692:
2693: for(i = 0; i < nombre_lignes; i++)
2694: {
2695: for(j = 0; j < nombre_colonnes; j++)
2696: {
2697: chaine_formatee = formateur_nombre(s_etat_processus,
2698: (void *) &(((integer8 **) ((*((struct_matrice *)
2699: ((*s_objet).objet))).tableau))[i][j]), 'I');
2700:
2701: if (chaine_formatee == NULL)
2702: {
2703: (*s_etat_processus).erreur_systeme =
2704: d_es_allocation_memoire;
2705: return(NULL);
2706: }
2707:
2708: longueur_courante = strlen(chaine_formatee);
2709: chaine_sauvegarde = chaine;
2710:
2711: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2712: {
2713: chaine = (unsigned char *) malloc(
2714: (strlen(chaine_sauvegarde) + longueur_courante
2715: + longueurs_maximales[j] + 2)
2716: * sizeof(unsigned char));
2717:
2718: if (chaine == NULL)
2719: {
2720: (*s_etat_processus).erreur_systeme =
2721: d_es_allocation_memoire;
2722: return(NULL);
2723: }
2724:
2725: strcpy(chaine, chaine_sauvegarde);
2726: free(chaine_sauvegarde);
2727: strcat(chaine, " ");
2728:
2729: ptre = &(chaine[strlen(chaine)]);
2730:
2731: for(k = 0; k < (longueurs_maximales[j]
2732: - longueur_courante); k++, *(ptre++) = ' ');
2733:
2734: (*ptre) = d_code_fin_chaine;
2735: }
2736: else
2737: {
2738: chaine = (unsigned char *) malloc(
2739: (strlen(chaine_sauvegarde) + longueur_courante
2740: + 2) * sizeof(unsigned char));
2741:
2742: if (chaine == NULL)
2743: {
2744: (*s_etat_processus).erreur_systeme =
2745: d_es_allocation_memoire;
2746: return(NULL);
2747: }
2748:
2749: strcpy(chaine, chaine_sauvegarde);
2750: free(chaine_sauvegarde);
2751: strcat(chaine, " ");
2752: }
2753:
2754: strcat(chaine, chaine_formatee);
2755: free(chaine_formatee);
2756: }
2757:
2758: chaine_sauvegarde = chaine;
2759:
2760: if (i != (nombre_lignes - 1))
2761: {
2762: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2763: {
2764: chaine = (unsigned char *) malloc(
2765: (strlen(chaine_sauvegarde) + 5 + offset)
2766: * sizeof(unsigned char));
2767:
2768: if (chaine == NULL)
2769: {
2770: (*s_etat_processus).erreur_systeme =
2771: d_es_allocation_memoire;
2772: return(NULL);
2773: }
2774:
2775: strcpy(chaine, chaine_sauvegarde);
2776: free(chaine_sauvegarde);
2777: strcat(chaine, " ]\n");
2778: ptre = &(chaine[strlen(chaine)]);
2779:
2780: for(k = 0; k < offset; k++, *(ptre++) = ' ');
2781:
2782: (*ptre) = d_code_fin_chaine;
2783: strcat(chaine, "[");
2784: }
2785: else
2786: {
2787: chaine = (unsigned char *) malloc(
2788: (strlen(chaine_sauvegarde) + 4)
2789: * sizeof(unsigned char));
2790:
2791: if (chaine == NULL)
2792: {
2793: (*s_etat_processus).erreur_systeme =
2794: d_es_allocation_memoire;
2795: return(NULL);
2796: }
2797:
2798: strcpy(chaine, chaine_sauvegarde);
2799: free(chaine_sauvegarde);
2800: strcat(chaine, " ][");
2801: }
2802: }
2803: }
2804:
2805: free(longueurs_maximales);
2806:
2807: chaine_sauvegarde = chaine;
2808: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
2809: + 4) * sizeof(unsigned char));
2810:
2811: if (chaine == NULL)
2812: {
2813: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2814: return(NULL);
2815: }
2816:
2817: strcpy(chaine, chaine_sauvegarde);
2818: free(chaine_sauvegarde);
2819: strcat(chaine, " ]]");
2820: }
2821: }
2822: else if ((*s_objet).type == MRL)
2823: {
2824:
2825: /*
2826: --------------------------------------------------------------------------------
2827: Matrice réelle
2828: --------------------------------------------------------------------------------
2829: */
2830:
2831: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
2832: .nombre_lignes;
2833: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
2834: .nombre_colonnes;
2835:
2836: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
2837:
2838: if (chaine != NULL)
2839: {
2840: strcpy(chaine, "[[");
2841: offset = strlen(chaine) + offset_initial - 1;
2842:
2843: if ((longueurs_maximales = malloc(sizeof(unsigned long) * 2 *
2844: nombre_colonnes)) == NULL)
2845: {
2846: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2847: return(NULL);
2848: }
2849:
2850: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2851: {
2852: for(j = 0; j < (2 * nombre_colonnes); j++)
2853: {
2854: longueurs_maximales[j] = 0;
2855: }
2856:
2857: for(i = 0; i < nombre_lignes; i++)
2858: {
2859: for(j = 0; j < nombre_colonnes; j++)
2860: {
2861: chaine_formatee = formateur_nombre(s_etat_processus,
2862: (void *) &(((real8 **) ((*((struct_matrice *)
2863: ((*s_objet).objet))).tableau))[i][j]), 'R');
2864:
2865: if (chaine_formatee == NULL)
2866: {
2867: (*s_etat_processus).erreur_systeme =
2868: d_es_allocation_memoire;
2869: return(NULL);
2870: }
2871:
2872: longueur_courante = strlen(chaine_formatee);
2873: longueur_decimale_courante = 0;
2874:
2875: if ((ptrl = index(chaine_formatee,
2876: (test_cfsf(s_etat_processus, 48) == d_vrai)
2877: ? ',' : '.')) != NULL)
2878: {
2879: longueur_decimale_courante = longueur_courante
2880: - (ptrl - chaine_formatee);
2881: longueur_courante = ptrl - chaine_formatee;
2882: }
2883:
2884: free(chaine_formatee);
2885:
2886: if (longueurs_maximales[2 * j] < longueur_courante)
2887: {
2888: longueurs_maximales[2 * j] = longueur_courante;
2889: }
2890:
2891: if (longueurs_maximales[(2 * j) + 1] <
2892: longueur_decimale_courante)
2893: {
2894: longueurs_maximales[(2 * j) + 1] =
2895: longueur_decimale_courante;
2896: }
2897: }
2898: }
2899: }
2900:
2901: for(i = 0; i < nombre_lignes; i++)
2902: {
2903: for(j = 0; j < nombre_colonnes; j++)
2904: {
2905: chaine_formatee = formateur_nombre(s_etat_processus,
2906: (void *) &(((real8 **) ((*((struct_matrice *)
2907: ((*s_objet).objet))).tableau))[i][j]), 'R');
2908:
2909: if (chaine_formatee == NULL)
2910: {
2911: (*s_etat_processus).erreur_systeme =
2912: d_es_allocation_memoire;
2913: return(NULL);
2914: }
2915:
2916: longueur_courante = strlen(chaine_formatee);
2917: longueur_decimale_courante = 0;
2918:
2919: if ((ptrl = index(chaine_formatee,
2920: (test_cfsf(s_etat_processus, 48) == d_vrai)
2921: ? ',' : '.')) != NULL)
2922: {
2923: longueur_decimale_courante = longueur_courante
2924: - (ptrl - chaine_formatee);
2925: longueur_courante = ptrl - chaine_formatee;
2926: }
2927:
2928: chaine_sauvegarde = chaine;
2929:
2930: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2931: {
2932: chaine = (unsigned char *) malloc(
2933: (strlen(chaine_sauvegarde) +
2934: longueur_courante + longueur_decimale_courante +
2935: longueurs_maximales[2 * j] +
2936: longueurs_maximales[(2 * j) + 1] + 2)
2937: * sizeof(unsigned char));
2938:
2939: if (chaine == NULL)
2940: {
2941: (*s_etat_processus).erreur_systeme =
2942: d_es_allocation_memoire;
2943: return(NULL);
2944: }
2945:
2946: strcpy(chaine, chaine_sauvegarde);
2947: free(chaine_sauvegarde);
2948: strcat(chaine, " ");
2949:
2950: ptre = &(chaine[strlen(chaine)]);
2951:
2952: for(k = 0; k < (longueurs_maximales[2 * j]
2953: - longueur_courante); k++, *(ptre++) = ' ');
2954:
2955: (*ptre) = d_code_fin_chaine;
2956: strcat(chaine, chaine_formatee);
2957: ptre = &(chaine[strlen(chaine)]);
2958:
2959: for(k = 0; k < (longueurs_maximales[(2 * j) + 1]
2960: - longueur_decimale_courante);
2961: k++, *(ptre++) = ' ');
2962:
2963: (*ptre) = d_code_fin_chaine;
2964: }
2965: else
2966: {
2967: chaine = (unsigned char *) malloc(
2968: (strlen(chaine_sauvegarde) +
2969: longueur_courante + longueur_decimale_courante
2970: + 2) * sizeof(unsigned char));
2971:
2972: if (chaine == NULL)
2973: {
2974: (*s_etat_processus).erreur_systeme =
2975: d_es_allocation_memoire;
2976: return(NULL);
2977: }
2978:
2979: strcpy(chaine, chaine_sauvegarde);
2980: free(chaine_sauvegarde);
2981: strcat(chaine, " ");
2982: strcat(chaine, chaine_formatee);
2983: }
2984:
2985: free(chaine_formatee);
2986: }
2987:
2988: chaine_sauvegarde = chaine;
2989:
2990: if (i != (nombre_lignes - 1))
2991: {
2992: if (test_cfsf(s_etat_processus, 45) == d_vrai)
2993: {
2994: chaine = (unsigned char *) malloc(
2995: (strlen(chaine_sauvegarde) + 5 + offset)
2996: * sizeof(unsigned char));
2997:
2998: if (chaine == NULL)
2999: {
3000: (*s_etat_processus).erreur_systeme =
3001: d_es_allocation_memoire;
3002: return(NULL);
3003: }
3004:
3005: strcpy(chaine, chaine_sauvegarde);
3006: free(chaine_sauvegarde);
3007: strcat(chaine, " ]\n");
3008: ptre = &(chaine[strlen(chaine)]);
3009:
3010: for(k = 0; k < offset; k++, *(ptre++) = ' ');
3011:
3012: (*ptre) = d_code_fin_chaine;
3013: strcat(chaine, "[");
3014: }
3015: else
3016: {
3017: chaine = (unsigned char *) malloc(
3018: (strlen(chaine_sauvegarde) + 4)
3019: * sizeof(unsigned char));
3020:
3021: if (chaine == NULL)
3022: {
3023: (*s_etat_processus).erreur_systeme =
3024: d_es_allocation_memoire;
3025: return(NULL);
3026: }
3027:
3028: strcpy(chaine, chaine_sauvegarde);
3029: free(chaine_sauvegarde);
3030: strcat(chaine, " ][");
3031: }
3032: }
3033: }
3034:
3035: free(longueurs_maximales);
3036:
3037: chaine_sauvegarde = chaine;
3038: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
3039: + 4) * sizeof(unsigned char));
3040:
3041: if (chaine == NULL)
3042: {
3043: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3044: return(NULL);
3045: }
3046:
3047: strcpy(chaine, chaine_sauvegarde);
3048: free(chaine_sauvegarde);
3049: strcat(chaine, " ]]");
3050: }
3051: }
3052: else if ((*s_objet).type == MTX)
3053: {
1.3 bertrand 3054: if (alsprintf(&chaine, "Mutex $ %016lX", (unsigned long)
3055: &((*((struct_mutex *) (*s_objet).objet)).mutex)) < 0)
1.1 bertrand 3056: {
3057: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3058: return(NULL);
3059: }
3060: }
3061: else if ((*s_objet).type == NOM)
3062: {
3063:
3064: /*
3065: --------------------------------------------------------------------------------
3066: Nom
3067: --------------------------------------------------------------------------------
3068: */
3069:
3070: if ((*((struct_nom *) (*s_objet).objet)).symbole == d_vrai)
3071: {
3072: chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
3073: (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
3074:
3075: if (chaine == NULL)
3076: {
3077: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3078: return(NULL);
3079: }
3080:
3081: sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom);
3082: }
3083: else
3084: {
3085: chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
3086: (*s_objet).objet)).nom) + 1) * sizeof(unsigned char));
3087:
3088: if (chaine == NULL)
3089: {
3090: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3091: return(NULL);
3092: }
3093:
3094: sprintf(chaine, "%s", (*((struct_nom *) (*s_objet).objet)).nom);
3095: }
3096: }
3097: else if ((*s_objet).type == REL)
3098: {
3099:
3100: /*
3101: --------------------------------------------------------------------------------
3102: Réel
3103: --------------------------------------------------------------------------------
3104: */
3105:
3106: chaine_formatee = formateur_nombre(s_etat_processus, (void *)
3107: ((real8 *) ((*s_objet).objet)), 'R');
3108:
3109: if (chaine_formatee == NULL)
3110: {
3111: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3112: return(NULL);
3113: }
3114:
3115: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1)
3116: * sizeof(unsigned char));
3117:
3118: if (chaine == NULL)
3119: {
3120: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3121: return(NULL);
3122: }
3123:
3124: strcpy(chaine, chaine_formatee);
3125: free(chaine_formatee);
3126: }
3127: else if ((*s_objet).type == VCX)
3128: {
3129:
3130: /*
3131: --------------------------------------------------------------------------------
3132: Vecteur complexe
3133: --------------------------------------------------------------------------------
3134: */
3135:
3136: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
3137: .taille;
3138:
3139: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
3140:
3141: if (chaine != NULL)
3142: {
3143: strcpy(chaine, "[");
3144:
3145: for(i = 0; i < nombre_colonnes; i++)
3146: {
3147: chaine_formatee = formateur_nombre(s_etat_processus, (void *)
3148: &(((struct_complexe16 *) ((*((struct_vecteur *)
3149: ((*s_objet).objet))).tableau))[i]), 'C');
3150:
3151: if (chaine_formatee == NULL)
3152: {
3153: (*s_etat_processus).erreur_systeme =
3154: d_es_allocation_memoire;
3155: return(NULL);
3156: }
3157:
3158: chaine_sauvegarde = chaine;
3159: chaine = (unsigned char *) malloc(
3160: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
3161: + 2) * sizeof(unsigned char));
3162:
3163: if (chaine == NULL)
3164: {
3165: (*s_etat_processus).erreur_systeme =
3166: d_es_allocation_memoire;
3167: return(NULL);
3168: }
3169:
3170: strcpy(chaine, chaine_sauvegarde);
3171: free(chaine_sauvegarde);
3172: strcat(chaine, " ");
3173: strcat(chaine, chaine_formatee);
3174: free(chaine_formatee);
3175: }
3176:
3177: chaine_sauvegarde = chaine;
3178: chaine = (unsigned char *) malloc(
3179: (strlen(chaine_sauvegarde) + 3)
3180: * sizeof(unsigned char));
3181:
3182: if (chaine == NULL)
3183: {
3184: (*s_etat_processus).erreur_systeme =
3185: d_es_allocation_memoire;
3186: return(NULL);
3187: }
3188:
3189: strcpy(chaine, chaine_sauvegarde);
3190: free(chaine_sauvegarde);
3191: strcat(chaine, " ]");
3192: }
3193: }
3194: else if ((*s_objet).type == VIN)
3195: {
3196:
3197: /*
3198: --------------------------------------------------------------------------------
3199: Vecteur entier
3200: --------------------------------------------------------------------------------
3201: */
3202:
3203: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
3204: .taille;
3205:
3206: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
3207:
3208: if (chaine != NULL)
3209: {
3210: strcpy(chaine, "[");
3211:
3212: for(i = 0; i < nombre_colonnes; i++)
3213: {
3214: chaine_formatee = formateur_nombre(s_etat_processus, (void *)
3215: &(((integer8 *) ((*((struct_vecteur *)
3216: ((*s_objet).objet))).tableau))[i]), 'I');
3217:
3218: if (chaine_formatee == NULL)
3219: {
3220: (*s_etat_processus).erreur_systeme =
3221: d_es_allocation_memoire;
3222: return(NULL);
3223: }
3224:
3225: chaine_sauvegarde = chaine;
3226: chaine = (unsigned char *) malloc(
3227: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
3228: + 2) * sizeof(unsigned char));
3229:
3230: if (chaine == NULL)
3231: {
3232: (*s_etat_processus).erreur_systeme =
3233: d_es_allocation_memoire;
3234: return(NULL);
3235: }
3236:
3237: strcpy(chaine, chaine_sauvegarde);
3238: free(chaine_sauvegarde);
3239: strcat(chaine, " ");
3240: strcat(chaine, chaine_formatee);
3241: free(chaine_formatee);
3242: }
3243:
3244: chaine_sauvegarde = chaine;
3245: chaine = (unsigned char *) malloc(
3246: (strlen(chaine_sauvegarde) + 3)
3247: * sizeof(unsigned char));
3248:
3249: if (chaine == NULL)
3250: {
3251: (*s_etat_processus).erreur_systeme =
3252: d_es_allocation_memoire;
3253: return(NULL);
3254: }
3255:
3256: strcpy(chaine, chaine_sauvegarde);
3257: free(chaine_sauvegarde);
3258: strcat(chaine, " ]");
3259: }
3260: }
3261: else if ((*s_objet).type == VRL)
3262: {
3263:
3264: /*
3265: --------------------------------------------------------------------------------
3266: Vecteur réel
3267: --------------------------------------------------------------------------------
3268: */
3269:
3270: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
3271: .taille;
3272:
3273: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
3274:
3275: if (chaine != NULL)
3276: {
3277: strcpy(chaine, "[");
3278:
3279: for(i = 0; i < nombre_colonnes; i++)
3280: {
3281: chaine_formatee = formateur_nombre(s_etat_processus, (void *)
3282: &(((real8 *) ((*((struct_vecteur *)
3283: ((*s_objet).objet))).tableau))[i]), 'R');
3284:
3285: if (chaine_formatee == NULL)
3286: {
3287: (*s_etat_processus).erreur_systeme =
3288: d_es_allocation_memoire;
3289: return(NULL);
3290: }
3291:
3292: chaine_sauvegarde = chaine;
3293: chaine = (unsigned char *) malloc(
3294: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
3295: + 2) * sizeof(unsigned char));
3296:
3297: if (chaine == NULL)
3298: {
3299: (*s_etat_processus).erreur_systeme =
3300: d_es_allocation_memoire;
3301: return(NULL);
3302: }
3303:
3304: strcpy(chaine, chaine_sauvegarde);
3305: free(chaine_sauvegarde);
3306: strcat(chaine, " ");
3307: strcat(chaine, chaine_formatee);
3308: free(chaine_formatee);
3309: }
3310:
3311: chaine_sauvegarde = chaine;
3312: chaine = (unsigned char *) malloc(
3313: (strlen(chaine_sauvegarde) + 3)
3314: * sizeof(unsigned char));
3315:
3316: if (chaine == NULL)
3317: {
3318: (*s_etat_processus).erreur_systeme =
3319: d_es_allocation_memoire;
3320: return(NULL);
3321: }
3322:
3323: strcpy(chaine, chaine_sauvegarde);
3324: free(chaine_sauvegarde);
3325: strcat(chaine, " ]");
3326: }
3327: }
3328:
3329: return(chaine);
3330: }
3331:
3332:
3333: /*
3334: ================================================================================
3335: Routines qui transforment un nombre entier, réel ou complexe en chaîne de
3336: caractères suivant le format courant
3337: ================================================================================
3338: Entrées : pointeur générique sur la donnée numérique à convertir,
3339: type de l'entité (I, R ou C).
3340: --------------------------------------------------------------------------------
3341: Sorties : chaîne de caractères allouée dans la routine
3342: --------------------------------------------------------------------------------
3343: Effets de bord : néant
3344: ================================================================================
3345: */
3346:
3347: /*
3348: --------------------------------------------------------------------------------
3349: Formatage des complexes, réels et entiers
3350: --------------------------------------------------------------------------------
3351: */
3352:
3353: unsigned char *
3354: formateur_nombre(struct_processus *s_etat_processus,
3355: void *valeur_numerique, unsigned char type)
3356: {
3357: unsigned char *chaine;
3358: unsigned char *construction_chaine;
3359: unsigned char *sauvegarde;
3360: unsigned char *tampon;
3361:
3362: chaine = NULL;
3363:
3364: switch(type)
3365: {
3366: case 'C' :
3367: {
3368: construction_chaine = (unsigned char *) malloc(
3369: 2 * sizeof(unsigned char));
3370:
3371: if (construction_chaine == NULL)
3372: {
3373: (*s_etat_processus).erreur_systeme =
3374: d_es_allocation_memoire;
3375: return(NULL);
3376: }
3377:
3378: strcpy(construction_chaine, "(");
3379:
3380: tampon = formateur_reel(s_etat_processus,
3381: (void *) &((*((struct_complexe16 *)
3382: valeur_numerique)).partie_reelle), 'R');
3383:
3384: if (tampon == NULL)
3385: {
3386: (*s_etat_processus).erreur_systeme =
3387: d_es_allocation_memoire;
3388: return(NULL);
3389: }
3390:
3391: sauvegarde = construction_chaine;
3392:
3393: construction_chaine = (unsigned char *) malloc(
3394: (strlen(sauvegarde) + strlen(tampon) + 2)
3395: * sizeof(unsigned char));
3396:
3397: if (construction_chaine == NULL)
3398: {
3399: (*s_etat_processus).erreur_systeme =
3400: d_es_allocation_memoire;
3401: return(NULL);
3402: }
3403:
3404: strcpy(construction_chaine, sauvegarde);
3405: free(sauvegarde);
3406: strcat(construction_chaine, tampon);
3407: free(tampon);
3408:
3409: if (test_cfsf(s_etat_processus, 48) == d_faux)
3410: {
3411: strcat(construction_chaine, ",");
3412: }
3413: else
3414: {
3415: strcat(construction_chaine, ".");
3416: }
3417:
3418: tampon = formateur_reel(s_etat_processus,
3419: (void *) &((*((struct_complexe16 *)
3420: valeur_numerique)).partie_imaginaire), 'R');
3421:
3422: if (tampon == NULL)
3423: {
3424: (*s_etat_processus).erreur_systeme =
3425: d_es_allocation_memoire;
3426: return(NULL);
3427: }
3428:
3429: sauvegarde = construction_chaine;
3430:
3431: construction_chaine = (unsigned char *) malloc(
3432: (strlen(sauvegarde) + strlen(tampon) + 2)
3433: * sizeof(unsigned char));
3434:
3435: if (construction_chaine == NULL)
3436: {
3437: (*s_etat_processus).erreur_systeme =
3438: d_es_allocation_memoire;
3439: return(NULL);
3440: }
3441:
3442: strcpy(construction_chaine, sauvegarde);
3443: free(sauvegarde);
3444: strcat(construction_chaine, tampon);
3445: free(tampon);
3446: strcat(construction_chaine, ")");
3447:
3448: chaine = construction_chaine;
3449:
3450: break;
3451: }
3452:
3453: case 'R' :
3454: {
3455: chaine = formateur_reel(s_etat_processus, valeur_numerique, 'R');
3456:
3457: if (chaine == NULL)
3458: {
3459: (*s_etat_processus).erreur_systeme =
3460: d_es_allocation_memoire;
3461: return(NULL);
3462: }
3463:
3464: break;
3465: }
3466:
3467: default :
3468: case 'I' :
3469: {
3470: chaine = formateur_reel(s_etat_processus, valeur_numerique, 'I');
3471:
3472: if (chaine == NULL)
3473: {
3474: (*s_etat_processus).erreur_systeme =
3475: d_es_allocation_memoire;
3476: return(NULL);
3477: }
3478:
3479: break;
3480: }
3481: }
3482:
3483: return(chaine);
3484: }
3485:
3486:
3487: /*
3488: --------------------------------------------------------------------------------
3489: Formateur des réels et entiers
3490: --------------------------------------------------------------------------------
3491: */
3492:
3493: unsigned char *
3494: formateur_reel(struct_processus *s_etat_processus,
3495: void *valeur_numerique, unsigned char type)
3496: {
3497: real8 mantisse;
3498: real8 tampon_reel;
3499:
3500: integer8 tampon_entier;
3501:
3502: logical1 i49;
3503: logical1 i50;
3504:
3505: long correction;
1.4 bertrand 3506: long dernier_chiffre_significatif;
1.1 bertrand 3507: long exposant;
3508: long longueur_utile;
3509: long longueur_utile_limite;
3510:
3511: unsigned char *chaine;
1.3 bertrand 3512: unsigned char format[32 + 1];
1.1 bertrand 3513: unsigned char mode[3 + 1];
3514: unsigned char *ptr;
1.3 bertrand 3515: unsigned char tampon[32 + 1];
1.1 bertrand 3516:
3517: unsigned long i;
3518: unsigned long j;
3519:
3520: chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
3521:
3522: if (chaine == NULL)
3523: {
3524: (*s_etat_processus).erreur_systeme =
3525: d_es_allocation_memoire;
3526: return(NULL);
3527: }
3528:
3529: if (type == 'R')
3530: {
3531: tampon_reel = *((real8 *) valeur_numerique);
3532:
3533: if (tampon_reel > ((real8) 0))
3534: {
3535: exposant = (long) floor(log10(tampon_reel));
3536: }
3537: else if (tampon_reel < ((real8) 0))
3538: {
3539: exposant = (long) floor(log10(-tampon_reel));
3540: }
3541: else
3542: {
3543: exposant = 0;
3544: }
3545:
3546: mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
3547: }
3548: else
3549: {
3550: tampon_entier = *((integer8 *) valeur_numerique);
3551:
3552: if (tampon_entier > ((integer8) 0))
3553: {
3554: exposant = (long) floor(log10(tampon_entier));
3555: }
3556: else if (tampon_entier < ((integer8) 0))
3557: {
3558: exposant = (long) floor(log10(-tampon_entier));
3559: }
3560: else
3561: {
3562: exposant = 0;
3563: }
3564:
3565: mantisse = (*((integer8 *) valeur_numerique)) / pow(10, exposant);
3566: }
3567:
3568: longueur_utile = 0;
3569: j = 1;
3570:
3571: for(i = 53; i <= 56; i++)
3572: {
3573: longueur_utile += (test_cfsf(s_etat_processus, (unsigned char) i)
3574: == d_vrai) ? j : 0;
3575: j *= 2;
3576: }
3577:
3578: longueur_utile_limite = 15;
3579:
3580: if (longueur_utile > longueur_utile_limite)
3581: {
3582: longueur_utile = longueur_utile_limite;
3583: }
3584:
3585: i49 = test_cfsf(s_etat_processus, 49);
3586: i50 = test_cfsf(s_etat_processus, 50);
3587:
3588: if (i49 == d_faux)
3589: {
3590: if (i50 == d_faux)
3591: {
3592:
3593: /*
3594: --------------------------------------------------------------------------------
3595: Mode standard
3596: --------------------------------------------------------------------------------
3597: */
3598:
3599: strcpy(mode, "STD");
3600: }
3601: else
3602: {
3603:
3604: /*
3605: --------------------------------------------------------------------------------
3606: Mode scientifique
3607: --------------------------------------------------------------------------------
3608: */
3609:
3610: strcpy(mode, "SCI");
3611: }
3612: }
3613: else
3614: {
3615: if (i50 == d_faux)
3616: {
3617:
3618: /*
3619: --------------------------------------------------------------------------------
3620: Mode fixe
3621: --------------------------------------------------------------------------------
3622: */
3623:
3624: strcpy(mode, "FIX");
3625: }
3626: else
3627: {
3628:
3629: /*
3630: --------------------------------------------------------------------------------
3631: Mode ingénieur
3632: --------------------------------------------------------------------------------
3633: */
3634:
3635: strcpy(mode, "ENG");
3636: }
3637: }
3638:
1.4 bertrand 3639: // Test portant sur le nombre de chiffres significatifs dans
3640: // le cas du format STD pour que 1.2E-15 apparaisse en notation
3641: // SCI car il y a une perte de précision dans l'affichage.
3642:
3643: if ((strcmp(mode, "STD") == 0) && (type == 'R'))
3644: {
3645: if (abs(*((real8 *) valeur_numerique)) < 1)
3646: {
3647: dernier_chiffre_significatif = -exposant;
3648: sprintf(tampon, ".%f", mantisse);
3649:
3650: ptr = &(tampon[strlen(tampon) - 1]);
3651:
3652: while((*ptr) != '.')
3653: {
3654: if ((*ptr) != '0')
3655: {
3656: dernier_chiffre_significatif++;
3657: }
3658:
3659: ptr--;
3660: }
3661: }
3662: else
3663: {
3664: dernier_chiffre_significatif = 0;
3665: }
3666: }
3667: else
3668: {
3669: dernier_chiffre_significatif = 0;
3670: }
3671:
1.1 bertrand 3672: if ((strcmp(mode, "SCI") == 0) ||
3673: ((strcmp(mode, "STD") == 0) && ((exposant >
1.4 bertrand 3674: longueur_utile_limite) || (dernier_chiffre_significatif > 15) ||
1.1 bertrand 3675: (exposant < -longueur_utile_limite))) ||
3676: ((strcmp(mode, "FIX") == 0) &&
3677: ((exposant >= longueur_utile_limite) ||
3678: (exposant < -longueur_utile))))
3679: {
3680: chaine[0] = d_code_fin_chaine;
3681: format[0] = d_code_fin_chaine;
3682:
3683: if (strcmp(mode, "STD") == 0)
3684: {
3685: longueur_utile = longueur_utile_limite - 1;
3686: }
3687:
3688: sprintf(format, "%%.%luf", longueur_utile);
3689: sprintf(tampon, format, mantisse);
3690: strcpy(chaine, tampon);
3691:
3692: if (strcmp(mode, "STD") == 0)
3693: {
3694: ptr = &(chaine[strlen(chaine) - 1]);
3695: while(((*ptr) == '0') || ((*ptr) == '.'))
3696: {
3697: (*ptr) = d_code_fin_chaine;
3698: ptr--;
3699: }
3700: }
3701:
3702: strcat(chaine, "E");
3703: sprintf(tampon, "%ld", exposant);
3704: strcat(chaine, tampon);
3705: }
3706: else if (strcmp(mode, "FIX") == 0)
3707: {
3708: chaine[0] = d_code_fin_chaine;
3709: format[0] = d_code_fin_chaine;
3710:
3711: if (longueur_utile + exposant >= longueur_utile_limite)
3712: {
3713: longueur_utile = longueur_utile_limite - (exposant + 1);
3714: }
3715:
3716: sprintf(format, "%%.%luf", longueur_utile);
3717:
3718: sprintf(tampon, format, (mantisse * pow(10, exposant)));
3719: strcpy(chaine, tampon);
3720: }
3721: else if (strcmp(mode, "ENG") == 0)
3722: {
3723: chaine[0] = d_code_fin_chaine;
3724: format[0] = d_code_fin_chaine;
3725:
3726: correction = labs(exposant) % 3;
3727:
3728: if (exposant < 0)
3729: {
3730: if (correction == 0)
3731: {
3732: correction = 3;
3733: }
3734:
3735: correction = 3 - correction;
3736: }
3737:
3738: longueur_utile -= correction;
3739: sprintf(format, "%%.%luf", longueur_utile);
3740:
3741: sprintf(tampon, format, (mantisse * pow(10, correction)));
3742: strcpy(chaine, tampon);
3743: strcat(chaine, "E");
3744: sprintf(tampon, "%ld", (exposant - correction));
3745: strcat(chaine, tampon);
3746: }
3747: else
3748: {
3749: if (type == 'I')
3750: {
3751: chaine[0] = d_code_fin_chaine;
3752: sprintf(tampon, "%lld", *((integer8 *) valeur_numerique));
3753: }
3754: else
3755: {
3756: chaine[0] = d_code_fin_chaine;
3757: format[0] = d_code_fin_chaine;
3758:
3759: if (exposant >= 0)
3760: {
3761: sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
3762: - 1));
3763: }
3764: else
3765: {
3766: sprintf(format, "%%.%luf", longueur_utile_limite);
3767: }
3768:
3769: sprintf(tampon, format, *((real8 *) valeur_numerique));
3770:
3771: i = strlen(tampon) - 1;
3772: while(tampon[i] == '0')
3773: {
3774: tampon[i] = d_code_fin_chaine;
3775: i--;
3776: }
3777:
3778: if (ds_imposition_separateur_decimal == d_faux)
3779: {
3780: i = strlen(tampon) - 1;
3781: if (tampon[i] == '.')
3782: {
3783: tampon[i] = d_code_fin_chaine;
3784: }
3785: }
3786: }
1.4 bertrand 3787:
1.1 bertrand 3788: strcpy(chaine, tampon);
3789: }
3790:
3791: if (test_cfsf(s_etat_processus, 48) == d_vrai)
3792: {
3793: for(i = 0; i < strlen(chaine); i++)
3794: {
3795: if (chaine[i] == '.')
3796: {
3797: chaine[i] = ',';
3798: }
3799: }
3800: }
3801:
3802: return(chaine);
3803: }
3804:
3805: // vim: ts=4