[BACK]Return to formateur.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/formateur.c between versions 1.1.1.1 and 1.25

version 1.1.1.1, 2010/01/26 15:22:44 version 1.25, 2011/04/11 12:10:05
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.9    RPL/2 (R) version 4.1.0.prerelease.0
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2011 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 67  formateur(struct_processus *s_etat_proce Line 67  formateur(struct_processus *s_etat_proce
     unsigned char               *format_majuscule;      unsigned char               *format_majuscule;
     unsigned char               *ptre;      unsigned char               *ptre;
     unsigned char               *ptrl;      unsigned char               *ptrl;
       unsigned char               *ptr_ecriture;
       unsigned char               *ptr_lecture;
     unsigned char               *registre;      unsigned char               *registre;
     unsigned char               tampon[1024 + 1];      unsigned char               tampon[1024 + 1];
   
Line 104  formateur(struct_processus *s_etat_proce Line 106  formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
         sprintf(tampon, "%016lX", (*((unsigned long *) ((*s_objet).objet))));          if (alsprintf(&chaine, "@ %016lX", (*((unsigned long *)
                   ((*s_objet).objet)))) < 0)
         chaine = (unsigned char *) malloc((strlen(tampon) + 3)  
                 * sizeof(unsigned char));  
   
         if (chaine == NULL)  
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(NULL);              return(NULL);
         }          }
   
         strcpy(chaine, "@ ");  
         strcat(chaine, tampon);  
     }      }
     else if ((*s_objet).type == SLB)      else if ((*s_objet).type == SLB)
     {      {
Line 127  formateur(struct_processus *s_etat_proce Line 122  formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
         sprintf(tampon, " %016lX", (unsigned long) (*((struct_bibliotheque *)          if (alsprintf(&chaine, "Library $ %016lX [%s]",
                 (*s_objet).objet)).descripteur);                  (unsigned long) (*((struct_bibliotheque *)
                   (*s_objet).objet)).descripteur, (*((struct_bibliotheque *)
         chaine = (unsigned char *) malloc((strlen(tampon) + 10)                  (*s_objet).objet)).nom) < 0)
                 * sizeof(unsigned char));  
   
         if (chaine == NULL)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
             return(NULL);  
         }  
   
         strcpy(chaine, "Library $");  
         strcat(chaine, tampon);  
   
         registre = chaine;  
   
         if ((chaine = malloc((strlen(registre) + 2 +  
                 strlen((*(struct_bibliotheque *) ((*s_objet).objet)).nom)  
                 + 2) * sizeof(unsigned char))) == NULL)  
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(NULL);              return(NULL);
         }          }
   
         sprintf(chaine, "%s [%s]", registre, (*((struct_bibliotheque *)  
                     (*s_objet).objet)).nom);  
         free(registre);  
     }      }
     else if ((*s_objet).type == SPH)      else if ((*s_objet).type == SPH)
     {      {
Line 165  formateur(struct_processus *s_etat_proce Line 140  formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
         sprintf(tampon, "%016lX", (unsigned long)          if (alsprintf(&chaine, "Semaphore $ %016lX '%s'",
                 &((*((struct_semaphore *) (*s_objet).objet)).semaphore));                  &((*((struct_semaphore *) (*s_objet).objet)).semaphore),
                   (*((struct_semaphore *) (*s_objet).objet)).nom) < 0)
         chaine = (unsigned char *) malloc((strlen(tampon) + 15 +  
                 strlen((*((struct_semaphore *) (*s_objet).objet)).nom))  
                 * sizeof(unsigned char));  
   
         if (chaine == NULL)  
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(NULL);              return(NULL);
         }          }
   
         sprintf(chaine, "Semaphore $%s '%s'", tampon,  
                 (*((struct_semaphore *) (*s_objet).objet)).nom);  
     }      }
     else if ((*s_objet).type == SQL)      else if ((*s_objet).type == SQL)
     {      {
Line 194  formateur(struct_processus *s_etat_proce Line 161  formateur(struct_processus *s_etat_proce
                 "MYSQL") == 0)                  "MYSQL") == 0)
         {          {
 #           ifdef MYSQL_SUPPORT  #           ifdef MYSQL_SUPPORT
             sprintf(tampon, "Sql $%016lX (%s)",              if (alsprintf(&chaine, "Sql $ %016lX (%s)",
                     (long unsigned int) (*((struct_connecteur_sql *)                      (long unsigned int) (*((struct_connecteur_sql *)
                     (*s_objet).objet)).descripteur.mysql,                      (*s_objet).objet)).descripteur.mysql,
                     (*((struct_connecteur_sql *) (*s_objet).objet)).type);                      (*((struct_connecteur_sql *) (*s_objet).objet)).type) < 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
 #           else  #           else
             if ((*s_etat_processus).langue == 'F')              if ((*s_etat_processus).langue == 'F')
             {              {
Line 217  formateur(struct_processus *s_etat_proce Line 188  formateur(struct_processus *s_etat_proce
                 "POSTGRESQL") == 0)                  "POSTGRESQL") == 0)
         {          {
 #           ifdef POSTGRESQL_SUPPORT  #           ifdef POSTGRESQL_SUPPORT
             sprintf(tampon, "Sql $%016lX [ %s ]",              if (alsprintf(&chaine, "Sql $ %016lX (%s)",
                     (long unsigned int) (*((struct_connecteur_sql *)                      (long unsigned int) (*((struct_connecteur_sql *)
                     (*s_objet).objet)).descripteur.postgresql,                      (*s_objet).objet)).descripteur.postgresql,
                     (*((struct_connecteur_sql *) (*s_objet).objet)).type);                      (*((struct_connecteur_sql *) (*s_objet).objet)).type) < 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
 #           else  #           else
             if ((*s_etat_processus).langue == 'F')              if ((*s_etat_processus).langue == 'F')
             {              {
Line 242  formateur(struct_processus *s_etat_proce Line 217  formateur(struct_processus *s_etat_proce
                     (*((struct_connecteur_sql *) (*s_objet).objet))                      (*((struct_connecteur_sql *) (*s_objet).objet))
                     .type));                      .type));
         }          }
   
         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);  
     }      }
     else if ((*s_objet).type == PRC)      else if ((*s_objet).type == PRC)
     {      {
Line 266  formateur(struct_processus *s_etat_proce Line 230  formateur(struct_processus *s_etat_proce
         if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)          if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
                 .processus_detache == d_vrai)                  .processus_detache == d_vrai)
         {          {
             sprintf(tampon, " %016lX", (unsigned long)              if (alsprintf(&chaine, "Process $ %016lX", (unsigned long)
                     (*(*((struct_processus_fils *) (*s_objet).objet)).thread)                      (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
                     .pid);                      .pid) < 0)
   
             chaine = (unsigned char *) malloc((strlen(tampon) + 10)  
                     * sizeof(unsigned char));  
   
             if (chaine == NULL)  
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(NULL);                  return(NULL);
             }              }
   
             strcpy(chaine, "Process $");  
             strcat(chaine, tampon);  
         }          }
         else          else
         {          {
             sprintf(tampon, " %016lX/%016lX",              if (alsprintf(&chaine, "Light weight process $ %016lX/%016lX",
                     (unsigned long) (*(*((struct_processus_fils *)                      (unsigned long) (*(*((struct_processus_fils *)
                     (*s_objet).objet)).thread).pid,                      (*s_objet).objet)).thread).pid,
                     (unsigned long) (*(*((struct_processus_fils *)                      (unsigned long) (*(*((struct_processus_fils *)
                     (*s_objet).objet)).thread).tid);                      (*s_objet).objet)).thread).tid) < 0)
   
             chaine = (unsigned char *) malloc((strlen(tampon) + 23)  
                     * sizeof(unsigned char));  
   
             if (chaine == NULL)  
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(NULL);                  return(NULL);
             }              }
   
             strcpy(chaine, "Light weight process $");  
             strcat(chaine, tampon);  
         }          }
     }      }
     else if ((*s_objet).type == FCH)      else if ((*s_objet).type == FCH)
