[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.84

version 1.71, 2015/01/05 15:32:12 version 1.84, 2015/11/26 11:44:29
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.20    RPL/2 (R) version 4.1.24
   Copyright (C) 1989-2015 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
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 1605  recherche_instruction_suivante_recursive Line 1489  recherche_instruction_suivante_recursive
                             pointeur_caractere_courant++;                              pointeur_caractere_courant++;
                         }                          }
   
                         if ((*pointeur_caractere_courant) == '>')                          if (((*pointeur_caractere_courant) == '>') &&
                                   ((*(pointeur_caractere_courant - 1)) ==
                                   d_code_espace))
                         {                          {
                             if ((*(++pointeur_caractere_courant)) == '>')                              pointeur_caractere_courant++;
                             {  
                               if ((*pointeur_caractere_courant) == '>')
                               {   // Cas de '>>'
                                 drapeau_fin_objet = d_vrai;                                  drapeau_fin_objet = d_vrai;
                                   pointeur_caractere_courant++;
                                   break;
                             }                              }
                             else                              else if ((*pointeur_caractere_courant) == '=')
                             {                              {   // Cas de '>='
                                   pointeur_caractere_courant++;
                               }
                               else if ((*pointeur_caractere_courant) !=
                                       d_code_espace)
                               {   // Tous les cas différents de '>'
                                 erreur_analyse = d_ex_syntaxe;                                  erreur_analyse = d_ex_syntaxe;
                                   break;
                             }                              }
   
                             pointeur_caractere_courant++;                              pointeur_caractere_courant--;
                             break;  
                         }                          }
   
                         if ((erreur_format == d_absence_erreur) &&                          if ((erreur_format == d_absence_erreur) &&
Line 1785  recherche_instruction_suivante_recursive Line 1680  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 1815  recherche_instruction_suivante_recursive Line 1710  recherche_instruction_suivante_recursive
         erreur = ((erreur_analyse == d_ex) && (erreur_format == d_ex))          erreur = ((erreur_analyse == d_ex) && (erreur_format == d_ex))
                 ? d_absence_erreur : d_erreur;                  ? d_absence_erreur : d_erreur;
         (*s_etat_processus).erreur_execution = erreur_analyse;          (*s_etat_processus).erreur_execution = erreur_analyse;
   
           if ((*s_etat_processus).erreur_execution == d_ex)
           {
               (*s_etat_processus).erreur_execution = erreur_format;
           }
     }      }
     else      else
     {      {
Line 1843  recherche_instruction_suivante_recursive Line 1743  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.84

CVSweb interface <joel.bertrand@systella.fr>