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

Diff for /rpl/src/compilation.c between versions 1.71 and 1.74

version 1.71, 2015/01/05 15:32:12 version 1.74, 2015/01/28 20:58:02
Line 20 Line 20
 */  */
   
   
 #define DEBUG_ERREURS  
 #include "rpl-conv.h"  #include "rpl-conv.h"
   
   
Line 282  compilation(struct_processus *s_etat_pro Line 281  compilation(struct_processus *s_etat_pro
   
                 while(i <= position_fin_nom_definition)                  while(i <= position_fin_nom_definition)
                 {                  {
                       if ((*s_etat_processus).pointeurs_caracteres_variables
                               [(*s_etat_processus).definitions_chainees[i]] < 0)
                       {
                           free(s_variable);
   
                           (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                           return(d_erreur);
                       }
   
                     *(definition++) = (*s_etat_processus)                      *(definition++) = (*s_etat_processus)
                             .definitions_chainees[i++];                              .definitions_chainees[i++];
                 }                  }
Line 291  compilation(struct_processus *s_etat_pro Line 299  compilation(struct_processus *s_etat_pro
                 if (recherche_variable(s_etat_processus, (*s_variable).nom)                  if (recherche_variable(s_etat_processus, (*s_variable).nom)
                         == d_vrai)                          == d_vrai)
                 {                  {
                       free(s_variable);
   
                     if ((*s_etat_processus).langue == 'F')                      if ((*s_etat_processus).langue == 'F')
                     {                      {
                         printf("+++Attention : Plusieurs définitions de"                          printf("+++Attention : Plusieurs définitions de"
Line 312  compilation(struct_processus *s_etat_pro Line 322  compilation(struct_processus *s_etat_pro
                 if ((*s_etat_processus).erreur_systeme != d_es)                  if ((*s_etat_processus).erreur_systeme != d_es)
                 {                  {
                     free(s_variable);                      free(s_variable);
   
                     return(d_erreur);                      return(d_erreur);
                 }                  }
   
Line 371  typedef struct pile Line 380  typedef struct pile
 } struct_pile_analyse;  } struct_pile_analyse;
   
 static inline struct_pile_analyse *  static inline struct_pile_analyse *
 empilement_analyse(struct_pile_analyse *ancienne_base,  empilement_analyse(struct_processus *s_etat_processus,
           struct_pile_analyse *ancienne_base,
         enum t_condition condition)          enum t_condition condition)
 {  {
     struct_pile_analyse     *nouvelle_base;      struct_pile_analyse     *nouvelle_base;
Line 388  empilement_analyse(struct_pile_analyse * Line 398  empilement_analyse(struct_pile_analyse *
 }  }
   
 static inline struct_pile_analyse *  static inline struct_pile_analyse *
 depilement_analyse(struct_pile_analyse *ancienne_base)  depilement_analyse(struct_processus *s_etat_processus,
           struct_pile_analyse *ancienne_base)
 {  {
     struct_pile_analyse     *nouvelle_base;      struct_pile_analyse     *nouvelle_base;
   
Line 415  test_analyse(struct_pile_analyse *l_base Line 426  test_analyse(struct_pile_analyse *l_base
 }  }
   
 static inline void  static inline void
 liberation_analyse(struct_pile_analyse *l_base_pile)  liberation_analyse(struct_processus *s_etat_processus,
           struct_pile_analyse *l_base_pile)
 {  {
     struct_pile_analyse     *l_nouvelle_base_pile;      struct_pile_analyse     *l_nouvelle_base_pile;
   
Line 472  analyse_syntaxique(struct_processus *s_e Line 484  analyse_syntaxique(struct_processus *s_e
         if (recherche_instruction_suivante(s_etat_processus) !=          if (recherche_instruction_suivante(s_etat_processus) !=
                 d_absence_erreur)                  d_absence_erreur)
         {          {
             liberation_analyse(l_base_pile);              liberation_analyse(s_etat_processus, l_base_pile);
   
             (*s_etat_processus).autorisation_empilement_programme = registre;              (*s_etat_processus).autorisation_empilement_programme = registre;
             return(d_erreur);              return(d_erreur);
         }          }
   
         if ((instruction = conversion_majuscule(          if ((instruction = conversion_majuscule(s_etat_processus,
                 (*s_etat_processus).instruction_courante)) == NULL)                  (*s_etat_processus).instruction_courante)) == NULL)
         {          {
             liberation_analyse(l_base_pile);              liberation_analyse(s_etat_processus, l_base_pile);
   
             (*s_etat_processus).autorisation_empilement_programme = registre;              (*s_etat_processus).autorisation_empilement_programme = registre;
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 490  analyse_syntaxique(struct_processus *s_e Line 502  analyse_syntaxique(struct_processus *s_e
   
         if (strcmp(instruction, "IF") == 0)          if (strcmp(instruction, "IF") == 0)
         {          {
             if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_IF))              if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                     == NULL)                      l_base_pile, AN_IF)) == NULL)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(d_erreur);                  return(d_erreur);
Line 504  analyse_syntaxique(struct_processus *s_e Line 516  analyse_syntaxique(struct_processus *s_e
         }          }
         else if (strcmp(instruction, "IFERR") == 0)          else if (strcmp(instruction, "IFERR") == 0)
         {          {
             if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,              if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                     AN_IFERR)) == NULL)                      l_base_pile, AN_IFERR)) == NULL)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(d_erreur);                  return(d_erreur);
Line 517  analyse_syntaxique(struct_processus *s_e Line 529  analyse_syntaxique(struct_processus *s_e
         }          }
         else if (strcmp(instruction, "CRITICAL") == 0)          else if (strcmp(instruction, "CRITICAL") == 0)
         {          {
             if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,              if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                     AN_CRITICAL)) == NULL)                      l_base_pile, AN_CRITICAL)) == NULL)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(d_erreur);                  return(d_erreur);
Line 535  analyse_syntaxique(struct_processus *s_e Line 547  analyse_syntaxique(struct_processus *s_e
                     (test_analyse(l_base_pile, AN_CASE) == d_faux) &&                      (test_analyse(l_base_pile, AN_CASE) == d_faux) &&
                     (test_analyse(l_base_pile, AN_IFERR) == d_faux))                      (test_analyse(l_base_pile, AN_IFERR) == d_faux))
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 551  analyse_syntaxique(struct_processus *s_e Line 563  analyse_syntaxique(struct_processus *s_e
         {          {
             if (test_analyse(l_base_pile, AN_THEN) == d_faux)              if (test_analyse(l_base_pile, AN_THEN) == d_faux)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 567  analyse_syntaxique(struct_processus *s_e Line 579  analyse_syntaxique(struct_processus *s_e
         {          {
             if (test_analyse(l_base_pile, AN_THEN) == d_faux)              if (test_analyse(l_base_pile, AN_THEN) == d_faux)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 589  analyse_syntaxique(struct_processus *s_e Line 601  analyse_syntaxique(struct_processus *s_e
                     (test_analyse(l_base_pile, AN_CRITICAL) == d_faux) &&                      (test_analyse(l_base_pile, AN_CRITICAL) == d_faux) &&
                     (test_analyse(l_base_pile, AN_ELSE) == d_faux))                      (test_analyse(l_base_pile, AN_ELSE) == d_faux))
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 599  analyse_syntaxique(struct_processus *s_e Line 611  analyse_syntaxique(struct_processus *s_e
                 return(d_erreur);                  return(d_erreur);
             }              }
   
             l_base_pile = depilement_analyse(l_base_pile);              l_base_pile = depilement_analyse(s_etat_processus, l_base_pile);
         }          }
         else if (strcmp(instruction, "DO") == 0)          else if (strcmp(instruction, "DO") == 0)
         {          {
             if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_DO))              if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                     == NULL)                      l_base_pile, AN_DO)) == NULL)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(d_erreur);                  return(d_erreur);
Line 618  analyse_syntaxique(struct_processus *s_e Line 630  analyse_syntaxique(struct_processus *s_e
         {          {
             if (test_analyse(l_base_pile, AN_DO) == d_faux)              if (test_analyse(l_base_pile, AN_DO) == d_faux)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 632  analyse_syntaxique(struct_processus *s_e Line 644  analyse_syntaxique(struct_processus *s_e
         }          }
         else if (strcmp(instruction, "WHILE") == 0)          else if (strcmp(instruction, "WHILE") == 0)
         {          {
             if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,              if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                     AN_WHILE)) == NULL)                      l_base_pile, AN_WHILE)) == NULL)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(d_erreur);                  return(d_erreur);
Line 647  analyse_syntaxique(struct_processus *s_e Line 659  analyse_syntaxique(struct_processus *s_e
         {          {
             if (test_analyse(l_base_pile, AN_WHILE) == d_faux)              if (test_analyse(l_base_pile, AN_WHILE) == d_faux)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 661  analyse_syntaxique(struct_processus *s_e Line 673  analyse_syntaxique(struct_processus *s_e
         }          }
         else if (strcmp(instruction, "SELECT") == 0)          else if (strcmp(instruction, "SELECT") == 0)
         {          {
             if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,              if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                     AN_SELECT)) == NULL)                      l_base_pile, AN_SELECT)) == NULL)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(d_erreur);                  return(d_erreur);
Line 676  analyse_syntaxique(struct_processus *s_e Line 688  analyse_syntaxique(struct_processus *s_e
         {          {
             if (test_analyse(l_base_pile, AN_SELECT) == d_faux)              if (test_analyse(l_base_pile, AN_SELECT) == d_faux)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 686  analyse_syntaxique(struct_processus *s_e Line 698  analyse_syntaxique(struct_processus *s_e
                 return(d_erreur);                  return(d_erreur);
             }              }
   
             if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,              if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                     AN_CASE)) == NULL)                      l_base_pile, AN_CASE)) == NULL)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(d_erreur);                  return(d_erreur);
Line 701  analyse_syntaxique(struct_processus *s_e Line 713  analyse_syntaxique(struct_processus *s_e
         {          {
             if (test_analyse(l_base_pile, AN_SELECT) == d_faux)              if (test_analyse(l_base_pile, AN_SELECT) == d_faux)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 715  analyse_syntaxique(struct_processus *s_e Line 727  analyse_syntaxique(struct_processus *s_e
         }          }
         else if (strcmp(instruction, "<<") == 0)          else if (strcmp(instruction, "<<") == 0)
         {          {
             if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_UP))              if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                     == NULL)                      l_base_pile, AN_UP)) == NULL)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(d_erreur);                  return(d_erreur);
Line 730  analyse_syntaxique(struct_processus *s_e Line 742  analyse_syntaxique(struct_processus *s_e
         {          {
             if (test_analyse(l_base_pile, AN_UP) == d_faux)              if (test_analyse(l_base_pile, AN_UP) == d_faux)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 740  analyse_syntaxique(struct_processus *s_e Line 752  analyse_syntaxique(struct_processus *s_e
                 return(d_erreur);                  return(d_erreur);
             }              }
   
             l_base_pile = depilement_analyse(l_base_pile);              l_base_pile = depilement_analyse(s_etat_processus, l_base_pile);
         }          }
         else if (strcmp(instruction, "FOR") == 0)          else if (strcmp(instruction, "FOR") == 0)
         {          {
             if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_FOR))              if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                     == NULL)                      l_base_pile, AN_FOR)) == NULL)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(d_erreur);                  return(d_erreur);
Line 757  analyse_syntaxique(struct_processus *s_e Line 769  analyse_syntaxique(struct_processus *s_e
         }          }
         else if (strcmp(instruction, "START") == 0)          else if (strcmp(instruction, "START") == 0)
         {          {
             if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,              if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                     AN_START)) == NULL)                      l_base_pile, AN_START)) == NULL)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(d_erreur);                  return(d_erreur);
Line 770  analyse_syntaxique(struct_processus *s_e Line 782  analyse_syntaxique(struct_processus *s_e
         }          }
         else if (strcmp(instruction, "FORALL") == 0)          else if (strcmp(instruction, "FORALL") == 0)
         {          {
             if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,              if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                     AN_FORALL)) == NULL)                      l_base_pile, AN_FORALL)) == NULL)
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return(d_erreur);                  return(d_erreur);
Line 787  analyse_syntaxique(struct_processus *s_e Line 799  analyse_syntaxique(struct_processus *s_e
                     (test_analyse(l_base_pile, AN_FORALL) == d_faux) &&                      (test_analyse(l_base_pile, AN_FORALL) == d_faux) &&
                     (test_analyse(l_base_pile, AN_START) == d_faux))                      (test_analyse(l_base_pile, AN_START) == d_faux))
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 797  analyse_syntaxique(struct_processus *s_e Line 809  analyse_syntaxique(struct_processus *s_e
                 return(d_erreur);                  return(d_erreur);
             }              }
   
             l_base_pile = depilement_analyse(l_base_pile);              l_base_pile = depilement_analyse(s_etat_processus, l_base_pile);
         }          }
         else if (strcmp(instruction, "STEP") == 0)          else if (strcmp(instruction, "STEP") == 0)
         {          {
             if ((test_analyse(l_base_pile, AN_FOR) == d_faux) &&              if ((test_analyse(l_base_pile, AN_FOR) == d_faux) &&
                     (test_analyse(l_base_pile, AN_START) == d_faux))                      (test_analyse(l_base_pile, AN_START) == d_faux))
             {              {
                 liberation_analyse(l_base_pile);                  liberation_analyse(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 814  analyse_syntaxique(struct_processus *s_e Line 826  analyse_syntaxique(struct_processus *s_e
                 return(d_erreur);                  return(d_erreur);
             }              }
   
             l_base_pile = depilement_analyse(l_base_pile);              l_base_pile = depilement_analyse(s_etat_processus, l_base_pile);
         }          }
   
         // Invalidation de l'instruction courante dans le fichier rpl-core          // Invalidation de l'instruction courante dans le fichier rpl-core
Line 827  analyse_syntaxique(struct_processus *s_e Line 839  analyse_syntaxique(struct_processus *s_e
   
     if (l_base_pile != NULL)      if (l_base_pile != NULL)
     {      {
         liberation_analyse(l_base_pile);          liberation_analyse(s_etat_processus, l_base_pile);
   
         (*s_etat_processus).autorisation_empilement_programme = registre;          (*s_etat_processus).autorisation_empilement_programme = registre;
         (*s_etat_processus).erreur_compilation = d_ec_source_incoherent;          (*s_etat_processus).erreur_compilation = d_ec_source_incoherent;
Line 840  analyse_syntaxique(struct_processus *s_e Line 852  analyse_syntaxique(struct_processus *s_e
   
 /*  /*
 ================================================================================  ================================================================================
   Procédure de d'analyse syntaxique du source pour readline  
 ================================================================================  
   Entrées :  
 --------------------------------------------------------------------------------  
   Sorties :  
     - rl_done à 0 ou à 1.  
 --------------------------------------------------------------------------------  
   Effets de bord :  
 ================================================================================  
 */  
   
 static char                 *ligne = NULL;  
 static unsigned int         niveau = 0;  
   
 int  
 readline_analyse_syntaxique(int count, int key)  
 {  
     char                        prompt[] = "+ %03d> ";  
     char                        prompt2[8];  
     char                        *registre;  
   
     struct_processus            s_etat_processus;  
   
     if ((*rl_line_buffer) == d_code_fin_chaine)  
     {  
         if (ligne == NULL)  
         {  
             rl_done = 1;  
         }  
         else  
         {  
             rl_done = 0;  
         }  
     }  
     else  
     {  
         if (ligne == NULL)  
         {  
             if ((ligne = malloc((strlen(rl_line_buffer) + 1)  
                     * sizeof(char))) == NULL)  
             {  
                 rl_done = 1;  
                 return(0);  
             }  
   
             strcpy(ligne, rl_line_buffer);  
         }  
         else  
         {  
             registre = ligne;  
   
             if ((ligne = malloc((strlen(registre)  
                     + strlen(rl_line_buffer) + 2) * sizeof(char))) == NULL)  
             {  
                 rl_done = 1;  
                 return(0);  
             }  
   
             sprintf(ligne, "%s %s", registre, rl_line_buffer);  
         }  
   
         rl_replace_line("", 1);  
   
         s_etat_processus.definitions_chainees = ligne;  
         s_etat_processus.debug = d_faux;  
         s_etat_processus.erreur_systeme = d_es;  
         s_etat_processus.erreur_execution = d_ex;  
   
         if (analyse_syntaxique(&s_etat_processus) == d_absence_erreur)  
         {  
             rl_done = 1;  
         }  
         else  
         {  
             if (s_etat_processus.erreur_systeme != d_es)  
             {  
                 rl_done = 1;  
             }  
             else  
             {  
                 rl_done = 0;  
                 rl_crlf();  
   
                 sprintf(prompt2, prompt, ++niveau);  
   
                 rl_expand_prompt(prompt2);  
                 rl_on_new_line();  
             }  
         }  
     }  
   
     if (rl_done != 0)  
     {  
         uprintf("\n");  
   
         if (ligne != NULL)  
         {  
             rl_replace_line(ligne, 1);  
   
             free(ligne);  
             ligne = NULL;  
         }  
   
         niveau = 0;  
     }  
   
     return(0);  
 }  
   
 int  
 readline_effacement(int count, int key)  
 {  
     rl_done = 0;  
     rl_replace_line("", 1);  
   
     free(ligne);  
     ligne = NULL;  
     niveau = 0;  
   
     uprintf("^G\n");  
     rl_expand_prompt("RPL/2> ");  
     rl_on_new_line();  
     return(0);  
 }  
   
   
 /*  
 ================================================================================  
   Routine d'échange de deux variables    Routine d'échange de deux variables
 ================================================================================  ================================================================================
   Entrées :    Entrées :
Line 1113  recherche_instruction_suivante_recursive Line 997  recherche_instruction_suivante_recursive
             (drapeau_fin_objet == d_faux) &&              (drapeau_fin_objet == d_faux) &&
             (erreur_analyse == d_ex) && (erreur_format == d_ex))              (erreur_analyse == d_ex) && (erreur_format == d_ex))
     {      {
   uprintf("%c", *pointeur_caractere_courant);
         switch(*pointeur_caractere_courant++)          switch(*pointeur_caractere_courant++)
         {          {
             case ']' :              case ']' :
Line 1755  recherche_instruction_suivante_recursive Line 1640  recherche_instruction_suivante_recursive
   
         if ((*(pointeur_caractere_courant - 1)) == caractere_fin)          if ((*(pointeur_caractere_courant - 1)) == caractere_fin)
         {          {
   uprintf(" > cas 1");
             // Cas des objets composites (LST, RPN, TBL)              // Cas des objets composites (LST, RPN, TBL)
             break;              break;
         }          }
         else if ((*pointeur_caractere_courant) == caractere_fin)          else if ((*pointeur_caractere_courant) == caractere_fin)
         {          {
   uprintf(" > cas 2");
             // Condition pour traiter les cas 123}              // Condition pour traiter les cas 123}
             break;              break;
         }          }
     }      }
   uprintf("\n");
   
     pointeur_fin_instruction = pointeur_caractere_courant;      pointeur_fin_instruction = pointeur_caractere_courant;
   
Line 1785  recherche_instruction_suivante_recursive Line 1673  recherche_instruction_suivante_recursive
             default:              default:
             {              {
                 (*s_etat_processus).erreur_execution = d_ex_syntaxe;                  (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                 return(d_erreur);  //              return(d_erreur);
             }              }
         }          }
     }      }
Line 1824  recherche_instruction_suivante_recursive Line 1712  recherche_instruction_suivante_recursive
     (*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;
   
   uprintf("'%s'\n", (*s_etat_processus).instruction_courante);
     return(erreur);      return(erreur);
 }  }
   
Line 1843  recherche_instruction_suivante_recursive Line 1732  recherche_instruction_suivante_recursive
 */  */
   
 unsigned char *  unsigned char *
 conversion_majuscule(unsigned char *chaine)  conversion_majuscule(struct_processus *s_etat_processus, unsigned char *chaine)
 {  {
     register unsigned char      *caractere_courant;      register unsigned char      *caractere_courant;
     register unsigned char      *caractere_courant_converti;      register unsigned char      *caractere_courant_converti;
Removed from v.1.71  
changed lines
  Added in v.1.74

CVSweb interface <joel.bertrand@systella.fr>