[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.5 and 1.58

version 1.5, 2011/06/21 07:45:22 version 1.58, 2019/02/03 14:40:32
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.1    RPL/2 (R) version 4.1.31
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2019 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;
           return(NULL);
       }
   
       return(chaine);
   }
   
   
   /*
   ================================================================================
     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;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return(NULL);          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);      return(chaine);
 }  }
   
   
   /*
   ================================================================================
     Routine testant la validité d'une chaîne de caractères
   ================================================================================
     Entrées : structure sur l'état du processus et chaîne courante
   --------------------------------------------------------------------------------
     Sorties : pointeur sur le caractère suivant
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   logical1
   validation_chaine(unsigned char *chaine)
   {
       if (chaine == NULL)
       {
           return(d_faux);
       }
   
       while((*chaine) != d_code_fin_chaine)
       {
           if ((*chaine) == '\\')
           {
               if ((*(chaine + 1)) == '"')
               {
                   chaine += 2;
               }
               else if ((*(chaine + 1)) == 'b')
               {
                   chaine += 2;
               }
               else if ((*(chaine + 1)) == 'n')
               {
                   chaine += 2;
               }
               else if ((*(chaine + 1)) == 't')
               {
                   chaine += 2;
               }
               else if ((*(chaine + 1)) == 'x')
               {
                   if ((*(chaine + 2)) != d_code_fin_chaine)
                   {
                       if ((*(chaine + 3)) != d_code_fin_chaine)
                       {
                           switch(*(chaine + 2))
                           {
                               case '0':
                               case '1':
                               case '2':
                               case '3':
                               case '4':
                               case '5':
                               case '6':
                               case '7':
                               case '8':
                               case '9':
                               case 'A':
                               case 'B':
                               case 'C':
                               case 'D':
                               case 'E':
                               case 'F':
                                   break;
   
                               default:
                                   return(d_faux);
                                   break;
                           }
   
                           switch(*(chaine + 3))
                           {
                               case '0':
                               case '1':
                               case '2':
                               case '3':
                               case '4':
                               case '5':
                               case '6':
                               case '7':
                               case '8':
                               case '9':
                               case 'A':
                               case 'B':
                               case 'C':
                               case 'D':
                               case 'E':
                               case 'F':
                                   break;
   
                               default:
                                   return(d_faux);
                                   break;
                           }
                       }
                       else
                       {
                           return(d_faux);
                       }
                   }
                   else
                   {
                       return(d_faux);
                   }
   
                   chaine += 4;
               }
               else if ((*(chaine + 1)) == '\\')
               {
                   chaine += 2;
               }
               else
               {
                   // Tous les autres cas sont invalides
                   return(d_faux);
               }
           }
           else
           {
               chaine++;
           }
       }
   
       return(d_vrai);
   }
   
   
   /*
   ================================================================================
     Routine permettant de trouver le caractère suivant dans une chaîne
   ================================================================================
     Entrées : structure sur l'état du processus et chaîne courante
   --------------------------------------------------------------------------------
     Sorties : pointeur sur le caractère suivant
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   static inline unsigned char *
   prochain_caractere(struct_processus *s_etat_processus, unsigned char *chaine)
   {
       unsigned char       *suivant;
   
       if (chaine == NULL)
       {
           return(NULL);
       }
   
       if ((*chaine) == '\\')
       {
           if ((*(chaine + 1)) == '"')
           {
               suivant = chaine + 2;
           }
           else if ((*(chaine + 1)) == 'b')
           {
               suivant = chaine + 2;
           }
           else if ((*(chaine + 1)) == 'n')
           {
               suivant = chaine + 2;
           }
           else if ((*(chaine + 1)) == 't')
           {
               suivant = chaine + 2;
           }
           else if ((*(chaine + 1)) == 'x')
           {
               if ((*(chaine + 2)) != d_code_fin_chaine)
               {
                   if ((*(chaine + 3)) != d_code_fin_chaine)
                   {
                       logical1        erreur;
   
                       erreur = d_faux;
   
                       switch(*(chaine + 2))
                       {
                           case '0':
                           case '1':
                           case '2':
                           case '3':
                           case '4':
                           case '5':
                           case '6':
                           case '7':
                           case '8':
                           case '9':
                           case 'A':
                           case 'B':
                           case 'C':
                           case 'D':
                           case 'E':
                           case 'F':
                               break;
   
                           default:
                               erreur = d_vrai;
                               break;
                       }
   
                       switch(*(chaine + 3))
                       {
                           case '0':
                           case '1':
                           case '2':
                           case '3':
                           case '4':
                           case '5':
                           case '6':
                           case '7':
                           case '8':
                           case '9':
                           case 'A':
                           case 'B':
                           case 'C':
                           case 'D':
                           case 'E':
                           case 'F':
                               break;
   
                           default:
                               erreur = d_vrai;
                               break;
                       }
   
                       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());
                           }
   
                           return(NULL);
                       }
   
                       suivant = chaine + 4;
                   }
                   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());
                       }
   
                       return(NULL);
                   }
               }
               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());
                   }
   
                   return(NULL);
               }
           }
           else if ((*(chaine + 1)) == '\\')
           {
               suivant = chaine + 2;
           }
           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());
               }
   
               return(NULL);
           }
       }
       else
       {
           suivant = chaine + 1;
       }
   
       return(suivant);
   }
   
   
   /*
   ================================================================================
     Routine donnant la longueur d'une chaîne de caractères
   ================================================================================
     Entrées : structure sur l'état du processus et chaîne
   --------------------------------------------------------------------------------
     Sorties : longueur de la chaîne
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   integer8
   longueur_chaine(struct_processus *s_etat_processus, unsigned char *chaine)
   {
       integer8        nombre_caracteres;
   
       unsigned char   *pointeur;
   
       pointeur = chaine;
       nombre_caracteres = 0;
   
       if ((*pointeur) == '\0')
       {
           return(0);
       }
   
       do
       {
           if ((pointeur = prochain_caractere(s_etat_processus, pointeur)) == NULL)
           {
               return(0);
           }
   
           nombre_caracteres++;
       } while((*pointeur) != 0);
   
       return(nombre_caracteres);
   }
   
   
   /*
   ================================================================================
     Routine retournant un pointeur sur le i-ème caractère d'une chaîne
   ================================================================================
     Entrées : structure sur l'état du processus, chaîne et position du caractère
   --------------------------------------------------------------------------------
     Sorties : pointeur sur le caractère
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   unsigned char *
   pointeur_ieme_caractere(struct_processus *s_etat_processus,
           unsigned char *chaine, integer8 position)
   {
       integer8            i;
   
       unsigned char       *pointeur;
   
       if ((pointeur = chaine) == NULL)
       {
           return(NULL);
       }
   
       for(i = 0; i < position; i++)
       {
           pointeur = prochain_caractere(s_etat_processus, pointeur);
   
           if ((*pointeur) == d_code_fin_chaine)
           {
               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);
       int                 registre;
   
       unsigned char       *ptr;
       unsigned char       *ptr2;
   
       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) = (unsigned char) registre;
               }
           }
   
           ptr = ptr2;
       }
   
       return;
   }
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.5  
changed lines
  Added in v.1.58

CVSweb interface <joel.bertrand@systella.fr>