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

Diff for /rpl/src/formateur_flux.c between versions 1.23 and 1.49

version 1.23, 2012/05/21 17:25:41 version 1.49, 2015/11/26 11:44:31
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.9    RPL/2 (R) version 4.1.24
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 37 Line 37
   
 unsigned char *  unsigned char *
 formateur_flux(struct_processus *s_etat_processus, unsigned char *donnees,  formateur_flux(struct_processus *s_etat_processus, unsigned char *donnees,
         long *longueur)          integer8 *longueur)
 {  {
     unsigned char           *chaine;      unsigned char           *chaine;
   
Line 107  formateur_flux(struct_processus *s_etat_ Line 107  formateur_flux(struct_processus *s_etat_
                             case '7':                              case '7':
                             case '8':                              case '8':
                             case '9':                              case '9':
                                 ec = (*ptr_lecture) - '0';                                  ec = (unsigned char) ((*ptr_lecture) - '0');
                                 break;                                  break;
   
                             case 'A':                              case 'A':
Line 116  formateur_flux(struct_processus *s_etat_ Line 116  formateur_flux(struct_processus *s_etat_
                             case 'D':                              case 'D':
                             case 'E':                              case 'E':
                             case 'F':                              case 'F':
                                 ec = ((*ptr_lecture) - 'A') + 10;                                  ec = (unsigned char) (((*ptr_lecture) - 'A')
                                           + 10);
                                 break;                                  break;
   
                             default:                              default:
Line 125  formateur_flux(struct_processus *s_etat_ Line 126  formateur_flux(struct_processus *s_etat_
                                 break;                                  break;
                         }                          }
   
                         ec *= 0x10;                          ec = (unsigned char) (ec * (unsigned char) 0x10);
                         ptr_lecture++;                          ptr_lecture++;
   
                         switch(*ptr_lecture)                          switch(*ptr_lecture)
Line 140  formateur_flux(struct_processus *s_etat_ Line 141  formateur_flux(struct_processus *s_etat_
                             case '7':                              case '7':
                             case '8':                              case '8':
                             case '9':                              case '9':
                                 ec += (*ptr_lecture) - '0';                                  ec = (unsigned char) (ec +
                                           ((*ptr_lecture) - '0'));
                                 break;                                  break;
   
                             case 'A':                              case 'A':
Line 149  formateur_flux(struct_processus *s_etat_ Line 151  formateur_flux(struct_processus *s_etat_
                             case 'D':                              case 'D':
                             case 'E':                              case 'E':
                             case 'F':                              case 'F':
                                 ec += ((*ptr_lecture) - 'A') + 10;                                  ec = (unsigned char) (ec +
                                           (((*ptr_lecture) - 'A') + 10));
                                 break;                                  break;
   
                             default:                              default:
Line 165  formateur_flux(struct_processus *s_etat_ Line 168  formateur_flux(struct_processus *s_etat_
                             {                              {
                                 printf("+++Information : "                                  printf("+++Information : "
                                         "Séquence d'échappement "                                          "Séquence d'échappement "
                                         "inconnue [%d]\n",                                          "inconnue (\\x%c%c) [%d]\n",
                                           *ptr_lecture, *(ptr_lecture + 1),
                                         (int) getpid());                                          (int) getpid());
                             }                              }
                             else                              else
                             {                              {
                                 printf("+++Warning : Unknown "                                  printf("+++Warning : Unknown "
                                         "escape code "                                          "escape code (\\x%c%c) [%d]\n",
                                         "[%d]\n", (int) getpid());                                          *ptr_lecture, *(ptr_lecture + 1),
                                           (int) getpid());
                             }                              }
                         }                          }
                     }                      }
Line 182  formateur_flux(struct_processus *s_etat_ Line 187  formateur_flux(struct_processus *s_etat_
                         {                          {
                             printf("+++Information : "                              printf("+++Information : "
                                     "Séquence d'échappement "                                      "Séquence d'échappement "
                                     "inconnue [%d]\n", (int) getpid());                                      "tronquée [%d]\n", (int) getpid());
                         }                          }
                         else                          else
                         {                          {
                             printf("+++Warning : Unknown escape code "                              printf("+++Warning : Truncated escape code "
                                     "[%d]\n", (int) getpid());                                      "[%d]\n", (int) getpid());
                         }                          }
                     }                      }
Line 212  formateur_flux(struct_processus *s_etat_ Line 217  formateur_flux(struct_processus *s_etat_
             }              }
             else              else
             {              {
                 if ((*s_etat_processus).langue == 'F')                  if ((*(ptr_lecture + 1)) == d_code_fin_chaine)
                 {                  {
                     printf("+++Information : Séquence d'échappement "                      if ((*s_etat_processus).langue == 'F')
                             "inconnue [%d]\n", (int) getpid());                      {
                           printf("+++Information : "
                                   "Séquence d'échappement "
                                   "tronquée [%d]\n", (int) getpid());
                       }
                       else
                       {
                           printf("+++Warning : Truncated escape code "
                                   "[%d]\n", (int) getpid());
                       }
                 }                  }
                 else                  else
                 {                  {   
                     printf("+++Warning : Unknown escape code "                      if ((*s_etat_processus).langue == 'F')
                             "[%d]\n", (int) getpid());                      {
                           printf("+++Information : Séquence d'échappement "
                                   "inconnue (%c%c) [%d]\n",
                                   *ptr_lecture, *(ptr_lecture + 1),
                                   (int) getpid());
                       }
                       else
                       {
                           printf("+++Warning : Unknown escape code (%c%c) "
                                   "[%d]\n", *ptr_lecture, *(ptr_lecture + 1),
                                   (int) getpid());
                       }
                 }                  }
             }              }
         }          }
Line 231  formateur_flux(struct_processus *s_etat_ Line 256  formateur_flux(struct_processus *s_etat_
   
     (*ptr_ecriture) = d_code_fin_chaine;      (*ptr_ecriture) = d_code_fin_chaine;
   
     if ((chaine = realloc(chaine, ((((*longueur) = ptr_ecriture - chaine)) + 1)      if ((chaine = realloc(chaine, (((size_t) ((*longueur) =
             * sizeof(unsigned char))) == NULL)              ptr_ecriture - chaine)) + 1) * 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);
Line 244  formateur_flux(struct_processus *s_etat_ Line 269  formateur_flux(struct_processus *s_etat_
   
 /*  /*
 ================================================================================  ================================================================================
     Routine de d'analyse d'un flux
   ================================================================================
     Entrées : structure sur l'état du processus et objet à afficher
   --------------------------------------------------------------------------------
     Sorties : chaine de caractères
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   unsigned char *
   analyse_flux(struct_processus *s_etat_processus, unsigned char *donnees,
           integer8 longueur)
   {
       integer8                longueur_courante;
   
       long                    offset;
   
       unsigned char           *chaine;
       unsigned char           hexadecimal[3];
       unsigned char           *ptr_ecriture;
       unsigned char           *ptr_lecture;
   
       if ((chaine = malloc(((size_t) (longueur_courante = longueur + 1)) *
               sizeof(unsigned char))) == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return(NULL);
       }
   
       ptr_lecture = donnees;
       ptr_ecriture = chaine;
   
       while(longueur > 0)
       {
           // Début de la séquence d'échappement
   
           switch((*ptr_lecture))
           {
               case '"':
               case '\b':
               case '\n':
               case '\t':
               case '\\':
               {
                   offset = ptr_ecriture - chaine;
   
                   if ((chaine = realloc(chaine, ((size_t) (++longueur_courante))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   ptr_ecriture = chaine + offset;
                   *ptr_ecriture++ = '\\';
   
                   switch((*ptr_lecture++))
                   {
                       case '"':
                       {
                           *ptr_ecriture++ = '"';
                           break;
                       }
   
                       case '\b':
                       {
                           *ptr_ecriture++ = 'b';
                           break;
                       }
   
                       case '\n':
                       {
                           *ptr_ecriture++ = 'n';
                           break;
                       }
   
                       case '\t':
                       {
                           *ptr_ecriture++ = 't';
                           break;
                       }
   
                       case '\\':
                       {
                           *ptr_ecriture++ = '\\';
                           break;
                       }
                   }
   
                   break;
               }
   
               case ' ':
               {
                   *ptr_ecriture++ = *ptr_lecture++;
                   break;
               }
   
               default:
               {
                   if (isgraph((*ptr_lecture)))
                   {
                       *ptr_ecriture++ = *ptr_lecture++;
                   }
                   else
                   {
                       offset = ptr_ecriture - chaine;
   
                       if ((chaine = realloc(chaine, ((size_t) (longueur_courante =
                               longueur_courante + 3)) * sizeof(unsigned char)))
                               == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       ptr_ecriture = chaine + offset;
                       *ptr_ecriture++ = '\\';
                       *ptr_ecriture++ = 'x';
   
                       sprintf(hexadecimal, "%02X", *ptr_lecture++);
   
                       *ptr_ecriture++ = hexadecimal[0];
                       *ptr_ecriture++ = hexadecimal[1];
                   }
   
                   break;
               }
           }
   
           longueur--;
       }
   
       (*ptr_ecriture) = d_code_fin_chaine;
   
       return(chaine);
   }
   
   
   /*
   ================================================================================
   Routine testant la validité d'une chaîne de caractères    Routine testant la validité d'une chaîne de caractères
 ================================================================================  ================================================================================
   Entrées : structure sur l'état du processus et chaîne courante    Entrées : structure sur l'état du processus et chaîne courante
Line 688  conversion_chaine(struct_processus *s_et Line 857  conversion_chaine(struct_processus *s_et
 {  {
     int                 (*fonction_1)(int);      int                 (*fonction_1)(int);
     int                 (*fonction_2)(int);      int                 (*fonction_2)(int);
       int                 registre;
   
     unsigned char       *ptr;      unsigned char       *ptr;
     unsigned char       *ptr2;      unsigned char       *ptr2;
     unsigned char       registre;  
   
     if (type == 'M')      if (type == 'M')
     {      {
Line 716  conversion_chaine(struct_processus *s_et Line 885  conversion_chaine(struct_processus *s_et
   
             if (fonction_2(registre) == (*ptr))              if (fonction_2(registre) == (*ptr))
             {              {
                 (*ptr) = registre;                  (*ptr) = (unsigned char) registre;
             }              }
         }          }
   
Removed from v.1.23  
changed lines
  Added in v.1.49

CVSweb interface <joel.bertrand@systella.fr>