Line 312  formateur(struct_processus *s_etat_proce Line 260  formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
         sprintf(tampon, " %016lX", (unsigned long) (*((struct_fichier *)          if (alsprintf(&chaine, "File $ %016lX", (unsigned long)
                 ((*s_objet).objet))).descripteur);                  (*((struct_fichier *) ((*s_objet).objet))).descripteur) < 0)
   
         chaine = (unsigned char *) malloc((strlen(tampon) + 7)  
                 * sizeof(unsigned char));  
   
         if (chaine == NULL)  
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(NULL);              return(NULL);
         }          }
   
         strcpy(chaine, "File $");  
         strcat(chaine, tampon);  
   
         registre45 = test_cfsf(s_etat_processus, 45);          registre45 = test_cfsf(s_etat_processus, 45);
         cf(s_etat_processus, 45);          cf(s_etat_processus, 45);
   
Line 452  formateur(struct_processus *s_etat_proce Line 392  formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
         sprintf(tampon, " %016lX", (unsigned long) (*((struct_socket *)          if (alsprintf(&chaine, "Socket $ %016lX",
                 ((*s_objet).objet))).socket);                  (unsigned long) (*((struct_socket *)
                   ((*s_objet).objet))).socket) < 0)
         chaine = (unsigned char *) malloc((strlen(tampon) + 9)  
                 * sizeof(unsigned char));  
   
         if (chaine == NULL)  
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(NULL);              return(NULL);
         }          }
   
         strcpy(chaine, "Socket $");  
         strcat(chaine, tampon);  
   
         registre45 = test_cfsf(s_etat_processus, 45);          registre45 = test_cfsf(s_etat_processus, 45);
         cf(s_etat_processus, 45);          cf(s_etat_processus, 45);
   
