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