/* ================================================================================ RPL/2 (R) version 4.1.32 Copyright (C) 1989-2020 Dr. BERTRAND Joël This file is part of RPL/2. RPL/2 is free software; you can redistribute it and/or modify it under the terms of the CeCILL V2 License as published by the french CEA, CNRS and INRIA. RPL/2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License for more details. You should have received a copy of the CeCILL License along with RPL/2. If not, write to info@cecill.info. ================================================================================ */ #include "rpl-conv.h" /* ================================================================================ Routine de formation des données pour l'affichage ================================================================================ Entrées : structure sur l'état du processus et objet à afficher -------------------------------------------------------------------------------- Sorties : chaine de caractères -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ unsigned char * formateur(struct_processus *s_etat_processus, long offset_initial, struct_objet *s_objet) { int parentheses_groupe_gauche; int parentheses_groupe_droit; integer8 (*__type_disp)(struct_processus *, void **); logical1 registre45; logical4 autorisation_parenthese; logical4 presence_signe; logical8 masque_binaire; struct_liste_chainee *l_atome; struct_liste_chainee *l_element_courant; struct_liste_chainee *l_liste1; struct_liste_chainee *l_liste2; struct_objet *s_sous_objet; struct_objet *s_sous_objet_1; struct_objet *s_sous_objet_2; struct_objet *s_sous_objet_3; unsigned char base[1 + 1]; unsigned char *chaine; unsigned char *chaine_fonction; unsigned char *chaine_formatee; unsigned char *chaine_tampon; unsigned char *chaine_sauvegarde; unsigned char *format; unsigned char *format_majuscule; unsigned char *ptre; unsigned char *ptrl; unsigned char *registre; unsigned char tampon[1024 + 1]; integer8 i; integer8 j; integer8 k; integer8 longueur_chaine; integer8 longueur_courante; integer8 longueur_decimale_courante; integer8 *longueurs_maximales; integer8 nombre_arguments; integer8 nombre_arguments_fonction; integer8 nombre_colonnes; integer8 nombre_elements; integer8 nombre_lignes; integer8 offset; chaine = NULL; chaine_formatee = NULL; chaine_sauvegarde = NULL; strcpy(base, " "); masque_binaire = 0; if ((*s_objet).type == ADR) { /* -------------------------------------------------------------------------------- Adresse -------------------------------------------------------------------------------- */ if (alsprintf(s_etat_processus, &chaine, "@ %016llX", (*((unsigned long long *) ((*s_objet).objet)))) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } } else if ((*s_objet).type == SLB) { /* -------------------------------------------------------------------------------- Bibliothèque partagée -------------------------------------------------------------------------------- */ # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpointer-to-int-cast" if (alsprintf(s_etat_processus, &chaine, "Library $ %016llX [%s]", (unsigned long long) (*((struct_bibliotheque *) (*s_objet).objet)).descripteur, (*((struct_bibliotheque *) (*s_objet).objet)).nom) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } # pragma GCC diagnostic pop } else if ((*s_objet).type == SPH) { /* -------------------------------------------------------------------------------- Sémaphore -------------------------------------------------------------------------------- */ # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpointer-to-int-cast" if (alsprintf(s_etat_processus, &chaine, "Semaphore $ %016llX '%s'", (unsigned long long) &((*((struct_semaphore *) (*s_objet).objet)).semaphore), (*((struct_semaphore *) (*s_objet).objet)).nom) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } # pragma GCC diagnostic pop } else if ((*s_objet).type == SQL) { /* -------------------------------------------------------------------------------- Connecteur SQL -------------------------------------------------------------------------------- */ if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type, "MYSQL") == 0) { # ifdef MYSQL_SUPPORT if (alsprintf(s_etat_processus, &chaine, "Sql $ %016llX (%s)", (unsigned long long) (*((struct_connecteur_sql *) (*s_objet).objet)).descripteur.mysql, (*((struct_connecteur_sql *) (*s_objet).objet)).type) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } # else if ((*s_etat_processus).langue == 'F') { printf("+++Attention : Support de MySQL " "non compilé !\n"); } else { printf("+++Warning : MySQL support " "not available !\n"); } fflush(stdout); # endif } else if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type, "POSTGRESQL") == 0) { # ifdef POSTGRESQL_SUPPORT if (alsprintf(s_etat_processus, &chaine, "Sql $ %016llX (%s)", (unsigned long long) (*((struct_connecteur_sql *) (*s_objet).objet)).descripteur.postgresql, (*((struct_connecteur_sql *) (*s_objet).objet)).type) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } # else if ((*s_etat_processus).langue == 'F') { printf("+++Attention : Support de PostgreSQL " "non compilé !\n"); } else { printf("+++Warning : PostgreSQL support " "not available !\n"); } fflush(stdout); # endif } else { BUG(1, printf("SQL type '%s' not allowed!", (*((struct_connecteur_sql *) (*s_objet).objet)) .type)); } } else if ((*s_objet).type == PRC) { /* -------------------------------------------------------------------------------- Processus -------------------------------------------------------------------------------- */ if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread) .processus_detache == d_vrai) { if (alsprintf(s_etat_processus, &chaine, "Process $ %016llX", (unsigned long long) (*(*((struct_processus_fils *) (*s_objet).objet)).thread) .pid) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } } else { if (alsprintf(s_etat_processus, &chaine, "Light weight process $ %016llX/%016llX", (unsigned long long) (*(*((struct_processus_fils *) (*s_objet).objet)).thread).pid, (unsigned long long) (*(*((struct_processus_fils *) (*s_objet).objet)).thread).tid) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } } } else if ((*s_objet).type == FCH) { /* -------------------------------------------------------------------------------- Fichier -------------------------------------------------------------------------------- */ if (alsprintf(s_etat_processus, &chaine, "File $ %016llX", (unsigned long long) (*((struct_fichier *) ((*s_objet).objet))).descripteur) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } registre45 = test_cfsf(s_etat_processus, 45); cf(s_etat_processus, 45); if ((format = formateur(s_etat_processus, 0, (*((struct_fichier *) ((*s_objet).objet))).format)) == NULL) { return(NULL); } if (registre45 == d_vrai) { sf(s_etat_processus, 45); } else { cf(s_etat_processus, 45); } if ((format_majuscule = conversion_majuscule(s_etat_processus, format)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } free(format); registre = chaine; if ((chaine = malloc((strlen(registre) + 1 + strlen(format_majuscule) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s %s", registre, format_majuscule); free(registre); tampon[0] = d_code_fin_chaine; if ((*((struct_fichier *) ((*s_objet).objet))).acces == 'S') { strcat(tampon, "SEQUENTIAL, "); } else if ((*((struct_fichier *) ((*s_objet).objet))).acces == 'D') { strcat(tampon, "DIRECT, "); } else { strcat(tampon, "KEYED, "); } if ((*((struct_fichier *) ((*s_objet).objet))).binaire == 'N') { strcat(tampon, "FORMATTED, "); } else if ((*((struct_fichier *) ((*s_objet).objet))).binaire == 'Y') { strcat(tampon, "UNFORMATTED, "); } else { strcat(tampon, "FLOW, "); } if ((*((struct_fichier *) ((*s_objet).objet))).ouverture == 'N') { strcat(tampon, "NEW, "); } else if ((*((struct_fichier *) ((*s_objet).objet))).ouverture == 'O') { strcat(tampon, "OLD, "); } else if ((*((struct_fichier *) ((*s_objet).objet))).ouverture == 'R') { strcat(tampon, "REPLACE, "); } else if ((*((struct_fichier *) ((*s_objet).objet))).ouverture == 'U') { strcat(tampon, "UNKNOWN, "); } else { strcat(tampon, "SCRATCH, "); } if ((*((struct_fichier *) ((*s_objet).objet))).protection == 'R') { strcat(tampon, "READONLY"); } else if ((*((struct_fichier *) ((*s_objet).objet))).protection == 'W') { strcat(tampon, "WRITEONLY"); } else { strcat(tampon, "READWRITE"); } registre = chaine; if ((chaine = malloc((strlen(chaine) + 6 + strlen(tampon) + strlen((*((struct_fichier *) ((*s_objet).objet))).nom) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s [%s <%s>]", registre, (*((struct_fichier *) ((*s_objet).objet))).nom, tampon); free(registre); free(format_majuscule); } else if ((*s_objet).type == SCK) { /* -------------------------------------------------------------------------------- Socket -------------------------------------------------------------------------------- */ if (alsprintf(s_etat_processus, &chaine, "Socket $ %016llX", (unsigned long long) (*((struct_socket *) ((*s_objet).objet))).socket) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } registre45 = test_cfsf(s_etat_processus, 45); cf(s_etat_processus, 45); if ((format = formateur(s_etat_processus, 0, (*((struct_socket *) ((*s_objet).objet))).format)) == NULL) { return(NULL); } if (registre45 == d_vrai) { sf(s_etat_processus, 45); } else { cf(s_etat_processus, 45); } if ((format_majuscule = conversion_majuscule(s_etat_processus, format)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } free(format); registre = chaine; if ((chaine = malloc((strlen(registre) + 1 + strlen(format_majuscule) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s %s", registre, format_majuscule); free(registre); tampon[0] = d_code_fin_chaine; strcat(tampon, (*((struct_socket *) ((*s_objet).objet))).type); strcat(tampon, ", "); if ((*((struct_socket *) ((*s_objet).objet))).domaine == PF_UNIX) { strcat(tampon, "UNIX, "); } else if ((*((struct_socket *) ((*s_objet).objet))).domaine == PF_INET) { strcat(tampon, "IPV4, "); } else if ((*((struct_socket *) ((*s_objet).objet))).domaine == PF_INET6) { strcat(tampon, "IPV6, "); } if ((*((struct_socket *) ((*s_objet).objet))).localisation == 'L') { strcat(tampon, "LOCAL, "); } else { strcat(tampon, "FOREIGN, "); } if ((*((struct_socket *) ((*s_objet).objet))).binaire == 'N') { strcat(tampon, "FORMATTED, "); } else if ((*((struct_socket *) ((*s_objet).objet))).binaire == 'Y') { strcat(tampon, "UNFORMATTED, "); } else { strcat(tampon, "FLOW, "); } if ((*((struct_socket *) ((*s_objet).objet))).protection == 'R') { strcat(tampon, "READONLY"); } else if ((*((struct_fichier *) ((*s_objet).objet))).protection == 'W') { strcat(tampon, "WRITEONLY"); } else { strcat(tampon, "READWRITE"); } registre = chaine; if ((*((struct_socket *) ((*s_objet).objet))).localisation == 'L') { // Socket locale if ((strcmp((*((struct_socket *) ((*s_objet).objet))).type, "STREAM") == 0) || (strcmp((*((struct_socket *) ((*s_objet).objet))).type, "SEQUENTIAL DATAGRAM") == 0)) { if (strcmp((*((struct_socket *) ((*s_objet).objet))) .adresse_distante, "") == 0) { // Socket connectée en écoute if ((chaine = malloc((strlen(registre) + 16 + strlen(tampon) + strlen((*((struct_socket *) ((*s_objet).objet))).adresse) + + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s [%s LISTENING <%s>]", registre, (*((struct_socket *) ((*s_objet).objet))).adresse, tampon); } else { // Socket connecté if ((chaine = malloc((strlen(registre) + 12 + strlen(tampon) + strlen((*((struct_socket *) ((*s_objet).objet))).adresse) + strlen((*((struct_socket *) ((*s_objet).objet))) .adresse_distante) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s [%s FROM %s <%s>]", registre, (*((struct_socket *) ((*s_objet).objet))).adresse, (*((struct_socket *) ((*s_objet).objet))) .adresse_distante, tampon); } } else // Socket non connectée { if ((chaine = malloc((strlen(registre) + 6 + strlen(tampon) + strlen((*((struct_socket *) ((*s_objet).objet))).adresse) + + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s [%s <%s>]", registre, (*((struct_socket *) ((*s_objet).objet))).adresse, tampon); } } else { // Socket distante if ((strcmp((*((struct_socket *) ((*s_objet).objet))).type, "STREAM") == 0) || (strcmp((*((struct_socket *) ((*s_objet).objet))).type, "SEQUENTIAL DATAGRAM") == 0)) { if ((chaine = malloc((strlen(registre) + 9 + strlen((*((struct_socket *) ((*s_objet).objet))) .adresse) + strlen(tampon) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s [TO %s <%s>]", registre, (*((struct_socket *) ((*s_objet).objet))) .adresse, tampon); } else { if (strcmp((*((struct_socket *) ((*s_objet).objet))) .adresse_distante, "") == 0) { if ((chaine = malloc((strlen(registre) + 5 + strlen(tampon) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s [<%s>]", registre, tampon); } else { if ((chaine = malloc((strlen(registre) + 9 + strlen((*((struct_socket *) ((*s_objet).objet))) .adresse_distante) + strlen(tampon) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s [TO %s <%s>]", registre, (*((struct_socket *) ((*s_objet).objet))) .adresse_distante, tampon); } } } free(registre); free(format_majuscule); } else if ((*s_objet).type == ALG) { /* -------------------------------------------------------------------------------- Expression algébrique -------------------------------------------------------------------------------- */ l_element_courant = (struct_liste_chainee *) (*s_objet).objet; while(l_element_courant != NULL) { if ((*(*l_element_courant).donnee).type == FCT) { if ((strcmp((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction, "<<") != 0) && (strcmp((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction, ">>") != 0)) { if ((strcmp((*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction, "+") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "-") == 0) || (strcmp( (*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction, "*") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "/") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "^") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "<") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, ">") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "==") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "<>") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "<=") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "=<") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, ">=") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "=>") == 0)) { if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_sous_objet_2) == d_erreur) { return(NULL); } chaine_sauvegarde = (*s_etat_processus) .instruction_courante; if (((*s_etat_processus).instruction_courante = (unsigned char *) malloc((strlen( (unsigned char *) (*s_sous_objet_2).objet) + 2 + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).instruction_courante = chaine_sauvegarde; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf((*s_etat_processus).instruction_courante, "'%s'", (unsigned char *) (*s_sous_objet_2).objet); presence_signe = (((*s_etat_processus) .instruction_courante[1] == '+') || ((*s_etat_processus).instruction_courante[1] == '-')) ? d_vrai : d_faux; (*s_etat_processus).type_en_cours = NON; recherche_type(s_etat_processus); if ((*s_etat_processus).erreur_execution != d_ex) { // Aucune erreur d'exécution ne peut être // retournée, car l'argument est cohérent. return(NULL); } if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_sous_objet_3) == d_erreur) { return(NULL); } free((*s_etat_processus).instruction_courante); (*s_etat_processus).instruction_courante = chaine_sauvegarde; autorisation_parenthese = d_faux; if ((*s_sous_objet_3).type == ALG) { l_atome = (struct_liste_chainee *) (*s_sous_objet_3).objet; chaine_fonction = ""; nombre_arguments_fonction = 0; while(l_atome != NULL) { if ((*(*l_atome).donnee).type == FCT) { if (strcmp((*((struct_fonction *) (*(*l_atome).donnee).objet)) .nom_fonction, ">>") != 0) { chaine_fonction = (*((struct_fonction *) (*(*l_atome).donnee).objet)) .nom_fonction; nombre_arguments_fonction = (*((struct_fonction *) (*(*l_atome).donnee).objet)) .nombre_arguments; } } l_atome = (*l_atome).suivant; } if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "+") == 0) { if ((strcmp(chaine_fonction, "AND") == 0) || (strcmp(chaine_fonction, "XOR") == 0) || (strcmp(chaine_fonction, "EQV") == 0) || (strcmp(chaine_fonction, "OR") == 0)) { autorisation_parenthese = d_vrai; } } else if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "-") == 0) { if (nombre_arguments_fonction != 0) { autorisation_parenthese = d_faux; } else { autorisation_parenthese = d_vrai; } } else if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "*") == 0) { if ((strcmp(chaine_fonction, "+") == 0) || (strcmp(chaine_fonction, "-") == 0) || (strcmp(chaine_fonction, "AND") == 0) || (strcmp(chaine_fonction, "XOR") == 0) || (strcmp(chaine_fonction, "EQV") == 0) || (strcmp(chaine_fonction, "OR") == 0)) { autorisation_parenthese = d_vrai; } } else if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "/") == 0) { if (nombre_arguments_fonction != 0) { autorisation_parenthese = d_faux; } else { autorisation_parenthese = d_vrai; } } else if ((strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "^") == 0)) { if (nombre_arguments_fonction != 0) { autorisation_parenthese = d_faux; } else { autorisation_parenthese = d_vrai; } } } if ((autorisation_parenthese == d_vrai) || (presence_signe == d_vrai)) { chaine_sauvegarde = (unsigned char *) (*s_sous_objet_2).objet; if (((*s_sous_objet_2).objet = malloc((strlen(chaine_sauvegarde) + 2 + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf((unsigned char *) (*s_sous_objet_2).objet, "(%s)", chaine_sauvegarde); free(chaine_sauvegarde); } liberation(s_etat_processus, s_sous_objet_3); if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_sous_objet_1) == d_erreur) { return(NULL); } chaine_sauvegarde = (*s_etat_processus) .instruction_courante; if (((*s_etat_processus).instruction_courante = (unsigned char *) malloc((strlen( (unsigned char *) (*s_sous_objet_1).objet) + 2 + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).instruction_courante = chaine_sauvegarde; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf((*s_etat_processus).instruction_courante, "'%s'", (unsigned char *) (*s_sous_objet_1).objet); (*s_etat_processus).type_en_cours = NON; recherche_type(s_etat_processus); if ((*s_etat_processus).erreur_execution != d_ex) { // Aucune erreur d'exécution ne peut être // retournée, car l'argument est cohérent. return(NULL); } if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_sous_objet_3) == d_erreur) { return(NULL); } free((*s_etat_processus).instruction_courante); (*s_etat_processus).instruction_courante = chaine_sauvegarde; autorisation_parenthese = d_faux; if ((*s_sous_objet_3).type == ALG) { l_atome = (struct_liste_chainee *) (*s_sous_objet_3).objet; chaine_fonction = ""; while(l_atome != NULL) { if ((*(*l_atome).donnee).type == FCT) { if (strcmp((*((struct_fonction *) (*(*l_atome).donnee).objet)) .nom_fonction, ">>") != 0) { chaine_fonction = (*((struct_fonction *) (*(*l_atome).donnee).objet)) .nom_fonction; } } l_atome = (*l_atome).suivant; } if ((strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "+") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "-") == 0)) { if ((strcmp(chaine_fonction, "AND") == 0) || (strcmp(chaine_fonction, "XOR") == 0) || (strcmp(chaine_fonction, "EQV") == 0) || (strcmp(chaine_fonction, "OR") == 0)) { autorisation_parenthese = d_vrai; } } else if ((strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "*") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "/") == 0)) { if ((strcmp(chaine_fonction, "+") == 0) || (strcmp(chaine_fonction, "-") == 0) || (strcmp(chaine_fonction, "AND") == 0) || (strcmp(chaine_fonction, "XOR") == 0) || (strcmp(chaine_fonction, "EQV") == 0) || (strcmp(chaine_fonction, "OR") == 0)) { autorisation_parenthese = d_vrai; } } else if ((strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "^") == 0)) { autorisation_parenthese = d_vrai; } } if (autorisation_parenthese == d_vrai) { chaine_sauvegarde = (unsigned char *) (*s_sous_objet_1).objet; if (((*s_sous_objet_1).objet = malloc((strlen(chaine_sauvegarde) + 2 + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf((unsigned char *) (*s_sous_objet_1).objet, "(%s)", chaine_sauvegarde); free(chaine_sauvegarde); } liberation(s_etat_processus, s_sous_objet_3); if ((s_sous_objet = allocation(s_etat_processus, CHN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if (((*s_sous_objet).objet = malloc((strlen( (unsigned char *) (*s_sous_objet_1).objet) + strlen((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction) + strlen((unsigned char *) (*s_sous_objet_2).objet) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf((unsigned char *) (*s_sous_objet).objet, "%s%s%s", (unsigned char *) (*s_sous_objet_1) .objet, (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, (unsigned char *) (*s_sous_objet_2).objet); liberation(s_etat_processus, s_sous_objet_1); liberation(s_etat_processus, s_sous_objet_2); if (empilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), s_sous_objet) == d_erreur) { return(NULL); } } else if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "=") == 0) { if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_sous_objet_2) == d_erreur) { return(NULL); } if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_sous_objet_1) == d_erreur) { return(NULL); } if ((s_sous_objet = allocation(s_etat_processus, CHN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } autorisation_parenthese = d_vrai; l_atome = l_element_courant; if (l_atome != NULL) { if ((*l_atome).suivant != NULL) { l_atome = (*l_atome).suivant; if ((*(*l_atome).donnee).type == FCT) { if (strcmp((*((struct_fonction *) (*(*l_atome).donnee).objet)) .nom_fonction, ">>") == 0) { if ((*l_atome).suivant == NULL) { autorisation_parenthese = d_faux; } } } } } if (autorisation_parenthese == d_vrai) { if (((*s_sous_objet).objet = malloc((strlen( (unsigned char *) (*s_sous_objet_1).objet) + strlen((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction) + strlen((unsigned char *) (*s_sous_objet_2).objet) + 2 + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf((unsigned char *) (*s_sous_objet).objet, "(%s%s%s)", (unsigned char *) (*s_sous_objet_1) .objet, (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, (unsigned char *) (*s_sous_objet_2).objet); } else { if (((*s_sous_objet).objet = malloc((strlen( (unsigned char *) (*s_sous_objet_1).objet) + strlen((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction) + strlen((unsigned char *) (*s_sous_objet_2).objet) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf((unsigned char *) (*s_sous_objet).objet, "%s%s%s", (unsigned char *) (*s_sous_objet_1) .objet, (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, (unsigned char *) (*s_sous_objet_2).objet); } liberation(s_etat_processus, s_sous_objet_1); liberation(s_etat_processus, s_sous_objet_2); if (empilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), s_sous_objet) == d_erreur) { return(NULL); } } else if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "NOT") == 0) { if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_sous_objet_1) == d_erreur) { return(NULL); } if ((s_sous_objet = allocation(s_etat_processus, CHN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if (((*s_sous_objet).objet = (unsigned char *) malloc( (strlen((unsigned char *) (*s_sous_objet_1) .objet) + 5 + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf((unsigned char *) (*s_sous_objet).objet, "%s(%s)", (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, (unsigned char *) (*s_sous_objet_1).objet ); liberation(s_etat_processus, s_sous_objet_1); if (empilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), s_sous_objet) == d_erreur) { return(NULL); } } else if ((strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "OR") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "XOR") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "EQV") == 0) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)).nom_fonction, "AND") == 0)) { if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_sous_objet_2) == d_erreur) { return(NULL); } if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_sous_objet_1) == d_erreur) { return(NULL); } if ((s_sous_objet = allocation(s_etat_processus, CHN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } parentheses_groupe_gauche = 0; parentheses_groupe_droit = 0; chaine_sauvegarde = (*s_etat_processus) .instruction_courante; if (((*s_etat_processus).instruction_courante = (unsigned char *) malloc((strlen( (unsigned char *) (*s_sous_objet_1).objet) + 2 + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).instruction_courante = chaine_sauvegarde; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf((*s_etat_processus).instruction_courante, "'%s'", (unsigned char *) (*s_sous_objet_1).objet); (*s_etat_processus).type_en_cours = NON; recherche_type(s_etat_processus); if ((*s_etat_processus).erreur_execution != d_ex) { // Aucune erreur d'exécution ne peut être // retournée, car l'argument est cohérent. return(NULL); } if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_sous_objet_3) == d_erreur) { return(NULL); } free((*s_etat_processus).instruction_courante); (*s_etat_processus).instruction_courante = chaine_sauvegarde; if ((*s_sous_objet_3).type == ALG) { l_atome = (struct_liste_chainee *) (*s_sous_objet_3).objet; chaine_fonction = ""; while(l_atome != NULL) { if ((*(*l_atome).donnee).type == FCT) { if (strcmp((*((struct_fonction *) (*(*l_atome).donnee).objet)) .nom_fonction, ">>") != 0) { chaine_fonction = (*((struct_fonction *) (*(*l_atome).donnee).objet)) .nom_fonction; } } l_atome = (*l_atome).suivant; } if (((strcmp(chaine_fonction, "OR") == 0) || (strcmp(chaine_fonction, "EQV") == 0) || (strcmp(chaine_fonction, "XOR") == 0)) && (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "AND") == 0)) { parentheses_groupe_gauche = 2; } } liberation(s_etat_processus, s_sous_objet_3); chaine_sauvegarde = (*s_etat_processus) .instruction_courante; if (((*s_etat_processus).instruction_courante = (unsigned char *) malloc((strlen( (unsigned char *) (*s_sous_objet_2).objet) + 2 + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).instruction_courante = chaine_sauvegarde; (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf((*s_etat_processus).instruction_courante, "'%s'", (unsigned char *) (*s_sous_objet_2).objet); (*s_etat_processus).type_en_cours = NON; recherche_type(s_etat_processus); if ((*s_etat_processus).erreur_execution != d_ex) { // Aucune erreur d'exécution ne peut être // retournée, car l'argument est cohérent. return(NULL); } if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_sous_objet_3) == d_erreur) { return(NULL); } free((*s_etat_processus).instruction_courante); (*s_etat_processus).instruction_courante = chaine_sauvegarde; if ((*s_sous_objet_3).type == ALG) { l_atome = (struct_liste_chainee *) (*s_sous_objet_3).objet; chaine_fonction = ""; while(l_atome != NULL) { if ((*(*l_atome).donnee).type == FCT) { if (strcmp((*((struct_fonction *) (*(*l_atome).donnee).objet)) .nom_fonction, ">>") != 0) { chaine_fonction = (*((struct_fonction *) (*(*l_atome).donnee).objet)) .nom_fonction; } } l_atome = (*l_atome).suivant; } if (((strcmp(chaine_fonction, "OR") == 0) || (strcmp(chaine_fonction, "EQV") == 0) || (strcmp(chaine_fonction, "XOR") == 0)) && (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "AND") == 0)) { parentheses_groupe_droit = 2; } } liberation(s_etat_processus, s_sous_objet_3); if (((*s_sous_objet).objet = malloc((strlen( (unsigned char *) (*s_sous_objet_1).objet) + strlen((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction) + strlen((unsigned char *) (*s_sous_objet_2).objet) + 2 + 1 + ((size_t) parentheses_groupe_gauche) + ((size_t) parentheses_groupe_droit)) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf((unsigned char *) (*s_sous_objet).objet, (parentheses_groupe_gauche == 0) ? ((parentheses_groupe_droit == 0) ? "%s %s %s" : "%s %s (%s)") : ((parentheses_groupe_droit == 0) ? "(%s) %s %s" : "(%s) %s (%s)"), (unsigned char *) (*s_sous_objet_1) .objet, (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, (unsigned char *) (*s_sous_objet_2).objet); liberation(s_etat_processus, s_sous_objet_1); liberation(s_etat_processus, s_sous_objet_2); if (empilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), s_sous_objet) == d_erreur) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } } else { nombre_arguments = (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nombre_arguments; if ((chaine = (unsigned char *) malloc(sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = d_code_fin_chaine; for(i = 0; i < nombre_arguments; i++) { if ((nombre_arguments - i) > 1) { l_liste1 = (*s_etat_processus).l_base_pile; for(j = 2; j < (nombre_arguments - i); j++) { l_liste1 = (*l_liste1).suivant; } l_liste2 = (*l_liste1).suivant; (*l_liste1).suivant = (*l_liste2).suivant; (*l_liste2).suivant = (*s_etat_processus) .l_base_pile; (*s_etat_processus).l_base_pile = l_liste2; } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_sous_objet) == d_erreur) { return(NULL); } chaine_sauvegarde = chaine; if (strlen(chaine_sauvegarde) == 0) { if ((chaine = (unsigned char *) malloc((strlen( (unsigned char *) (*s_sous_objet).objet) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s", (unsigned char *) (*s_sous_objet).objet); } else { if ((chaine = (unsigned char *) malloc((strlen( chaine_sauvegarde) + 1 + strlen( (unsigned char *) (*s_sous_objet).objet) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s,%s", chaine_sauvegarde, (unsigned char *) (*s_sous_objet) .objet); } free(chaine_sauvegarde); liberation(s_etat_processus, s_sous_objet); } chaine_sauvegarde = chaine; if ((chaine = (unsigned char *) malloc((strlen( (*((struct_fonction *) (*(*l_element_courant) .donnee).objet)).nom_fonction) + 2 + strlen(chaine_sauvegarde) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s(%s)", (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, chaine_sauvegarde); free(chaine_sauvegarde); if ((s_sous_objet = allocation(s_etat_processus, CHN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } (*s_sous_objet).objet = chaine; if (empilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), s_sous_objet) == d_erreur) { return(NULL); } } } } else { if ((s_sous_objet = allocation(s_etat_processus, CHN)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if (((*s_sous_objet).objet = formateur( s_etat_processus, 0, (*l_element_courant).donnee)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if (((*(*l_element_courant).donnee).type == ALG) || (((*(*l_element_courant).donnee).type == NOM) && ((*((struct_nom *) (*(*l_element_courant) .donnee).objet)).symbole == d_vrai))) { chaine_sauvegarde = (unsigned char *) (*s_sous_objet).objet; if (((*s_sous_objet).objet = malloc((strlen( chaine_sauvegarde) - 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } ptrl = chaine_sauvegarde; ptre = (unsigned char *) (*s_sous_objet).objet; for(ptrl++, i = ((integer8) strlen(chaine_sauvegarde)) - 2; i > 0; i--, *ptre++ = *ptrl++); (*ptre) = d_code_fin_chaine; free(chaine_sauvegarde); } else if ((*(*l_element_courant).donnee).type == CHN) { chaine_sauvegarde = (unsigned char *) (*s_sous_objet).objet; if (((*s_sous_objet).objet = malloc((strlen( chaine_sauvegarde) + 3) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf((unsigned char *) (*s_sous_objet).objet, "\"%s\"", chaine_sauvegarde); free(chaine_sauvegarde); } if (empilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), s_sous_objet) == d_erreur) { return(NULL); } } l_element_courant = (*l_element_courant).suivant; } if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), &s_sous_objet) == d_erreur) { return(NULL); } if ((chaine = (unsigned char *) malloc((strlen((unsigned char *) (*s_sous_objet).objet) + 2 + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet); liberation(s_etat_processus, s_sous_objet); } else if ((*s_objet).type == BIN) { /* -------------------------------------------------------------------------------- Entier binaire en base 2, 8, 10 ou 16 -------------------------------------------------------------------------------- */ masque_binaire = masque_entiers_binaires(s_etat_processus); if ((test_cfsf(s_etat_processus, 43) == d_faux) && (test_cfsf(s_etat_processus, 44) == d_faux)) { /* -- Base décimale --------------------------------------------------------------- */ sprintf(tampon, "%llu", (*((unsigned long long *) ((*s_objet).objet))) & masque_binaire); strcpy(base, "d"); } else if ((test_cfsf(s_etat_processus, 43) == d_vrai) && (test_cfsf(s_etat_processus, 44) == d_faux)) { /* -- Base octale ----------------------------------------------------------------- */ sprintf(tampon, "%llo", (*((unsigned long long *) ((*s_objet).objet))) & masque_binaire); strcpy(base, "o"); } else if (test_cfsf(s_etat_processus, 44) == d_vrai) { /* -- Bases hexadécimale et binaire ----------------------------------------------- */ sprintf(tampon, "%llX", (*((unsigned long long *) ((*s_objet).objet))) & masque_binaire); if (test_cfsf(s_etat_processus, 43) == d_vrai) { strcpy(base, "h"); } else { chaine = (unsigned char *) malloc((strlen(tampon) + 1) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, tampon); tampon[0] = 0; for(i = 0; i < (integer8) strlen(chaine); i++) { switch(chaine[i]) { case '0' : { strcat(tampon, (i != 0) ? "0000" : "0"); break; } case '1' : { strcat(tampon, (i != 0) ? "0001" : "1"); break; } case '2' : { strcat(tampon, (i != 0) ? "0010" : "10"); break; } case '3' : { strcat(tampon, (i != 0) ? "0011" : "11"); break; } case '4' : { strcat(tampon, (i != 0) ? "0100" : "100"); break; } case '5' : { strcat(tampon, (i != 0) ? "0101" : "101"); break; } case '6' : { strcat(tampon, (i != 0) ? "0110" : "110"); break; } case '7' : { strcat(tampon, (i != 0) ? "0111" : "111"); break; } case '8' : { strcat(tampon, "1000"); break; } case '9' : { strcat(tampon, "1001"); break; } case 'A' : { strcat(tampon, "1010"); break; } case 'B' : { strcat(tampon, "1011"); break; } case 'C' : { strcat(tampon, "1100"); break; } case 'D' : { strcat(tampon, "1101"); break; } case 'E' : { strcat(tampon, "1110"); break; } case 'F' : { strcat(tampon, "1111"); break; } } } free(chaine); strcpy(base, "b"); } } chaine = (unsigned char *) malloc((strlen(tampon) + 4) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, "# "); strcat(chaine, tampon); strcat(chaine, base); } else if ((*s_objet).type == CHN) { /* -------------------------------------------------------------------------------- Chaîne de caractères -------------------------------------------------------------------------------- */ if (((*s_etat_processus).autorisation_conversion_chaine == 'Y') && (test_cfsf(s_etat_processus, 34) == d_vrai)) { if ((chaine = formateur_flux(s_etat_processus, (unsigned char *) (*s_objet).objet, &longueur_chaine)) == NULL) { return(NULL); } } else { if ((chaine = malloc((strlen((unsigned char *) ((*s_objet).objet)) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, (unsigned char *) ((*s_objet).objet)); } } else if ((*s_objet).type == CPL) { /* -------------------------------------------------------------------------------- Complexe -------------------------------------------------------------------------------- */ chaine_formatee = formateur_nombre(s_etat_processus, ((struct_complexe16 *) ((*s_objet).objet)), 'C'); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_formatee); free(chaine_formatee); } else if ((*s_objet).type == RPN) { /* -------------------------------------------------------------------------------- Définition -------------------------------------------------------------------------------- */ l_element_courant = (struct_liste_chainee *) ((*s_objet).objet); chaine_sauvegarde = chaine; while(l_element_courant != NULL) { if ((chaine_formatee = formateur(s_etat_processus, offset_initial, (*l_element_courant).donnee)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if ((*(*l_element_courant).donnee).type == CHN) { chaine_tampon = chaine_formatee; if ((chaine_formatee = (unsigned char *) malloc((strlen( chaine_tampon) + 3) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine_formatee, "\"%s\"", chaine_tampon); free(chaine_tampon); } l_element_courant = (*l_element_courant).suivant; if (chaine != NULL) { chaine_sauvegarde = chaine; if ((chaine = (unsigned char *) malloc((strlen( chaine_sauvegarde) + strlen(chaine_formatee) + 2) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); strcat(chaine, chaine_formatee); free(chaine_formatee); } else { chaine = chaine_formatee; } } chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine; strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); } else if ((*s_objet).type == INT) { /* -------------------------------------------------------------------------------- Entier -------------------------------------------------------------------------------- */ chaine_formatee = formateur_nombre(s_etat_processus, ((integer8 *) ((*s_objet).objet)), 'I'); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_formatee); free(chaine_formatee); } else if ((*s_objet).type == FCT) { /* -------------------------------------------------------------------------------- Fonction -------------------------------------------------------------------------------- */ chaine = (unsigned char *) malloc((strlen((*((struct_fonction *) ((*s_objet).objet))).nom_fonction) + 1) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, (unsigned char *) (*((struct_fonction *) ((*s_objet).objet))).nom_fonction); } else if ((*s_objet).type == TBL) { /* -------------------------------------------------------------------------------- Tableau -------------------------------------------------------------------------------- */ chaine = (unsigned char *) malloc(4 * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, "<[ "); offset = ((integer8) strlen(chaine)) + offset_initial; for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) .nombre_elements; i++) { chaine_sauvegarde = chaine; chaine_formatee = formateur(s_etat_processus, (long) offset, (*((struct_tableau *) (*s_objet).objet)).elements[i]); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if ((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) .type == CHN) { chaine = (unsigned char *) malloc((strlen(chaine_formatee) + strlen(chaine_sauvegarde) + 3) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, "\""); strcat(chaine, chaine_formatee); free(chaine_formatee); strcat(chaine, "\""); } else if ((*(*((struct_tableau *) (*s_objet).objet)) .elements[i]).type == CHN) { chaine = (unsigned char *) malloc((strlen(chaine_formatee) + strlen(chaine_sauvegarde) + 1) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee); free(chaine_sauvegarde); free(chaine_formatee); } else { chaine = (unsigned char *) malloc((strlen(chaine_formatee) + strlen(chaine_sauvegarde) + 1) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee); free(chaine_sauvegarde); free(chaine_formatee); } if (test_cfsf(s_etat_processus, 45) == d_vrai) { chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, "\n"); if ((*((struct_tableau *) (*s_objet).objet)) .nombre_elements != (i + 1)) { chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 1 + ((size_t) offset)) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); ptre = &(chaine[strlen(chaine)]); for(k = 0; k < offset; k++, *(ptre++) = ' '); (*ptre) = d_code_fin_chaine; } } else { if ((*((struct_tableau *) (*s_objet).objet)) .nombre_elements != (i + 1)) { chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); } } } if (test_cfsf(s_etat_processus, 45) == d_vrai) { if (chaine[strlen(chaine) - 1] == '\n') { chaine[strlen(chaine) - 1] = d_code_fin_chaine; } } if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements != 0) { chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]>"); } else { chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, "]>"); } } else if ((*s_objet).type == LST) { /* -------------------------------------------------------------------------------- Liste -------------------------------------------------------------------------------- */ chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, "{ "); l_element_courant = (struct_liste_chainee *) ((*s_objet).objet); nombre_elements = 0; offset = ((integer8) strlen(chaine)) + offset_initial; while(l_element_courant != NULL) { chaine_sauvegarde = chaine; chaine_formatee = formateur(s_etat_processus, (long) offset, (*l_element_courant).donnee); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if ((*(*l_element_courant).donnee).type == CHN) { chaine = (unsigned char *) malloc((strlen(chaine_formatee) + strlen(chaine_sauvegarde) + 3) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, "\""); strcat(chaine, chaine_formatee); free(chaine_formatee); strcat(chaine, "\""); } else if ((*(*l_element_courant).donnee).type == NOM) { chaine = (unsigned char *) malloc((strlen(chaine_formatee) + strlen(chaine_sauvegarde) + 1) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee); free(chaine_sauvegarde); free(chaine_formatee); } else { chaine = (unsigned char *) malloc((strlen(chaine_formatee) + strlen(chaine_sauvegarde) + 1) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee); free(chaine_sauvegarde); free(chaine_formatee); } if (test_cfsf(s_etat_processus, 45) == d_vrai) { chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, "\n"); if ((*l_element_courant).suivant != NULL) { chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 1 + ((size_t) offset)) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); ptre = &(chaine[strlen(chaine)]); for(k = 0; k < offset; k++, *(ptre++) = ' '); (*ptre) = d_code_fin_chaine; } } else { if ((*l_element_courant).suivant != NULL) { chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); } } nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (test_cfsf(s_etat_processus, 45) == d_vrai) { if (chaine[strlen(chaine) - 1] == '\n') { chaine[strlen(chaine) - 1] = d_code_fin_chaine; } } if (nombre_elements != 0) { chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " }"); } else { chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, "}"); } } else if ((*s_objet).type == MCX) { /* -------------------------------------------------------------------------------- Matrice complexe -------------------------------------------------------------------------------- */ nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) .nombre_lignes; nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) .nombre_colonnes; chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); if (chaine != NULL) { strcpy(chaine, "[["); offset = ((integer8) strlen(chaine)) + offset_initial - 1; if ((longueurs_maximales = malloc(sizeof(integer8) * 2 * ((size_t) nombre_colonnes))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if (test_cfsf(s_etat_processus, 45) == d_vrai) { for(j = 0; j < (2 * nombre_colonnes); j++) { longueurs_maximales[j] = 0; } for(i = 0; i < nombre_lignes; i++) { for(j = 0; j < nombre_colonnes; j++) { chaine_formatee = formateur_nombre(s_etat_processus, &(((struct_complexe16 **) ((*((struct_matrice *) ((*s_objet).objet))).tableau))[i][j]), 'C'); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } longueur_courante = (integer8) strlen(chaine_formatee); longueur_decimale_courante = 0; if ((ptrl = index(chaine_formatee, (test_cfsf(s_etat_processus, 48) == d_vrai) ? '.' : ',')) != NULL) { longueur_decimale_courante = longueur_courante - (ptrl - chaine_formatee); longueur_courante = ptrl - chaine_formatee; } free(chaine_formatee); if (longueurs_maximales[2 * j] < longueur_courante) { longueurs_maximales[2 * j] = longueur_courante; } if (longueurs_maximales[(2 * j) + 1] < longueur_decimale_courante) { longueurs_maximales[(2 * j) + 1] = longueur_decimale_courante; } } } } for(i = 0; i < nombre_lignes; i++) { for(j = 0; j < nombre_colonnes; j++) { chaine_formatee = formateur_nombre(s_etat_processus, &(((struct_complexe16 **) ((*((struct_matrice *) ((*s_objet).objet))).tableau))[i][j]), 'C'); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } longueur_courante = (integer8) strlen(chaine_formatee); longueur_decimale_courante = 0; if ((ptrl = index(chaine_formatee, (test_cfsf(s_etat_processus, 48) == d_vrai) ? '.' : ',')) != NULL) { longueur_decimale_courante = longueur_courante - (ptrl - chaine_formatee); longueur_courante = ptrl - chaine_formatee; } chaine_sauvegarde = chaine; if (test_cfsf(s_etat_processus, 45) == d_vrai) { chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + ((size_t) longueur_courante) + ((size_t) longueur_decimale_courante) + ((size_t) longueurs_maximales[2 * j]) + ((size_t) longueurs_maximales[(2 * j) + 1]) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); ptre = &(chaine[strlen(chaine)]); for (k = 0; k < (longueurs_maximales[2 * j] - longueur_courante); k++, *(ptre++) = ' '); (*ptre) = d_code_fin_chaine; strcat(chaine, chaine_formatee); ptre = &(chaine[strlen(chaine)]); for(k = 0; k < (longueurs_maximales[(2 * j) + 1] - longueur_decimale_courante); k++, *(ptre++) = ' '); (*ptre) = d_code_fin_chaine; } else { chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + ((size_t) longueur_courante) + ((size_t) longueur_decimale_courante) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); strcat(chaine, chaine_formatee); } free(chaine_formatee); } chaine_sauvegarde = chaine; if (i != (nombre_lignes - 1)) { if (test_cfsf(s_etat_processus, 45) == d_vrai) { chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 5 + ((size_t) offset)) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]\n"); ptre = &(chaine[strlen(chaine)]); for(k = 0; k < offset; k++, *(ptre++) = ' '); (*ptre) = d_code_fin_chaine; strcat(chaine, "["); } else { chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 4) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]["); } } } free(longueurs_maximales); chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]]"); } } else if ((*s_objet).type == MIN) { /* -------------------------------------------------------------------------------- Matrice entière -------------------------------------------------------------------------------- */ nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) .nombre_lignes; nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) .nombre_colonnes; chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); if (chaine != NULL) { strcpy(chaine, "[["); offset = ((integer8) strlen(chaine)) + offset_initial - 1; if ((longueurs_maximales = malloc(sizeof(integer8) * ((size_t) nombre_colonnes))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if (test_cfsf(s_etat_processus, 45) == d_vrai) { for(j = 0; j < nombre_colonnes; j++) { longueurs_maximales[j] = 0; } for(i = 0; i < nombre_lignes; i++) { for(j = 0; j < nombre_colonnes; j++) { chaine_formatee = formateur_nombre(s_etat_processus, &(((integer8 **) ((*((struct_matrice *) ((*s_objet).objet))).tableau))[i][j]), 'I'); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } longueur_courante = (integer8) strlen(chaine_formatee); free(chaine_formatee); if (longueurs_maximales[j] < longueur_courante) { longueurs_maximales[j] = longueur_courante; } } } } for(i = 0; i < nombre_lignes; i++) { for(j = 0; j < nombre_colonnes; j++) { chaine_formatee = formateur_nombre(s_etat_processus, &(((integer8 **) ((*((struct_matrice *) ((*s_objet).objet))).tableau))[i][j]), 'I'); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } longueur_courante = (integer8) strlen(chaine_formatee); chaine_sauvegarde = chaine; if (test_cfsf(s_etat_processus, 45) == d_vrai) { chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + ((size_t) longueur_courante) + ((size_t) longueurs_maximales[j]) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); ptre = &(chaine[strlen(chaine)]); for(k = 0; k < (longueurs_maximales[j] - longueur_courante); k++, *(ptre++) = ' '); (*ptre) = d_code_fin_chaine; } else { chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + ((size_t) longueur_courante) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); } strcat(chaine, chaine_formatee); free(chaine_formatee); } chaine_sauvegarde = chaine; if (i != (nombre_lignes - 1)) { if (test_cfsf(s_etat_processus, 45) == d_vrai) { chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 5 + ((size_t) offset)) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]\n"); ptre = &(chaine[strlen(chaine)]); for(k = 0; k < offset; k++, *(ptre++) = ' '); (*ptre) = d_code_fin_chaine; strcat(chaine, "["); } else { chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 4) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]["); } } } free(longueurs_maximales); chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]]"); } } else if ((*s_objet).type == MRL) { /* -------------------------------------------------------------------------------- Matrice réelle -------------------------------------------------------------------------------- */ nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) .nombre_lignes; nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) .nombre_colonnes; chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); if (chaine != NULL) { strcpy(chaine, "[["); offset = ((integer8) strlen(chaine)) + offset_initial - 1; if ((longueurs_maximales = malloc(sizeof(integer8) * 2 * ((size_t) nombre_colonnes))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if (test_cfsf(s_etat_processus, 45) == d_vrai) { for(j = 0; j < (2 * nombre_colonnes); j++) { longueurs_maximales[j] = 0; } for(i = 0; i < nombre_lignes; i++) { for(j = 0; j < nombre_colonnes; j++) { chaine_formatee = formateur_nombre(s_etat_processus, &(((real8 **) ((*((struct_matrice *) ((*s_objet).objet))).tableau))[i][j]), 'R'); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } longueur_courante = (integer8) strlen(chaine_formatee); longueur_decimale_courante = 0; if ((ptrl = index(chaine_formatee, (test_cfsf(s_etat_processus, 48) == d_vrai) ? ',' : '.')) != NULL) { longueur_decimale_courante = longueur_courante - (ptrl - chaine_formatee); longueur_courante = ptrl - chaine_formatee; } free(chaine_formatee); if (longueurs_maximales[2 * j] < longueur_courante) { longueurs_maximales[2 * j] = longueur_courante; } if (longueurs_maximales[(2 * j) + 1] < longueur_decimale_courante) { longueurs_maximales[(2 * j) + 1] = longueur_decimale_courante; } } } } for(i = 0; i < nombre_lignes; i++) { for(j = 0; j < nombre_colonnes; j++) { chaine_formatee = formateur_nombre(s_etat_processus, &(((real8 **) ((*((struct_matrice *) ((*s_objet).objet))).tableau))[i][j]), 'R'); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } longueur_courante = (integer8) strlen(chaine_formatee); longueur_decimale_courante = 0; if ((ptrl = index(chaine_formatee, (test_cfsf(s_etat_processus, 48) == d_vrai) ? ',' : '.')) != NULL) { longueur_decimale_courante = longueur_courante - (ptrl - chaine_formatee); longueur_courante = ptrl - chaine_formatee; } chaine_sauvegarde = chaine; if (test_cfsf(s_etat_processus, 45) == d_vrai) { chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + ((size_t) longueur_courante) + ((size_t) longueur_decimale_courante) + ((size_t) longueurs_maximales[2 * j]) + ((size_t) longueurs_maximales[(2 * j) + 1]) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); ptre = &(chaine[strlen(chaine)]); for(k = 0; k < (longueurs_maximales[2 * j] - longueur_courante); k++, *(ptre++) = ' '); (*ptre) = d_code_fin_chaine; strcat(chaine, chaine_formatee); ptre = &(chaine[strlen(chaine)]); for(k = 0; k < (longueurs_maximales[(2 * j) + 1] - longueur_decimale_courante); k++, *(ptre++) = ' '); (*ptre) = d_code_fin_chaine; } else { chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + ((size_t) longueur_courante) + ((size_t) longueur_decimale_courante) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); strcat(chaine, chaine_formatee); } free(chaine_formatee); } chaine_sauvegarde = chaine; if (i != (nombre_lignes - 1)) { if (test_cfsf(s_etat_processus, 45) == d_vrai) { chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 5 + ((size_t) offset)) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]\n"); ptre = &(chaine[strlen(chaine)]); for(k = 0; k < offset; k++, *(ptre++) = ' '); (*ptre) = d_code_fin_chaine; strcat(chaine, "["); } else { chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 4) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]["); } } } free(longueurs_maximales); chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]]"); } } else if ((*s_objet).type == MTX) { if (alsprintf(s_etat_processus, &chaine, "Mutex $ %016llX owned by $ %016llX", &((*((struct_mutex *) (*s_objet).objet)).mutex), (logical8) (*((struct_mutex *) (*s_objet).objet)).tid) < 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } } else if ((*s_objet).type == NOM) { /* -------------------------------------------------------------------------------- Nom -------------------------------------------------------------------------------- */ if ((*((struct_nom *) (*s_objet).objet)).symbole == d_vrai) { chaine = (unsigned char *) malloc((strlen((*((struct_nom *) (*s_objet).objet)).nom) + 3) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom); } else { chaine = (unsigned char *) malloc((strlen((*((struct_nom *) (*s_objet).objet)).nom) + 1) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s", (*((struct_nom *) (*s_objet).objet)).nom); } } else if ((*s_objet).type == REL) { /* -------------------------------------------------------------------------------- Réel -------------------------------------------------------------------------------- */ chaine_formatee = formateur_nombre(s_etat_processus, ((real8 *) ((*s_objet).objet)), 'R'); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_formatee); free(chaine_formatee); } else if ((*s_objet).type == VCX) { /* -------------------------------------------------------------------------------- Vecteur complexe -------------------------------------------------------------------------------- */ nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) .taille; chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); if (chaine != NULL) { strcpy(chaine, "["); for(i = 0; i < nombre_colonnes; i++) { chaine_formatee = formateur_nombre(s_etat_processus, &(((struct_complexe16 *) ((*((struct_vecteur *) ((*s_objet).objet))).tableau))[i]), 'C'); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + strlen(chaine_formatee) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); strcat(chaine, chaine_formatee); free(chaine_formatee); } chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 3) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]"); } } else if ((*s_objet).type == VIN) { /* -------------------------------------------------------------------------------- Vecteur entier -------------------------------------------------------------------------------- */ nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) .taille; chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); if (chaine != NULL) { strcpy(chaine, "["); for(i = 0; i < nombre_colonnes; i++) { chaine_formatee = formateur_nombre(s_etat_processus, &(((integer8 *) ((*((struct_vecteur *) ((*s_objet).objet))).tableau))[i]), 'I'); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + strlen(chaine_formatee) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); strcat(chaine, chaine_formatee); free(chaine_formatee); } chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 3) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]"); } } else if ((*s_objet).type == VRL) { /* -------------------------------------------------------------------------------- Vecteur réel -------------------------------------------------------------------------------- */ nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) .taille; chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); if (chaine != NULL) { strcpy(chaine, "["); for(i = 0; i < nombre_colonnes; i++) { chaine_formatee = formateur_nombre(s_etat_processus, &(((real8 *) ((*((struct_vecteur *) ((*s_objet).objet))).tableau))[i]), 'R'); if (chaine_formatee == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + strlen(chaine_formatee) + 2) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); strcat(chaine, chaine_formatee); free(chaine_formatee); } chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 3) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]"); } } else if ((*s_objet).type == REC) { chaine = (unsigned char *) malloc(4 * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, "|[ "); offset = ((integer8) strlen(chaine)) + offset_initial; // L'objet se compose de deux tables à une dimension de // mêmes tailles. chaine_sauvegarde = chaine; if ((chaine_formatee = formateur(s_etat_processus, (long) offset, (*((struct_record *) (*s_objet).objet)).noms)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if ((chaine = (unsigned char *) malloc((strlen(chaine_formatee) + strlen(chaine_sauvegarde) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee); free(chaine_sauvegarde); free(chaine_formatee); if (test_cfsf(s_etat_processus, 45) == d_vrai) { chaine_sauvegarde = chaine; if ((chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 2) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, "\n"); chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 1 + ((size_t) offset)) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); ptre = &(chaine[strlen(chaine)]); for(k = 0; k < offset; k++, *(ptre++) = ' '); (*ptre) = d_code_fin_chaine; } else { chaine_sauvegarde = chaine; if ((chaine = (unsigned char *) malloc( (strlen(chaine_sauvegarde) + 2) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); } chaine_sauvegarde = chaine; if ((chaine_formatee = formateur(s_etat_processus, (long) offset, (*((struct_record *) (*s_objet).objet)).donnees)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if ((chaine = (unsigned char *) malloc((strlen(chaine_formatee) + strlen(chaine_sauvegarde) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee); free(chaine_sauvegarde); free(chaine_formatee); chaine_sauvegarde = chaine; chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " ]|"); } else if ((*s_objet).type == NON) { if ((chaine = malloc((strlen("System object") + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, "System object"); } else if ((*s_objet).type == EXT) { l_element_courant = (*s_etat_processus).s_bibliotheques; while(l_element_courant != NULL) { if ((*((struct_bibliotheque *) (*l_element_courant).donnee)) .descripteur == (*s_objet).descripteur_bibliotheque) { if ((__type_disp = dlsym((*s_objet).descripteur_bibliotheque, "__type_disp")) == NULL) { // Symbole externe non affichable if ((chaine = malloc((strlen( "External symbol (disp function not found)") + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, "External symbol (disp function not found)"); } else { // Symbole externe affichable void **arg; arg = (void **) &s_objet; __type_disp(s_etat_processus, arg); chaine = (unsigned char *) (*arg); } break; } l_element_courant = (*l_element_courant).suivant; } if (l_element_courant == NULL) { // Symbole externe non affichable if ((chaine = malloc((strlen("External symbol") + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, "External symbol"); } } else { BUG(1, uprintf("Unknown symbol type\n")); } return(chaine); } /* ================================================================================ Routines qui transforment un nombre entier, réel ou complexe en chaîne de caractères suivant le format courant ================================================================================ Entrées : pointeur générique sur la donnée numérique à convertir, type de l'entité (I, R ou C). -------------------------------------------------------------------------------- Sorties : chaîne de caractères allouée dans la routine -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ /* -------------------------------------------------------------------------------- Formatage des complexes, réels et entiers -------------------------------------------------------------------------------- */ unsigned char * formateur_nombre(struct_processus *s_etat_processus, void *valeur_numerique, unsigned char type) { unsigned char *chaine; unsigned char *construction_chaine; unsigned char *sauvegarde; unsigned char *tampon; chaine = NULL; switch(type) { case 'C' : { construction_chaine = (unsigned char *) malloc( 2 * sizeof(unsigned char)); if (construction_chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(construction_chaine, "("); tampon = formateur_reel(s_etat_processus, &((*((struct_complexe16 *) valeur_numerique)).partie_reelle), 'R'); if (tampon == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sauvegarde = construction_chaine; construction_chaine = (unsigned char *) malloc( (strlen(sauvegarde) + strlen(tampon) + 2) * sizeof(unsigned char)); if (construction_chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(construction_chaine, sauvegarde); free(sauvegarde); strcat(construction_chaine, tampon); free(tampon); if (test_cfsf(s_etat_processus, 48) == d_faux) { strcat(construction_chaine, ","); } else { strcat(construction_chaine, "."); } tampon = formateur_reel(s_etat_processus, &((*((struct_complexe16 *) valeur_numerique)).partie_imaginaire), 'R'); if (tampon == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } sauvegarde = construction_chaine; construction_chaine = (unsigned char *) malloc( (strlen(sauvegarde) + strlen(tampon) + 2) * sizeof(unsigned char)); if (construction_chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(construction_chaine, sauvegarde); free(sauvegarde); strcat(construction_chaine, tampon); free(tampon); strcat(construction_chaine, ")"); chaine = construction_chaine; break; } case 'R' : { chaine = formateur_reel(s_etat_processus, valeur_numerique, 'R'); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } break; } default : case 'I' : { chaine = formateur_reel(s_etat_processus, valeur_numerique, 'I'); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } break; } } return(chaine); } /* -------------------------------------------------------------------------------- Formateur des réels et entiers -------------------------------------------------------------------------------- */ unsigned char * formateur_reel(struct_processus *s_etat_processus, void *valeur_numerique, unsigned char type) { real8 mantisse; real8 tampon_reel; integer8 tampon_entier; logical1 i49; logical1 i50; long correction; long dernier_chiffre_significatif; long exposant; long i; long j; long longueur_utile; long longueur_utile_limite; unsigned char *chaine; unsigned char format[32 + 1]; unsigned char mode[3 + 1]; unsigned char *ptr; unsigned char tampon[32 + 1]; chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if (type == 'R') { # ifdef FP_INFINITE int signe; if ((signe = isinf((*((real8 *) valeur_numerique)))) != 0) { if (signe > 0) { strcpy(chaine, "infinity"); } else { strcpy(chaine, "-infinity"); } return(chaine); } # endif if (isnan((*((real8 *) valeur_numerique)))) { strcpy(chaine, "undef"); return(chaine); } tampon_reel = *((real8 *) valeur_numerique); if (tampon_reel > ((real8) 0)) { exposant = (long) floor(log10(tampon_reel)); } else if (tampon_reel < ((real8) 0)) { exposant = (long) floor(log10(-tampon_reel)); } else { exposant = 0; } mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant); } else { tampon_entier = *((integer8 *) valeur_numerique); if (tampon_entier > ((integer8) 0)) { exposant = (long) floor(log10((double) tampon_entier)); } else if (tampon_entier < ((integer8) 0)) { if (tampon_entier != INT64_MIN) { exposant = (long) floor(log10((double) -tampon_entier)); } else { tampon_reel = (real8) tampon_entier; exposant = (long) floor(log10(-tampon_reel)); } } else { exposant = 0; } mantisse = ((real8) (*((integer8 *) valeur_numerique))) / pow(10, (double) exposant); } longueur_utile = 0; j = 1; for(i = 53; i <= 56; i++) { longueur_utile += (test_cfsf(s_etat_processus, (unsigned char) i) == d_vrai) ? j : 0; j *= 2; } longueur_utile_limite = 15; if (longueur_utile > longueur_utile_limite) { longueur_utile = longueur_utile_limite; } i49 = test_cfsf(s_etat_processus, 49); i50 = test_cfsf(s_etat_processus, 50); if (i49 == d_faux) { if (i50 == d_faux) { /* -------------------------------------------------------------------------------- Mode standard -------------------------------------------------------------------------------- */ strcpy(mode, "STD"); } else { /* -------------------------------------------------------------------------------- Mode scientifique -------------------------------------------------------------------------------- */ strcpy(mode, "SCI"); } } else { if (i50 == d_faux) { /* -------------------------------------------------------------------------------- Mode fixe -------------------------------------------------------------------------------- */ strcpy(mode, "FIX"); } else { /* -------------------------------------------------------------------------------- Mode ingénieur -------------------------------------------------------------------------------- */ strcpy(mode, "ENG"); } } // Test portant sur le nombre de chiffres significatifs dans // le cas du format STD pour que 1.2E-15 apparaisse en notation // SCI car il y a une perte de précision dans l'affichage. if ((strcmp(mode, "STD") == 0) && (type == 'R')) { if (abs(*((real8 *) valeur_numerique)) < 1) { dernier_chiffre_significatif = -exposant; sprintf(tampon, ".%f", mantisse); ptr = &(tampon[strlen(tampon) - 1]); while((*ptr) != '.') { if ((*ptr) != '0') { dernier_chiffre_significatif++; } ptr--; } } else { dernier_chiffre_significatif = 0; } } else { dernier_chiffre_significatif = 0; } if ((strcmp(mode, "SCI") == 0) || ((strcmp(mode, "STD") == 0) && ((exposant > longueur_utile_limite) || (dernier_chiffre_significatif > 15) || (exposant < -longueur_utile_limite))) || ((strcmp(mode, "FIX") == 0) && ((exposant >= longueur_utile_limite) || (exposant < -longueur_utile)))) { chaine[0] = d_code_fin_chaine; format[0] = d_code_fin_chaine; if (strcmp(mode, "STD") == 0) { longueur_utile = longueur_utile_limite - 1; } sprintf(format, "%%.%luf", longueur_utile); sprintf(tampon, format, mantisse); strcpy(chaine, tampon); if (strcmp(mode, "STD") == 0) { ptr = &(chaine[strlen(chaine) - 1]); while(((*ptr) == '0') || ((*ptr) == '.')) { (*ptr) = d_code_fin_chaine; ptr--; } } strcat(chaine, "E"); sprintf(tampon, "%ld", exposant); strcat(chaine, tampon); } else if (strcmp(mode, "FIX") == 0) { chaine[0] = d_code_fin_chaine; format[0] = d_code_fin_chaine; if (longueur_utile + exposant >= longueur_utile_limite) { longueur_utile = longueur_utile_limite - (exposant + 1); } sprintf(format, "%%.%luf", longueur_utile); sprintf(tampon, format, (mantisse * pow(10, (double) exposant))); strcpy(chaine, tampon); } else if (strcmp(mode, "ENG") == 0) { chaine[0] = d_code_fin_chaine; format[0] = d_code_fin_chaine; correction = labs(exposant) % 3; if (exposant < 0) { if (correction == 0) { correction = 3; } correction = 3 - correction; } longueur_utile -= correction; sprintf(format, "%%.%luf", longueur_utile); sprintf(tampon, format, (mantisse * pow(10, (double) correction))); strcpy(chaine, tampon); strcat(chaine, "E"); sprintf(tampon, "%ld", (exposant - correction)); strcat(chaine, tampon); } else { if (type == 'I') { chaine[0] = d_code_fin_chaine; sprintf(tampon, "%lld", *((integer8 *) valeur_numerique)); } else { chaine[0] = d_code_fin_chaine; format[0] = d_code_fin_chaine; if (exposant >= 0) { if ((exposant + 1) < longueur_utile_limite) { sprintf(format, "%%.%luf", (longueur_utile_limite - exposant - 1)); } else { strcpy(format, "%.0f."); } } else { sprintf(format, "%%.%luf", longueur_utile_limite); } sprintf(tampon, format, *((real8 *) valeur_numerique)); i = ((long) strlen(tampon)) - 1; while(tampon[i] == '0') { tampon[i] = d_code_fin_chaine; i--; } if (ds_imposition_separateur_decimal == d_faux) { i = ((long) strlen(tampon)) - 1; if (tampon[i] == '.') { tampon[i] = d_code_fin_chaine; } } } strcpy(chaine, tampon); } if (test_cfsf(s_etat_processus, 48) == d_vrai) { for(i = 0; i < (long) strlen(chaine); i++) { if (chaine[i] == '.') { chaine[i] = ','; } } } return(chaine); } // vim: ts=4