Line 1819  formateur(struct_processus *s_etat_proce Line 1752  formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
         chaine = (unsigned char *) malloc((strlen((unsigned char *)          if ((chaine = malloc((strlen((unsigned char *)
                 ((*s_objet).objet)) + 1) * sizeof(unsigned char));                  ((*s_objet).objet)) + 1) * sizeof(unsigned char))) == NULL)
   
         if (chaine == NULL)  
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(NULL);              return(NULL);
         }          }
   
         strcpy(chaine, (unsigned char *) ((*s_objet).objet));          if (((*s_etat_processus).autorisation_conversion_chaine == 'Y') &&
                   (test_cfsf(s_etat_processus, 34) == d_vrai))
           {
               ptr_lecture = (unsigned char *) (*s_objet).objet;
               ptr_ecriture = chaine;
   
               while((*ptr_lecture) != d_code_fin_chaine)
               {
                   (*ptr_ecriture) = (*ptr_lecture);
   
                   // Début de la séquence d'échappement
   
                   if ((*ptr_lecture) == '\\')
                   {
                       if ((*(ptr_lecture + 1)) == '"')
                       {
                           ptr_lecture++;
                           (*ptr_ecriture) = '\"';
                       }
                       else if ((*(ptr_lecture + 1)) == 'b')
                       {
                           ptr_lecture++;
                           (*ptr_ecriture) = '\b';
                       }
                       else if ((*(ptr_lecture + 1)) == 'n')
                       {
                           ptr_lecture++;
                           (*ptr_ecriture) = '\n';
                       }
                       else if ((*(ptr_lecture + 1)) == 't')
                       {
                           ptr_lecture++;
                           (*ptr_ecriture) = '\t';
                       }
                       else if ((*(ptr_lecture + 1)) == 'x')
                       {
                           ptr_lecture += 2;
   
                           if ((*ptr_lecture) != d_code_fin_chaine)
                           {
                               if ((*(ptr_lecture + 1)) != d_code_fin_chaine)
                               {
                                   logical1        erreur;
                                   unsigned char   ec;
   
                                   erreur = d_faux;
   
                                   switch(*ptr_lecture)
                                   {
                                       case '0':
                                       case '1':
                                       case '2':
                                       case '3':
                                       case '4':
                                       case '5':
                                       case '6':
                                       case '7':
                                       case '8':
                                       case '9':
                                           ec = (*ptr_lecture) - '0';
                                           break;
   
                                       case 'A':
                                       case 'B':
                                       case 'C':
                                       case 'D':
                                       case 'E':
                                       case 'F':
                                           ec = ((*ptr_lecture) - 'A') + 10;
                                           break;
   
                                       default:
                                           ec = 0;
                                           erreur = d_vrai;
                                           break;
                                   }
   
                                   ec *= 0x10;
                                   ptr_lecture++;
   
                                   switch(*ptr_lecture)
                                   {
                                       case '0':
                                       case '1':
                                       case '2':
                                       case '3':
                                       case '4':
                                       case '5':
                                       case '6':
                                       case '7':
                                       case '8':
                                       case '9':
                                           ec += (*ptr_lecture) - '0';
                                           break;
   
                                       case 'A':
                                       case 'B':
                                       case 'C':
                                       case 'D':
                                       case 'E':
                                       case 'F':
                                           ec += ((*ptr_lecture) - 'A') + 10;
                                           break;
   
                                       default:
                                           erreur = d_vrai;
                                           break;
                                   }
   
                                   (*ptr_ecriture) = ec;
   
                                   if (erreur == d_vrai)
                                   {
                                       if ((*s_etat_processus).langue == 'F')
                                       {
                                           printf("+++Information : "
                                                   "Séquence d'échappement "
                                                   "inconnue [%d]\n",
                                                   (int) getpid());
                                       }
                                       else
                                       {
                                           printf("+++Warning : Unknown "
                                                   "escape code "
                                                   "[%d]\n", (int) getpid());
                                       }
                                   }
                               }
                               else
                               {
                                   if ((*s_etat_processus).langue == 'F')
                                   {
                                       printf("+++Information : "
                                               "Séquence d'échappement "
                                               "inconnue [%d]\n", (int) getpid());
                                   }
                                   else
                                   {
                                       printf("+++Warning : Unknown escape code "
                                               "[%d]\n", (int) getpid());
                                   }
                               }
                           }
                           else
                           {
                               if ((*s_etat_processus).langue == 'F')
                               {
                                   printf("+++Information : "
                                           "Séquence d'échappement "
                                           "inconnue [%d]\n", (int) getpid());
                               }
                               else
                               {
                                   printf("+++Warning : Unknown escape code "
                                           "[%d]\n", (int) getpid());
                               }
                           }
                       }
                       else if ((*(ptr_lecture + 1)) == '\\')
                       {
                           ptr_lecture++;
                       }
                       else
                       {
                           if ((*s_etat_processus).langue == 'F')
                           {
                               printf("+++Information : Séquence d'échappement "
                                       "inconnue [%d]\n", (int) getpid());
                           }
                           else
                           {
                               printf("+++Warning : Unknown escape code "
                                       "[%d]\n", (int) getpid());
                           }
                       }
                   }
   
                   ptr_ecriture++;
                   ptr_lecture++;
               }
   
               (*ptr_ecriture) = d_code_fin_chaine;
   
               if ((chaine = realloc(chaine, ((ptr_ecriture - chaine) + 1) *
                       sizeof(unsigned char))) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
           }
           else
           {
               strcpy(chaine, (unsigned char *) ((*s_objet).objet));
           }
     }      }
     else if ((*s_objet).type == CPL)      else if ((*s_objet).type == CPL)
     {      {
Line 3052  formateur(struct_processus *s_etat_proce Line 3176  formateur(struct_processus *s_etat_proce
     }      }
     else if ((*s_objet).type == MTX)      else if ((*s_objet).type == MTX)
     {      {
         sprintf(tampon, " %016lX", (unsigned long)          if (alsprintf(&chaine, "Mutex $ %016lX", (unsigned long)
                 &((*((struct_mutex *) (*s_objet).objet)).mutex));                  &((*((struct_mutex *) (*s_objet).objet)).mutex)) < 0)
   
         chaine = (unsigned char *) malloc((strlen(tampon) + 8)  
                 * sizeof(unsigned char));  
   
         if (chaine == NULL)  
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(NULL);              return(NULL);
         }          }
   
         strcpy(chaine, "Mutex $");  
         strcat(chaine, tampon);  
     }      }
     else if ((*s_objet).type == NOM)      else if ((*s_objet).type == NOM)
     {      {
Line 3512  formateur_reel(struct_processus *s_etat_ Line 3628  formateur_reel(struct_processus *s_etat_
     logical1                i50;      logical1                i50;
   
     long                    correction;      long                    correction;
       long                    dernier_chiffre_significatif;
     long                    exposant;      long                    exposant;
     long                    longueur_utile;      long                    longueur_utile;
     long                    longueur_utile_limite;      long                    longueur_utile_limite;
   
     unsigned char           *chaine;      unsigned char           *chaine;
     unsigned char           format[16 + 1];      unsigned char           format[32 + 1];
     unsigned char           mode[3 + 1];      unsigned char           mode[3 + 1];
     unsigned char           *ptr;      unsigned char           *ptr;
     unsigned char           tampon[16 + 1];      unsigned char           tampon[32 + 1];
   
     unsigned long           i;      unsigned long           i;
     unsigned long           j;      unsigned long           j;
Line 3644  formateur_reel(struct_processus *s_etat_ Line 3761  formateur_reel(struct_processus *s_etat_
         }          }
     }      }
   
       // 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) ||      if ((strcmp(mode, "SCI") == 0) ||
             ((strcmp(mode, "STD") == 0) && ((exposant >              ((strcmp(mode, "STD") == 0) && ((exposant >
             longueur_utile_limite) ||              longueur_utile_limite) || (dernier_chiffre_significatif > 15) ||
             (exposant < -longueur_utile_limite))) ||              (exposant < -longueur_utile_limite))) ||
             ((strcmp(mode, "FIX") == 0) &&              ((strcmp(mode, "FIX") == 0) &&
             ((exposant >= longueur_utile_limite) ||              ((exposant >= longueur_utile_limite) ||
Line 3759  formateur_reel(struct_processus *s_etat_ Line 3909  formateur_reel(struct_processus *s_etat_
                 }                  }
             }              }
         }          }
   
         strcpy(chaine, tampon);          strcpy(chaine, tampon);
     }      }
   
Removed from v.1.1.1.1  
changed lines
  Added in v.1.25

CVSweb interface <joel.bertrand@systella.fr>