[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.13 and 1.21

version 1.13, 2011/09/26 15:57:10 version 1.21, 2012/03/01 10:14:04
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.4    RPL/2 (R) version 4.1.7
   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 241  formateur_flux(struct_processus *s_etat_ Line 241  formateur_flux(struct_processus *s_etat_
     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);
   
       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.13  
changed lines
  Added in v.1.21

CVSweb interface <joel.bertrand@systella.fr>