[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.15 and 1.28

version 1.15, 2011/11/18 09:51:32 version 1.28, 2012/12/18 13:19:34
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.4    RPL/2 (R) version 4.1.12
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2012 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 244  formateur_flux(struct_processus *s_etat_ Line 244  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,
           long longueur)
   {
       long                    longueur_courante;
       long                    offset;
   
       unsigned char           *chaine;
       unsigned char           hexadecimal[3];
       unsigned char           *ptr_ecriture;
       unsigned char           *ptr_lecture;
   
       if ((chaine = malloc((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':
               {
                   offset = ptr_ecriture - chaine;
   
                   if ((chaine = realloc(chaine, (++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;
                       }
                   }
   
                   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, (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 268  validation_chaine(unsigned char *chaine) Line 404  validation_chaine(unsigned char *chaine)
         {          {
             if ((*(chaine + 1)) == '"')              if ((*(chaine + 1)) == '"')
             {              {
                 // Valide                  chaine += 2;
             }              }
             else if ((*(chaine + 1)) == 'b')              else if ((*(chaine + 1)) == 'b')
             {              {
                 // Valide                  chaine += 2;
             }              }
             else if ((*(chaine + 1)) == 'n')              else if ((*(chaine + 1)) == 'n')
             {              {
                 // Valide                  chaine += 2;
             }              }
             else if ((*(chaine + 1)) == 't')              else if ((*(chaine + 1)) == 't')
             {              {
                 // Valide                  chaine += 2;
             }              }
             else if ((*(chaine + 1)) == 'x')              else if ((*(chaine + 1)) == 'x')
             {              {
Line 347  validation_chaine(unsigned char *chaine) Line 483  validation_chaine(unsigned char *chaine)
                 {                  {
                     return(d_faux);                      return(d_faux);
                 }                  }
   
                   chaine += 4;
             }              }
             else if ((*(chaine + 1)) == '\\')              else if ((*(chaine + 1)) == '\\')
             {              {
                 // Valide                  chaine += 2;
             }              }
             else              else
             {              {
Line 360  validation_chaine(unsigned char *chaine) Line 498  validation_chaine(unsigned char *chaine)
         }          }
         else          else
         {          {
             // Caractère valide              chaine++;
         }          }
   
         chaine++;  
     }      }
   
     return(d_vrai);      return(d_vrai);
Line 527  prochain_caractere(struct_processus *s_e Line 663  prochain_caractere(struct_processus *s_e
         }          }
         else if ((*(chaine + 1)) == '\\')          else if ((*(chaine + 1)) == '\\')
         {          {
             suivant = chaine + 1;              suivant = chaine + 2;
         }          }
         else          else
         {          {
Line 599  longueur_chaine(struct_processus *s_etat Line 735  longueur_chaine(struct_processus *s_etat
 ================================================================================  ================================================================================
   Routine retournant un pointeur sur le i-ème caractère d'une chaîne    Routine retournant un pointeur sur le i-ème caractère d'une chaîne
 ================================================================================  ================================================================================
   Entrées : structure sur l'état du processus et chaîne    Entrées : structure sur l'état du processus, chaîne et position du caractère
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Sorties : longueur de la chaîne    Sorties : pointeur sur le caractère
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Effets de bord : néant    Effets de bord : néant
 ================================================================================  ================================================================================
Line 633  pointeur_ieme_caractere(struct_processus Line 769  pointeur_ieme_caractere(struct_processus
     return(pointeur);      return(pointeur);
 }  }
   
   
   /*
   ================================================================================
     Routine retournant la position du caractère en fonction du pointeur
     dans la chaîne
   ================================================================================
     Entrées : structure sur l'état du processus, chaîne et position
   --------------------------------------------------------------------------------
     Sorties : quantième dans la chaîne
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   integer8
   position_caractere_de_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine, unsigned char *position)
   {
       integer8            i;
   
       i = 1;
   
       while(chaine != position)
       {
           chaine = prochain_caractere(s_etat_processus, chaine);
           i++;
   
           if ((*chaine) == d_code_fin_chaine)
           {
               return(0);
           }
       }
   
       return(i);
   }
   
   
   /*
   ================================================================================
     Conversion d'une chaîne en majuscule ou en minuscule
   ================================================================================
     Entrées : chaîne et indicateur ('M' pour majuscules, 'm' pour minuscules)
   --------------------------------------------------------------------------------
     Sorties : néant
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   void
   conversion_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine, unsigned char type)
   {
       int                 (*fonction_1)(int);
       int                 (*fonction_2)(int);
   
       unsigned char       *ptr;
       unsigned char       *ptr2;
       unsigned char       registre;
   
       if (type == 'M')
       {
           fonction_1 = toupper;
           fonction_2 = tolower;
       }
       else
       {
           fonction_1 = tolower;
           fonction_2 = toupper;
       }
   
       ptr = chaine;
   
       while((*ptr) != d_code_fin_chaine)
       {
           ptr2 = prochain_caractere(s_etat_processus, ptr);
   
           if ((ptr2 - ptr) == 1)
           {
               registre = fonction_1((*ptr));
   
               if (fonction_2(registre) == (*ptr))
               {
                   (*ptr) = registre;
               }
           }
   
           ptr = ptr2;
       }
   
       return;
   }
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.15  
changed lines
  Added in v.1.28

CVSweb interface <joel.bertrand@systella.fr>