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

version 1.71, 2015/01/05 15:32:12 version 1.72, 2015/01/27 14:18:05
Line 20 Line 20
 */  */
   
   
 #define DEBUG_ERREURS  
 #include "rpl-conv.h"  #include "rpl-conv.h"
   
   
Line 371  typedef struct pile Line 370  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 388  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 416  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 474  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 492  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 506  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 519  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 537  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 553  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 569  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 591  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 601  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 620  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 634  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 649  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 663  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 678  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 688  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 703  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 717  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 732  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 742  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 759  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 772  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 789  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 799  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 816  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 829  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 842  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 1843  recherche_instruction_suivante_recursive Line 1717  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.72

CVSweb interface <joel.bertrand@systella.fr>