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

Diff for /rpl/src/compilation.c between versions 1.39 and 1.53

version 1.39, 2012/01/25 16:38:30 version 1.53, 2012/12/19 09:58:22
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.6    RPL/2 (R) version 4.1.12
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2012 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
Line 358  compilation(struct_processus *s_etat_pro Line 358  compilation(struct_processus *s_etat_pro
 ================================================================================  ================================================================================
 */  */
   
 logical1  enum t_condition    { AN_IF = 1, AN_IFERR, AN_THEN, AN_ELSE, AN_ELSEIF,
 analyse_syntaxique(struct_processus *s_etat_processus)                      AN_END, AN_DO, AN_UNTIL, AN_WHILE, AN_REPEAT, AN_SELECT,
 {                      AN_CASE, AN_DEFAULT, AN_UP, AN_DOWN, AN_FOR, AN_START,
     enum t_condition    { AN_IF = 1, AN_IFERR, AN_THEN, AN_ELSE, AN_ELSEIF,                      AN_NEXT, AN_STEP, AN_CRITICAL, AN_FORALL };
                         AN_END, AN_DO, AN_UNTIL, AN_WHILE, AN_REPEAT, AN_SELECT,  
                         AN_CASE, AN_DEFAULT, AN_UP, AN_DOWN, AN_FOR, AN_START,  
                         AN_NEXT, AN_STEP };  
   
     unsigned char       *instruction;  
     unsigned char       registre;  
   
     typedef struct pile  
     {  
         enum t_condition    condition;  
         struct pile         *suivant;  
     } struct_pile_analyse;  
   
     struct_pile_analyse     *l_base_pile;  typedef struct pile
     struct_pile_analyse     *l_nouvelle_base_pile;  {
       enum t_condition    condition;
       struct pile         *suivant;
   } struct_pile_analyse;
   
   static inline struct_pile_analyse *
   empilement_analyse(struct_pile_analyse *ancienne_base,
           enum t_condition condition)
   {
       struct_pile_analyse     *nouvelle_base;
   
     inline struct_pile_analyse *      if ((nouvelle_base = malloc(sizeof(struct_pile_analyse))) == NULL)
     empilement_analyse(struct_pile_analyse *ancienne_base,  
             enum t_condition condition)  
     {      {
         struct_pile_analyse     *nouvelle_base;          return(NULL);
       }
   
         if ((nouvelle_base = malloc(sizeof(struct_pile_analyse))) == NULL)      (*nouvelle_base).suivant = ancienne_base;
         {      (*nouvelle_base).condition = condition;
             return(NULL);  
         }  
   
         (*nouvelle_base).suivant = ancienne_base;      return(nouvelle_base);
         (*nouvelle_base).condition = condition;  }
   
         return(nouvelle_base);  static inline struct_pile_analyse *
     }  depilement_analyse(struct_pile_analyse *ancienne_base)
   {
       struct_pile_analyse     *nouvelle_base;
   
     inline struct_pile_analyse *      if (ancienne_base == NULL)
     depilement_analyse(struct_pile_analyse *ancienne_base)  
     {      {
         struct_pile_analyse     *nouvelle_base;          return(NULL);
       }
   
         if (ancienne_base == NULL)      nouvelle_base = (*ancienne_base).suivant;
         {      free(ancienne_base);
             return(NULL);  
         }  
   
         nouvelle_base = (*ancienne_base).suivant;      return(nouvelle_base);
         free(ancienne_base);  }
   
         return(nouvelle_base);  static inline logical1
   test_analyse(struct_pile_analyse *l_base_pile, enum t_condition condition)
   {
       if (l_base_pile == NULL)
       {
           return(d_faux);
     }      }
   
     inline logical1      return(((*l_base_pile).condition == condition) ? d_vrai : d_faux);
     test_analyse(struct_pile_analyse *l_base_pile, enum t_condition condition)  }
     {  
         if (l_base_pile == NULL)  
         {  
             return(d_faux);  
         }  
   
         return(((*l_base_pile).condition == condition) ? d_vrai : d_faux);  static inline void
     }  liberation_analyse(struct_pile_analyse *l_base_pile)
   {
       struct_pile_analyse     *l_nouvelle_base_pile;
   
     inline void      while(l_base_pile != NULL)
     liberation_analyse(struct_pile_analyse *l_base_pile)  
     {      {
         struct_pile_analyse     *l_nouvelle_base_pile;          l_nouvelle_base_pile = (*l_base_pile).suivant;
           free(l_base_pile);
           l_base_pile = l_nouvelle_base_pile;
       }
   
         while(l_base_pile != NULL)      return;
         {  }
             l_nouvelle_base_pile = (*l_base_pile).suivant;  
             free(l_base_pile);  
             l_base_pile = l_nouvelle_base_pile;  
         }  
   
         return;  logical1
     }  analyse_syntaxique(struct_processus *s_etat_processus)
   {
       unsigned char       *instruction;
       unsigned char       registre;
   
       struct_pile_analyse     *l_base_pile;
       struct_pile_analyse     *l_nouvelle_base_pile;
   
     l_base_pile = NULL;      l_base_pile = NULL;
     l_nouvelle_base_pile = NULL;      l_nouvelle_base_pile = NULL;
Line 514  analyse_syntaxique(struct_processus *s_e Line 514  analyse_syntaxique(struct_processus *s_e
   
             l_base_pile = l_nouvelle_base_pile;              l_base_pile = l_nouvelle_base_pile;
         }          }
           else if (strcmp(instruction, "CRITICAL") == 0)
           {
               if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,
                       AN_CRITICAL)) == NULL)
               {
                   liberation_analyse(l_base_pile);
   
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(d_erreur);
               }
   
               l_base_pile = l_nouvelle_base_pile;
           }
         else if (strcmp(instruction, "THEN") == 0)          else if (strcmp(instruction, "THEN") == 0)
         {          {
             if ((test_analyse(l_base_pile, AN_IF) == d_faux) &&              if ((test_analyse(l_base_pile, AN_IF) == d_faux) &&
Line 572  analyse_syntaxique(struct_processus *s_e Line 585  analyse_syntaxique(struct_processus *s_e
                     (test_analyse(l_base_pile, AN_DEFAULT) == d_faux) &&                      (test_analyse(l_base_pile, AN_DEFAULT) == d_faux) &&
                     (test_analyse(l_base_pile, AN_SELECT) == d_faux) &&                      (test_analyse(l_base_pile, AN_SELECT) == d_faux) &&
                     (test_analyse(l_base_pile, AN_THEN) == d_faux) &&                      (test_analyse(l_base_pile, AN_THEN) == 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(l_base_pile);
Line 753  analyse_syntaxique(struct_processus *s_e Line 767  analyse_syntaxique(struct_processus *s_e
   
             l_base_pile = l_nouvelle_base_pile;              l_base_pile = l_nouvelle_base_pile;
         }          }
           else if (strcmp(instruction, "FORALL") == 0)
           {
               if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,
                       AN_FORALL)) == NULL)
               {
                   liberation_analyse(l_base_pile);
   
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(d_erreur);
               }
   
               l_base_pile = l_nouvelle_base_pile;
           }
         else if (strcmp(instruction, "NEXT") == 0)          else if (strcmp(instruction, "NEXT") == 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_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(l_base_pile);
Line 822  analyse_syntaxique(struct_processus *s_e Line 850  analyse_syntaxique(struct_processus *s_e
 ================================================================================  ================================================================================
 */  */
   
   static char                 *ligne = NULL;
   static unsigned int         niveau = 0;
   
 int  int
 readline_analyse_syntaxique(int count, int key)  readline_analyse_syntaxique(int count, int key)
 {  {
     struct_processus            s_etat_processus;      char                        prompt[] = "+ %03d> ";
       char                        prompt2[8];
       char                        *registre;
   
     s_etat_processus.definitions_chainees = rl_line_buffer;      struct_processus            s_etat_processus;
     s_etat_processus.debug = d_faux;  
   
     if ((*rl_line_buffer) == d_code_fin_chaine)      if ((*rl_line_buffer) == d_code_fin_chaine)
     {      {
         rl_done = 1;          if (ligne == NULL)
           {
               rl_done = 1;
           }
           else
           {
               rl_done = 0;
           }
     }      }
     else      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)          if (analyse_syntaxique(&s_etat_processus) == d_absence_erreur)
         {          {
             rl_done = 1;              rl_done = 1;
         }          }
         else          else
         {          {
             rl_done = 0;              if (s_etat_processus.erreur_systeme != d_es)
             rl_mark = rl_end;              {
             rl_crlf();                  rl_done = 1;
             rl_expand_prompt("     > ");              }
             rl_on_new_line();              else
               {
                   rl_done = 0;
                   rl_crlf();
   
                   sprintf(prompt2, prompt, ++niveau);
   
                   rl_expand_prompt(prompt2);
                   rl_on_new_line();
               }
         }          }
     }      }
   
     if (rl_done != 0)      if (rl_done != 0)
     {      {
         uprintf("\n");          uprintf("\n");
   
           if (ligne != NULL)
           {
               rl_replace_line(ligne, 1);
   
               free(ligne);
               ligne = NULL;
           }
   
           niveau = 0;
     }      }
   
     return(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);
   }
   
   
 /*  /*
 ================================================================================  ================================================================================
Removed from v.1.39  
changed lines
  Added in v.1.53

CVSweb interface <joel.bertrand@systella.fr>