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

Diff for /rpl/src/compilation.c between versions 1.68 and 1.69

version 1.68, 2014/07/26 09:58:02 version 1.69, 2014/08/04 06:58:48
Line 19 Line 19
 ================================================================================  ================================================================================
 */  */
   
   #define DEBUG_ERREURS
 #include "rpl-conv.h"  #include "rpl-conv.h"
   
   
Line 1017  swap(void *variable_1, void *variable_2, Line 1017  swap(void *variable_1, void *variable_2,
 logical1  logical1
 recherche_instruction_suivante(struct_processus *s_etat_processus)  recherche_instruction_suivante(struct_processus *s_etat_processus)
 {  {
       return(recherche_instruction_suivante_recursive(s_etat_processus, 0));
   }
   
   logical1
   recherche_instruction_suivante_recursive(struct_processus *s_etat_processus,
           integer8 recursivite)
   {
     enum t_type                 registre_type_en_cours;      enum t_type                 registre_type_en_cours;
   
     logical1                    drapeau_fin_objet;      logical1                    drapeau_fin_objet;
Line 1458  recherche_instruction_suivante(struct_pr Line 1465  recherche_instruction_suivante(struct_pr
                     registre_type_en_cours = (*s_etat_processus).type_en_cours;                      registre_type_en_cours = (*s_etat_processus).type_en_cours;
                     (*s_etat_processus).type_en_cours = LST;                      (*s_etat_processus).type_en_cours = LST;
   
                     if (recherche_instruction_suivante(s_etat_processus)                      if (recherche_instruction_suivante_recursive(
                             == d_erreur)                              s_etat_processus, recursivite + 1) == d_erreur)
                     {                      {
                         (*s_etat_processus).type_en_cours =                          (*s_etat_processus).type_en_cours =
                                 registre_type_en_cours;                                  registre_type_en_cours;
Line 1474  recherche_instruction_suivante(struct_pr Line 1481  recherche_instruction_suivante(struct_pr
                         return(d_erreur);                          return(d_erreur);
                     }                      }
   
                       (*s_etat_processus).type_en_cours = registre_type_en_cours;
                     pointeur_caractere_courant =                      pointeur_caractere_courant =
                             (*s_etat_processus).definitions_chainees +                              (*s_etat_processus).definitions_chainees +
                             (*s_etat_processus).position_courante;                              (*s_etat_processus).position_courante;
Line 1585  recherche_instruction_suivante(struct_pr Line 1593  recherche_instruction_suivante(struct_pr
                         erreur_format = d_ex_syntaxe;                          erreur_format = d_ex_syntaxe;
                     }                      }
   
                     niveau = 1;                      pointeur_caractere_courant++;
                       drapeau_fin_objet = d_faux;
   
                     while((niveau != 0) && ((*pointeur_caractere_courant) !=                      while(((*pointeur_caractere_courant) != d_code_fin_chaine)
                             d_code_fin_chaine))                              && (erreur_format == d_absence_erreur))
                     {                      {
                         (*s_etat_processus).position_courante =                          while((*pointeur_caractere_courant) == d_code_espace)
                                 pointeur_caractere_courant  
                                 - (*s_etat_processus).definitions_chainees;  
   
                         registre_type_en_cours = (*s_etat_processus)  
                                 .type_en_cours;  
                         (*s_etat_processus).type_en_cours = RPN;  
   
                         if (recherche_instruction_suivante(s_etat_processus)  
                                 == d_erreur)  
                         {                          {
                             (*s_etat_processus).type_en_cours =                              pointeur_caractere_courant++;
                                     registre_type_en_cours;                          }
   
                             if ((*s_etat_processus).instruction_courante                          if ((*pointeur_caractere_courant) == '>')
                                     != NULL)                          {
                               if ((*(++pointeur_caractere_courant)) == '>')
                               {
                                   drapeau_fin_objet = d_vrai;
                               }
                               else
                             {                              {
                                 free((*s_etat_processus).instruction_courante);                                  erreur_analyse = d_ex_syntaxe;
                                 (*s_etat_processus).instruction_courante = NULL;  
                             }                              }
   
                             return(d_erreur);                              pointeur_caractere_courant++;
                               break;
                         }                          }
   
                         (*s_etat_processus).type_en_cours =                          if ((erreur_format == d_absence_erreur) &&
                                 registre_type_en_cours;                                  (drapeau_fin_objet == d_faux))
                         pointeur_caractere_courant =  
                                 (*s_etat_processus).definitions_chainees +  
                                 (*s_etat_processus).position_courante;  
   
                         if (strcmp((*s_etat_processus).instruction_courante,  
                                 "<<") == 0)  
                         {  
                             niveau++;  
                         }  
                         else if (strcmp((*s_etat_processus)  
                                 .instruction_courante, ">>") == 0)  
                         {                          {
                             niveau--;                              (*s_etat_processus).position_courante =
                         }                                      pointeur_caractere_courant
                                       - (*s_etat_processus).definitions_chainees;
   
                               registre_type_en_cours = (*s_etat_processus)
                                       .type_en_cours;
                               (*s_etat_processus).type_en_cours = RPN;
   
                               if ((erreur =
                                       recherche_instruction_suivante_recursive(
                                       s_etat_processus, recursivite + 1))
                                       != d_absence_erreur)
                               {
                                   (*s_etat_processus).type_en_cours =
                                           registre_type_en_cours;
   
                                   if ((*s_etat_processus).instruction_courante
                                           != NULL)
                                   {
                                       free((*s_etat_processus)
                                               .instruction_courante);
                                       (*s_etat_processus).instruction_courante
                                               = NULL;
                                   }
   
                                   return(d_erreur);
                               }
   
                               (*s_etat_processus).type_en_cours =
                                       registre_type_en_cours;
                               pointeur_caractere_courant = (*s_etat_processus)
                                       .definitions_chainees + (*s_etat_processus)
                                       .position_courante;
   
                         free((*s_etat_processus).instruction_courante);                              free((*s_etat_processus).instruction_courante);
                           }
                     }                      }
   
                     if (niveau != 0)                      if (drapeau_fin_objet == d_faux)
                     {                      {
                         erreur_analyse = d_ex_syntaxe;                          erreur_analyse = d_ex_syntaxe;
                           drapeau_fin_objet = d_vrai;
                     }                      }
   
                     drapeau_fin_objet = d_vrai;  
                 }                  }
                 else if ((*pointeur_caractere_courant) == '[')                  else if ((*pointeur_caractere_courant) == '[')
                 { // Cas <[ ]>                  { // Cas <[ ]>
Line 1686  recherche_instruction_suivante(struct_pr Line 1711  recherche_instruction_suivante(struct_pr
                                     .type_en_cours;                                      .type_en_cours;
                             (*s_etat_processus).type_en_cours = TBL;                              (*s_etat_processus).type_en_cours = TBL;
   
                             if ((erreur = recherche_instruction_suivante(                              if ((erreur =
                                     s_etat_processus)) != d_absence_erreur)                                      recherche_instruction_suivante_recursive(
                                       s_etat_processus, recursivite + 1))
                                       != d_absence_erreur)
                             {                              {
                                 (*s_etat_processus).type_en_cours =                                  (*s_etat_processus).type_en_cours =
                                         registre_type_en_cours;                                          registre_type_en_cours;
Line 1725  recherche_instruction_suivante(struct_pr Line 1752  recherche_instruction_suivante(struct_pr
             }              }
         }          }
   
         if ((*pointeur_caractere_courant) == caractere_fin)          if ((*(pointeur_caractere_courant - 1)) == caractere_fin)
         {          {
               // Cas des objets composites (LST, RPN, TBL)
               break;
           }
           else if ((*pointeur_caractere_courant) == caractere_fin)
           {
               // Condition pour traiter les cas 123}
             break;              break;
         }          }
     }      }
   
     pointeur_fin_instruction = pointeur_caractere_courant;      pointeur_fin_instruction = pointeur_caractere_courant;
   
       if (recursivite == 0)
       {
           // Si la variable récursivité est nulle, il faut que le caractère
           // suivant l'objet soit un espace ou une fin de chaîne. Si ce n'est pas
           // le cas, il faut retourner une erreur car les objets de type
           // [[ 1 4 ]]3 doivent être invalides.
   
           switch((*pointeur_fin_instruction))
           {
               case d_code_fin_chaine:
               case d_code_espace:
               {
                   break;
               }
   
               default:
               {
                   (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                   return(d_erreur);
               }
           }
       }
   
     (*s_etat_processus).instruction_courante = (unsigned char *)      (*s_etat_processus).instruction_courante = (unsigned char *)
                 malloc((((size_t) (pointeur_fin_instruction                  malloc((((size_t) (pointeur_fin_instruction
                 - pointeur_debut_instruction)) + 1) * sizeof(unsigned char));                  - pointeur_debut_instruction)) + 1) * sizeof(unsigned char));
Line 1764  recherche_instruction_suivante(struct_pr Line 1820  recherche_instruction_suivante(struct_pr
         (*(*s_etat_processus).instruction_courante) = d_code_fin_chaine;          (*(*s_etat_processus).instruction_courante) = d_code_fin_chaine;
     }      }
   
 uprintf("%c %s\n", caractere_fin, (*s_etat_processus).instruction_courante);  
     (*s_etat_processus).position_courante = pointeur_fin_instruction      (*s_etat_processus).position_courante = pointeur_fin_instruction
             - (*s_etat_processus).definitions_chainees;              - (*s_etat_processus).definitions_chainees;
   
Line 1774  uprintf("%c %s\n", caractere_fin, (*s_et Line 1829  uprintf("%c %s\n", caractere_fin, (*s_et
   
 /*  /*
 ================================================================================  ================================================================================
   Routine mettant la chaine d'entrée en majuscule    Routine mettant la chaîne d'entrée en majuscule
 ================================================================================  ================================================================================
   Entrée : pointeur sur une chaine en minuscules.    Entrée : pointeur sur une chaîne en minuscules.
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Sortie : pointeur sur la chaine en majuscules. Si le pointeur retourné    Sortie : pointeur sur la chaîne en majuscules. Si le pointeur retourné
     est nul, il s'est produit une erreur. L'allocation est faite dans la      est nul, il s'est produit une erreur. L'allocation est faite dans la
     routine.      routine.
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Removed from v.1.68  
changed lines
  Added in v.1.69

CVSweb interface <joel.bertrand@systella.fr>