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

Diff for /rpl/src/formateur.c between versions 1.4 and 1.26

version 1.4, 2010/02/08 19:26:32 version 1.26, 2011/04/21 16:00:54
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.10    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 188  formateur(struct_processus *s_etat_proce Line 190  formateur(struct_processus *s_etat_proce
 #           ifdef POSTGRESQL_SUPPORT  #           ifdef POSTGRESQL_SUPPORT
             if (alsprintf(&chaine, "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.postgresql,
                     (*((struct_connecteur_sql *) (*s_objet).objet)).type) < 0)                      (*((struct_connecteur_sql *) (*s_objet).objet)).type) < 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 390  formateur(struct_processus *s_etat_proce Line 392  formateur(struct_processus *s_etat_proce
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
         if (alsprintf(&chaine, "Socket %016lX",          if (alsprintf(&chaine, "Socket $ %016lX",
                 (unsigned long) (*((struct_socket *)                  (unsigned long) (*((struct_socket *)
                 ((*s_objet).objet))).socket) < 0)                  ((*s_objet).objet))).socket) < 0)
         {          {
Line 1750  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)
     {      {
Removed from v.1.4  
changed lines
  Added in v.1.26

CVSweb interface <joel.bertrand@systella.fr>