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