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

Diff for /rpl/src/compilation.c between versions 1.45 and 1.104

version 1.45, 2012/04/13 14:12:46 version 1.104, 2024/01/17 16:57:09
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.8    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2024 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 54  compilation(struct_processus *s_etat_pro Line 54  compilation(struct_processus *s_etat_pro
     unsigned char           ouverture_definition;      unsigned char           ouverture_definition;
     unsigned char           position_debut_nom_definition_valide;      unsigned char           position_debut_nom_definition_valide;
   
     unsigned long           *adresse;      integer8                *adresse;
     unsigned long           i;      integer8                i;
     unsigned long           niveau_definition;      integer8                niveau_definition;
     unsigned long           niveau_definition_registre;      integer8                niveau_definition_registre;
     unsigned long           position_courante;      integer8                position_courante;
     unsigned long           position_debut_nom_definition;      integer8                position_debut_nom_definition;
     unsigned long           position_fin_nom_definition;      integer8                position_fin_nom_definition;
     unsigned long           validation;      integer8                validation;
     unsigned long           validation_registre;      integer8                validation_registre;
   
     (*s_etat_processus).erreur_compilation = d_ec;      (*s_etat_processus).erreur_compilation = d_ec;
     (*s_etat_processus).erreur_systeme = d_es;      (*s_etat_processus).erreur_systeme = d_es;
Line 257  compilation(struct_processus *s_etat_pro Line 257  compilation(struct_processus *s_etat_pro
             s_variable = (struct_variable *)              s_variable = (struct_variable *)
                     malloc(sizeof(struct_variable));                      malloc(sizeof(struct_variable));
             adresse = (*s_objet).objet;              adresse = (*s_objet).objet;
             definition = (unsigned char *) malloc(              definition = (unsigned char *) malloc(((size_t)
                     (position_fin_nom_definition -                      (position_fin_nom_definition -
                     position_debut_nom_definition + 2) *                      position_debut_nom_definition + 2)) *
                     sizeof(unsigned char));                      sizeof(unsigned char));
   
             if ((s_objet == NULL) || (s_variable == NULL) ||              if ((s_objet == NULL) || (s_variable == NULL) ||
Line 281  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 290  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 311  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 358  compilation(struct_processus *s_etat_pro Line 368  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  typedef struct pile
     {  {
         enum t_condition    condition;      enum t_condition    condition;
         struct pile         *suivant;      struct pile         *suivant;
     } struct_pile_analyse;  } struct_pile_analyse;
   
     struct_pile_analyse     *l_base_pile;  static inline struct_pile_analyse *
     struct_pile_analyse     *l_nouvelle_base_pile;  empilement_analyse(struct_processus *s_etat_processus,
           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_processus *s_etat_processus,
           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_processus *s_etat_processus,
           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 471  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 489  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 503  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(s_etat_processus, 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, "CRITICAL") == 0)
           {
               if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                       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 521  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 537  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 553  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 572  analyse_syntaxique(struct_processus *s_e Line 598  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(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 584  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 603  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 617  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 632  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 646  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 661  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 671  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 686  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 700  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 715  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 725  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 742  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(s_etat_processus, 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, "FORALL") == 0)
           {
               if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
                       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 756  analyse_syntaxique(struct_processus *s_e Line 796  analyse_syntaxique(struct_processus *s_e
         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(s_etat_processus, l_base_pile);
   
                 (*s_etat_processus).autorisation_empilement_programme =                  (*s_etat_processus).autorisation_empilement_programme =
                         registre;                          registre;
Line 768  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 785  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 798  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 811  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 952  readline_effacement(int count, int key) Line 865  readline_effacement(int count, int key)
 */  */
   
 void  void
 swap(void *variable_1, void *variable_2, unsigned long taille)  swap(void *variable_1, void *variable_2, integer8 taille)
 {  {
     register unsigned char      *t_var_1;      register unsigned char      *t_var_1;
     register unsigned char      *t_var_2;      register unsigned char      *t_var_2;
     register unsigned char      variable_temporaire;      register unsigned char      variable_temporaire;
   
     register unsigned long      i;      register integer8           i;
   
     t_var_1 = (unsigned char *) variable_1;      t_var_1 = (unsigned char *) variable_1;
     t_var_2 = (unsigned char *) variable_2;      t_var_2 = (unsigned char *) variable_2;
Line 989  swap(void *variable_1, void *variable_2, Line 902  swap(void *variable_1, void *variable_2,
 logical1  logical1
 recherche_instruction_suivante(struct_processus *s_etat_processus)  recherche_instruction_suivante(struct_processus *s_etat_processus)
 {  {
       return(recherche_instruction_suivante_recursive(s_etat_processus, 0));
   }
   
   logical1
   recherche_instruction_suivante_recursive(struct_processus *s_etat_processus,
           integer8 recursivite)
   {
       enum t_type                 registre_type_en_cours;
   
     logical1                    drapeau_fin_objet;      logical1                    drapeau_fin_objet;
     logical1                    erreur;      logical1                    erreur;
     logical1                    erreur_analyse;  
     logical1                    erreur_format;      int                         erreur_analyse;
       int                         erreur_format;
   
       integer8                    nombre_caracteres;
       integer8                    (*__type_parse)(struct_processus *, void **);
   
   
     unsigned char               base_binaire;      unsigned char               base_binaire;
       unsigned char               caractere_fin;
     unsigned char               *pointeur_caractere_courant;      unsigned char               *pointeur_caractere_courant;
     unsigned char               *pointeur_caractere_destination;      unsigned char               *pointeur_caractere_destination;
     unsigned char               *pointeur_debut_instruction;      unsigned char               *pointeur_debut_instruction;
     unsigned char               *pointeur_fin_instruction;      unsigned char               *pointeur_fin_instruction;
   
     signed long                 niveau;      signed long                 niveau;
     signed long                 niveau_annexe;  
       struct_liste_chainee        *l_element_courant;
   
     erreur_analyse = d_ex;      erreur_analyse = d_ex;
     erreur_format = d_ex;      erreur_format = d_ex;
     erreur = d_absence_erreur;      erreur = d_absence_erreur;
   
       switch((*s_etat_processus).type_en_cours)
       {
           case RPN:
           {
               caractere_fin = '>';
               break;
           }
   
           case LST:
           {
               caractere_fin = '}';
               break;
           }
   
           case TBL:
           case REC:
           {
               caractere_fin = ']';
               break;
           }
   
           default:
           {
               caractere_fin = d_code_espace;
               break;
           }
       }
   
     drapeau_fin_objet = d_faux;      drapeau_fin_objet = d_faux;
     niveau = 0;      niveau = 0;
   
Line 1040  recherche_instruction_suivante(struct_pr Line 997  recherche_instruction_suivante(struct_pr
         return(erreur);          return(erreur);
     }      }
   
       /*
        * On regarde s'il existe des fonctions permettant de parser
        * les objets dans les bibliothèques externes.
        */
   
       l_element_courant = (*s_etat_processus).s_bibliotheques;
       (*s_etat_processus).position_courante = pointeur_caractere_courant
               - (*s_etat_processus).definitions_chainees;
   
       while(l_element_courant != NULL)
       {
           if ((__type_parse = dlsym((*((struct_bibliotheque *)
                   (*l_element_courant).donnee)).descripteur, "__type_parse"))
                   != NULL)
           {
               // Une fonction declareTypeExtension(parse) se trouve dans la
               // bibliothèque. Si cette fonction renvoie une valeur non nulle,
               // elle a réussi à parser correctement un objet.
   
               if ((nombre_caracteres = __type_parse(s_etat_processus, NULL)) != 0)
               {
                   if (((*s_etat_processus).instruction_courante =
                           malloc((((unsigned) nombre_caracteres) + 1)
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(d_erreur);
                   }
   
                   strncpy((*s_etat_processus).instruction_courante,
                           (*s_etat_processus).definitions_chainees +
                           (*s_etat_processus).position_courante,
                           (unsigned) nombre_caracteres);
                   (*s_etat_processus).instruction_courante[nombre_caracteres]
                           = d_code_fin_chaine;
   
                   (*s_etat_processus).position_courante += nombre_caracteres;
                   return(erreur);
               }
           }
   
           l_element_courant = (*l_element_courant).suivant;
       }
   
     pointeur_debut_instruction = pointeur_caractere_courant;      pointeur_debut_instruction = pointeur_caractere_courant;
   
     while(((*pointeur_caractere_courant) != d_code_espace) &&      while(((*pointeur_caractere_courant) != d_code_espace) &&
             ((*pointeur_caractere_courant) != d_code_fin_chaine) &&              ((*pointeur_caractere_courant) != d_code_fin_chaine) &&
             (drapeau_fin_objet == d_faux) &&              (drapeau_fin_objet == d_faux) &&
             (erreur_analyse == d_ex) &&              (erreur_analyse == d_ex) && (erreur_format == d_ex))
             (erreur_format == d_ex))  
     {      {
         switch(*pointeur_caractere_courant++)          switch(*pointeur_caractere_courant++)
         {          {
             case ']' :              case ']' :
             case '}' :              case '}' :
               {
                   break;
               }
   
             case ')' :              case ')' :
             {              {
                 erreur_format = d_ex_syntaxe;                  erreur_format = d_ex_syntaxe;
Line 1261  recherche_instruction_suivante(struct_pr Line 1266  recherche_instruction_suivante(struct_pr
                 pointeur_caractere_courant++;                  pointeur_caractere_courant++;
   
                 if (((*pointeur_caractere_courant) != d_code_fin_chaine) &&                  if (((*pointeur_caractere_courant) != d_code_fin_chaine) &&
                         ((*pointeur_caractere_courant) != ' '))                          ((*pointeur_caractere_courant) != d_code_espace) &&
                           ((*pointeur_caractere_courant) != caractere_fin))
                 {                  {
                     erreur_analyse = d_ex_syntaxe;                      erreur_analyse = d_ex_syntaxe;
                 }                  }
Line 1385  recherche_instruction_suivante(struct_pr Line 1391  recherche_instruction_suivante(struct_pr
                 }                  }
   
                 niveau = 1;                  niveau = 1;
                 niveau_annexe = 0;  
   
                 while((niveau != 0) && ((*pointeur_caractere_courant) !=                  while((niveau != 0) && ((*pointeur_caractere_courant) !=
                         d_code_fin_chaine))                          d_code_fin_chaine))
                 {                  {
                     switch(*pointeur_caractere_courant)                      (*s_etat_processus).position_courante =
                     {                              pointeur_caractere_courant
                         case '{' :                              - (*s_etat_processus).definitions_chainees;
                         {  
                             if (niveau_annexe == 0)  
                             {  
                                 niveau++;  
                             }  
                             else  
                             {  
                                 erreur_analyse = d_ex_syntaxe;  
                             }  
   
                             break;  
                         }  
   
                         case '}' :  
                         {  
                             if (niveau_annexe == 0)  
                             {  
                                 niveau--;  
                             }  
                             else  
                             {  
                                 erreur_analyse = d_ex_syntaxe;  
                             }  
   
                             break;  
                         }  
   
                         case '[' :  
                         {  
                             niveau_annexe++;  
   
                             if (niveau_annexe > 2)                      registre_type_en_cours = (*s_etat_processus).type_en_cours;
                             {                      (*s_etat_processus).type_en_cours = LST;
                                 erreur_analyse = d_ex_syntaxe;  
                             }  
   
                             break;                      if (recherche_instruction_suivante_recursive(
                         }                              s_etat_processus, recursivite + 1) == d_erreur)
                       {
                           (*s_etat_processus).type_en_cours =
                                   registre_type_en_cours;
   
                         case ']' :                          if ((*s_etat_processus).instruction_courante
                                   != NULL)
                         {                          {
                             niveau_annexe--;                              free((*s_etat_processus).instruction_courante);
                               (*s_etat_processus).instruction_courante = NULL;
                             if (niveau_annexe < 0)  
                             {  
                                 erreur_analyse = d_ex_syntaxe;  
                             }  
   
                             break;  
                         }                          }
   
                         case '"' :                          return(d_erreur);
                         {                      }
                             if (niveau_annexe == 0)  
                             {  
                                 pointeur_caractere_courant++;  
   
                                 while((*pointeur_caractere_courant != '"') &&                      (*s_etat_processus).type_en_cours = registre_type_en_cours;
                                         ((*pointeur_caractere_courant) !=                      pointeur_caractere_courant =
                                         d_code_fin_chaine))                              (*s_etat_processus).definitions_chainees +
                                 {                              (*s_etat_processus).position_courante;
                                     if (*pointeur_caractere_courant == '\\')  
                                     {  
                                         pointeur_caractere_courant++;  
   
                                         switch(*pointeur_caractere_courant)  
                                         {  
                                             case '\\' :  
                                             case '"' :  
                                             {  
                                                 pointeur_caractere_courant++;  
                                                 break;  
                                             }  
                                         }  
                                     }  
                                     else  
                                     {  
                                         pointeur_caractere_courant++;  
                                     }  
                                 }  
                             }  
                             else  
                             {  
                                 erreur_analyse = d_ex_syntaxe;  
                             }  
   
                             break;                      if (strcmp((*s_etat_processus).instruction_courante, "}")
                         }                              == 0)
                       {
                           niveau--;
                     }                      }
   
                     pointeur_caractere_courant++;                      free((*s_etat_processus).instruction_courante);
                 }                  }
   
                 if ((niveau != 0) || (niveau_annexe != 0))                  if (niveau != 0)
                 {                  {
                     erreur_analyse = d_ex_syntaxe;                      erreur_analyse = d_ex_syntaxe;
                 }                  }
Line 1577  recherche_instruction_suivante(struct_pr Line 1523  recherche_instruction_suivante(struct_pr
             {              {
                 if (((*s_etat_processus).autorisation_empilement_programme                  if (((*s_etat_processus).autorisation_empilement_programme
                         == 'Y') && ((*pointeur_caractere_courant) == '<'))                          == 'Y') && ((*pointeur_caractere_courant) == '<'))
                 {                  { // Cas << >>
                     if (pointeur_debut_instruction !=                      if (pointeur_debut_instruction !=
                             (pointeur_caractere_courant - 1))                              (pointeur_caractere_courant - 1))
                     {                      {
                         erreur_format = d_ex_syntaxe;                          erreur_format = d_ex_syntaxe;
                     }                      }
   
                     niveau = 1;                      pointeur_caractere_courant++;
                       drapeau_fin_objet = d_faux;
   
                     while((niveau != 0) && ((*pointeur_caractere_courant) !=                      while(((*pointeur_caractere_courant) != d_code_fin_chaine)
                             d_code_fin_chaine))                              && (erreur_format == d_absence_erreur))
                     {                      {
                         if (((*pointeur_caractere_courant) == '<') &&                          while((*pointeur_caractere_courant) == d_code_espace)
                                 ((*(pointeur_caractere_courant + 1)) == '<'))  
                         {                          {
                             niveau++;  
                             pointeur_caractere_courant++;                              pointeur_caractere_courant++;
                         }                          }
                         else if (((*pointeur_caractere_courant) == '>') &&  
                                 ((*(pointeur_caractere_courant + 1)) == '>'))                          if (((*pointeur_caractere_courant) == '>') &&
                                   ((*(pointeur_caractere_courant - 1)) ==
                                   d_code_espace))
                         {                          {
                             niveau--;  
                             pointeur_caractere_courant++;                              pointeur_caractere_courant++;
   
                               if ((*pointeur_caractere_courant) == '>')
                               {   // Cas de '>>'
                                   drapeau_fin_objet = d_vrai;
                                   pointeur_caractere_courant++;
                                   break;
                               }
                               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;
                                   break;
                               }
   
                               pointeur_caractere_courant--;
                         }                          }
                         else if ((*pointeur_caractere_courant) == '"')  
                           if ((erreur_format == d_absence_erreur) &&
                                   (drapeau_fin_objet == d_faux))
                         {                          {
                             pointeur_caractere_courant++;                              (*s_etat_processus).position_courante =
                                       pointeur_caractere_courant
                                       - (*s_etat_processus).definitions_chainees;
   
                             while((*pointeur_caractere_courant != '"') &&                              registre_type_en_cours = (*s_etat_processus)
                                     ((*pointeur_caractere_courant) !=                                      .type_en_cours;
                                     d_code_fin_chaine))                              (*s_etat_processus).type_en_cours = RPN;
   
                               if ((erreur =
                                       recherche_instruction_suivante_recursive(
                                       s_etat_processus, recursivite + 1))
                                       != d_absence_erreur)
                             {                              {
                                 if (*pointeur_caractere_courant == '\\')                                  (*s_etat_processus).type_en_cours =
                                 {                                          registre_type_en_cours;
                                     pointeur_caractere_courant++;  
   
                                     switch(*pointeur_caractere_courant)                                  if ((*s_etat_processus).instruction_courante
                                     {                                          != NULL)
                                         case '\\' :  
                                         case '"' :  
                                         {  
                                             pointeur_caractere_courant++;  
                                             break;  
                                         }  
                                     }  
                                 }  
                                 else  
                                 {                                  {
                                     pointeur_caractere_courant++;                                      free((*s_etat_processus)
                                               .instruction_courante);
                                       (*s_etat_processus).instruction_courante
                                               = NULL;
                                 }                                  }
   
                                   return(d_erreur);
                             }                              }
                         }  
   
                         pointeur_caractere_courant++;                              (*s_etat_processus).type_en_cours =
                                       registre_type_en_cours;
                               pointeur_caractere_courant = (*s_etat_processus)
                                       .definitions_chainees + (*s_etat_processus)
                                       .position_courante;
   
                               free((*s_etat_processus).instruction_courante);
                           }
                     }                      }
   
                     if (niveau != 0)                      if (drapeau_fin_objet == d_faux)
                     {                      {
                         erreur_analyse = d_ex_syntaxe;                          erreur_analyse = d_ex_syntaxe;
                           drapeau_fin_objet = d_vrai;
                     }                      }
   
                     drapeau_fin_objet = d_vrai;  
                 }                  }
                 else if ((*pointeur_caractere_courant) == '[')                  else if ((*pointeur_caractere_courant) == '[')
                 {                  { // Cas <[ ]>
                     if (pointeur_debut_instruction !=                      if (pointeur_debut_instruction !=
                             (pointeur_caractere_courant - 1))                              (pointeur_caractere_courant - 1))
                     {                      {
Line 1681  recherche_instruction_suivante(struct_pr Line 1655  recherche_instruction_suivante(struct_pr
                                     pointeur_caractere_courant                                      pointeur_caractere_courant
                                     - (*s_etat_processus).definitions_chainees;                                      - (*s_etat_processus).definitions_chainees;
   
                             if ((erreur = recherche_instruction_suivante(                              registre_type_en_cours = (*s_etat_processus)
                                     s_etat_processus)) != d_absence_erreur)                                      .type_en_cours;
                               (*s_etat_processus).type_en_cours = TBL;
   
                               if ((erreur =
                                       recherche_instruction_suivante_recursive(
                                       s_etat_processus, recursivite + 1))
                                       != d_absence_erreur)
                               {
                                   (*s_etat_processus).type_en_cours =
                                           registre_type_en_cours;
   
                                   if ((*s_etat_processus).instruction_courante
                                           != NULL)
                                   {
                                       free((*s_etat_processus)
                                               .instruction_courante);
                                       (*s_etat_processus).instruction_courante
                                               = NULL;
                                   }
   
                                   return(d_erreur);
                               }
   
                               (*s_etat_processus).type_en_cours =
                                       registre_type_en_cours;
                               pointeur_caractere_courant = (*s_etat_processus)
                                       .definitions_chainees + (*s_etat_processus)
                                       .position_courante;
   
                               free((*s_etat_processus).instruction_courante);
                           }
                       }
   
                       if (drapeau_fin_objet == d_faux)
                       {
                           erreur_analyse = d_ex_syntaxe;
                           drapeau_fin_objet = d_vrai;
                       }
                   }
   
                   break;
               }
   
               case '|' :
               {
                   if ((*pointeur_caractere_courant) == '[')
                   { // Cas |[ ]|
                       if (pointeur_debut_instruction !=
                               (pointeur_caractere_courant - 1))
                       {
                           erreur_format = d_ex_syntaxe;
                       }
   
                       pointeur_caractere_courant++;
                       drapeau_fin_objet = d_faux;
   
                       while(((*pointeur_caractere_courant) != d_code_fin_chaine)
                               && (erreur_format == d_absence_erreur))
                       {
                           while((*pointeur_caractere_courant) == d_code_espace)
                           {
                               pointeur_caractere_courant++;
                           }
   
                           if ((*pointeur_caractere_courant) == ']')
                           {
                               if ((*(++pointeur_caractere_courant)) == '|')
                               {
                                   drapeau_fin_objet = d_vrai;
                               }
                               else
                               {
                                   erreur_analyse = d_ex_syntaxe;
                               }
   
                               pointeur_caractere_courant++;
                               break;
                           }
   
                           if ((erreur_format == d_absence_erreur) &&
                                   (drapeau_fin_objet == d_faux))
                           {
                               (*s_etat_processus).position_courante =
                                       pointeur_caractere_courant
                                       - (*s_etat_processus).definitions_chainees;
   
                               registre_type_en_cours = (*s_etat_processus)
                                       .type_en_cours;
                               (*s_etat_processus).type_en_cours = REC;
   
                               if ((erreur =
                                       recherche_instruction_suivante_recursive(
                                       s_etat_processus, recursivite + 1))
                                       != d_absence_erreur)
                             {                              {
                                   (*s_etat_processus).type_en_cours =
                                           registre_type_en_cours;
   
                                 if ((*s_etat_processus).instruction_courante                                  if ((*s_etat_processus).instruction_courante
                                         != NULL)                                          != NULL)
                                 {                                  {
                                     free((*s_etat_processus)                                      free((*s_etat_processus)
                                             .instruction_courante);                                              .instruction_courante);
                                       (*s_etat_processus).instruction_courante
                                               = NULL;
                                 }                                  }
   
                                 return(d_erreur);                                  return(d_erreur);
                             }                              }
   
                               (*s_etat_processus).type_en_cours =
                                       registre_type_en_cours;
                             pointeur_caractere_courant = (*s_etat_processus)                              pointeur_caractere_courant = (*s_etat_processus)
                                     .definitions_chainees + (*s_etat_processus)                                      .definitions_chainees + (*s_etat_processus)
                                     .position_courante;                                      .position_courante;
Line 1712  recherche_instruction_suivante(struct_pr Line 1786  recherche_instruction_suivante(struct_pr
                 break;                  break;
             }              }
         }          }
   
           if ((*(pointeur_caractere_courant - 1)) == caractere_fin)
           {
               // Cas des objets composites (LST, RPN, TBL, REC)
               break;
           }
           else if ((*pointeur_caractere_courant) == caractere_fin)
           {
               // Condition pour traiter les cas "123}"
               break;
           }
     }      }
   
     pointeur_fin_instruction = pointeur_caractere_courant;      pointeur_fin_instruction = pointeur_caractere_courant;
   
       if (recursivite == 0)
       {
           // Si la variable récursivité est nulle, il faut que le caractère
           // suivant l'objet soit un espace ou une fin de chaîne. Si ce n'est pas
           // le cas, il faut retourner une erreur car les objets de type
           // [[ 1 4 ]]3 doivent être invalides.
   
           switch((*pointeur_fin_instruction))
           {
               case d_code_fin_chaine:
               case d_code_espace:
               {
                   break;
               }
   
               default:
               {
                   (*s_etat_processus).erreur_execution = d_ex_syntaxe;
   //              return(d_erreur);
               }
           }
       }
   
     (*s_etat_processus).instruction_courante = (unsigned char *)      (*s_etat_processus).instruction_courante = (unsigned char *)
                 malloc(((pointeur_fin_instruction - pointeur_debut_instruction)                  malloc((((size_t) (pointeur_fin_instruction
                 + 1) * sizeof(unsigned char));                  - pointeur_debut_instruction)) + 1) * sizeof(unsigned char));
   
     if ((*s_etat_processus).instruction_courante == NULL)      if ((*s_etat_processus).instruction_courante == NULL)
     {      {
Line 1741  recherche_instruction_suivante(struct_pr Line 1849  recherche_instruction_suivante(struct_pr
         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 1756  recherche_instruction_suivante(struct_pr Line 1869  recherche_instruction_suivante(struct_pr
   
 /*  /*
 ================================================================================  ================================================================================
   Routine mettant la chaine d'entrée en majuscule    Routine mettant la chaîne d'entrée en majuscule
 ================================================================================  ================================================================================
   Entrée : pointeur sur une chaine en minuscules.    Entrée : pointeur sur une chaîne en minuscules.
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Sortie : pointeur sur la chaine en majuscules. Si le pointeur retourné    Sortie : pointeur sur la chaîne en majuscules. Si le pointeur retourné
     est nul, il s'est produit une erreur. L'allocation est faite dans la      est nul, il s'est produit une erreur. L'allocation est faite dans la
     routine.      routine.
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 1769  recherche_instruction_suivante(struct_pr Line 1882  recherche_instruction_suivante(struct_pr
 */  */
   
 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;
     register unsigned char      *chaine_convertie;      register unsigned char      *chaine_convertie;
   
     unsigned long               longueur_chaine_plus_terminaison;      integer8                    longueur_chaine_plus_terminaison;
   
     longueur_chaine_plus_terminaison = 0;      longueur_chaine_plus_terminaison = 0;
     caractere_courant = chaine;      caractere_courant = chaine;
Line 1788  conversion_majuscule(unsigned char *chai Line 1901  conversion_majuscule(unsigned char *chai
   
     caractere_courant = chaine;      caractere_courant = chaine;
     caractere_courant_converti = chaine_convertie = (unsigned char *) malloc(      caractere_courant_converti = chaine_convertie = (unsigned char *) malloc(
             (longueur_chaine_plus_terminaison + 1) * sizeof(unsigned char));              ((size_t) (longueur_chaine_plus_terminaison + 1))
               * sizeof(unsigned char));
   
     if (chaine_convertie != NULL)      if (chaine_convertie != NULL)
     {      {
Line 1816  conversion_majuscule(unsigned char *chai Line 1930  conversion_majuscule(unsigned char *chai
   
 void  void
 conversion_majuscule_limitee(unsigned char *chaine_entree,  conversion_majuscule_limitee(unsigned char *chaine_entree,
         unsigned char *chaine_sortie, unsigned long longueur)          unsigned char *chaine_sortie, integer8 longueur)
 {  {
     unsigned long           i;      integer8            i;
   
     for(i = 0; i < longueur; i++)      for(i = 0; i < longueur; i++)
     {      {
Line 1862  initialisation_drapeaux(struct_processus Line 1976  initialisation_drapeaux(struct_processus
 {  {
     unsigned long                   i;      unsigned long                   i;
   
     for(i = 0; i < 31; cf(s_etat_processus, i++));      for(i = 0; i < 31; cf(s_etat_processus, (unsigned char) i++));
   
     if ((*s_etat_processus).lancement_interactif == d_vrai)      if ((*s_etat_processus).lancement_interactif == d_vrai)
     {      {
Removed from v.1.45  
changed lines
  Added in v.1.104

CVSweb interface <joel.bertrand@systella.fr>