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