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

Diff for /rpl/src/gestion_pile_systeme.c between versions 1.12 and 1.35

version 1.12, 2010/06/24 09:21:43 version 1.35, 2011/07/22 07:38:35
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.16    RPL/2 (R) version 4.1.1
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2011 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 131  empilement_pile_systeme(struct_processus Line 131  empilement_pile_systeme(struct_processus
     (*(*s_etat_processus).l_base_pile_systeme).clause = ' ';      (*(*s_etat_processus).l_base_pile_systeme).clause = ' ';
     (*(*s_etat_processus).l_base_pile_systeme).adresse_retour = 0;      (*(*s_etat_processus).l_base_pile_systeme).adresse_retour = 0;
     (*(*s_etat_processus).l_base_pile_systeme).niveau_courant = 0;      (*(*s_etat_processus).l_base_pile_systeme).niveau_courant = 0;
       (*(*s_etat_processus).l_base_pile_systeme).pointeur_adresse_retour = NULL;
     (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';      (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';
     (*(*s_etat_processus).l_base_pile_systeme).indice_boucle = NULL;      (*(*s_etat_processus).l_base_pile_systeme).indice_boucle = NULL;
     (*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = NULL;      (*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = NULL;
Line 301  effacement_pile_systeme(struct_processus Line 302  effacement_pile_systeme(struct_processus
 void  void
 trace(struct_processus *s_etat_processus, FILE *flux)  trace(struct_processus *s_etat_processus, FILE *flux)
 {  {
       integer8                        i;
       integer8                        candidat;
   
       long                            delta;
   
       struct_liste_chainee            *l_variable;
       struct_liste_chainee            *l_candidat;
   
     struct_liste_pile_systeme       *l_element_courant;      struct_liste_pile_systeme       *l_element_courant;
   
     integer8                        i;      unsigned char                   *tampon;
   
     l_element_courant = (*s_etat_processus).l_base_pile_systeme;      l_element_courant = (*s_etat_processus).l_base_pile_systeme;
     i = 0;      i = 0;
Line 324  trace(struct_processus *s_etat_processus Line 333  trace(struct_processus *s_etat_processus
   
     while(l_element_courant != NULL)      while(l_element_courant != NULL)
     {      {
         fprintf(flux, "%d : D=", i--);          fprintf(flux, "%d : (%016X) D=", i--, l_element_courant);
   
         fprintf(flux, ((*l_element_courant).creation_variables_statiques          fprintf(flux, ((*l_element_courant).creation_variables_statiques
                 == d_vrai) ? "1" : "0");                  == d_vrai) ? "1" : "0");
Line 344  trace(struct_processus *s_etat_processus Line 353  trace(struct_processus *s_etat_processus
   
         if ((*l_element_courant).retour_definition == 'Y')          if ((*l_element_courant).retour_definition == 'Y')
         {          {
             fprintf(flux, "RTRN ");              fprintf(flux, "RTN ");
   
             if ((*l_element_courant).origine_routine_evaluation == 'Y')              if ((*l_element_courant).origine_routine_evaluation == 'Y')
             {              {
                 fprintf(flux, "EVL ");                  fprintf(flux, "EVL ");
   
                 if ((*l_element_courant).adresse_retour != 0)  
                 {  
                     fprintf(flux, "P=%lu", (*l_element_courant)  
                             .adresse_retour);  
                 }  
             }              }
             else              else
             {              {
                 fprintf(flux, "SEQ ");                  fprintf(flux, "SEQ ");
   
                 if ((*l_element_courant).pointeur_objet_retour != NULL)                  if ((*l_element_courant).adresse_retour != 0)
                 {                  {
                     fprintf(flux, "A=%X", (*l_element_courant)                      fprintf(flux, "P=%016X", (*l_element_courant)
                             .pointeur_objet_retour);                              .adresse_retour);
   
                       // Calcul de la routine de départ
   
                       l_variable = (struct_liste_chainee *)
                               (*(*(*s_etat_processus)
                               .l_liste_variables_par_niveau).precedent).liste;
                       candidat = (*s_etat_processus)
                               .longueur_definitions_chainees;
                       l_candidat = NULL;
   
                       // l_variable balaie les variables de niveau 0.
   
                       while(l_variable != NULL)
                       {
                           if ((*(*((struct_variable *) (*l_variable).donnee))
                                   .objet).type == ADR)
                           {
                               delta = (*l_element_courant).adresse_retour
                                       - (*((unsigned long *)
                                       (*(*((struct_variable *) (*l_variable)
                                       .donnee)).objet).objet));
   
                               if ((delta > 0) && (delta < candidat))
                               {
                                   candidat = delta;
                                   l_candidat = l_variable;
                               }
                           }
   
                           l_variable = (*l_variable).suivant;
                       }
   
                       if (l_candidat != NULL)
                       {
                           fprintf(flux, "\n  Call from %s",
                                   (*((struct_variable *) (*l_candidat).donnee))
                                   .nom);
                       }
                       else
                       {
                           fprintf(flux, "\n  Call from RPL/2 initialization");
                       }
                   }
                   else
                   {
                       fprintf(flux, "RPL/2 initialization");
                 }                  }
             }              }
         }          }
Line 374  trace(struct_processus *s_etat_processus Line 423  trace(struct_processus *s_etat_processus
             if ((*l_element_courant).origine_routine_evaluation == 'Y')              if ((*l_element_courant).origine_routine_evaluation == 'Y')
             {              {
                 fprintf(flux, "EVL ");                  fprintf(flux, "EVL ");
   
                 if ((*l_element_courant).adresse_retour != 0)  
                 {  
                     fprintf(flux, "P=%lu", (*l_element_courant)  
                             .adresse_retour);  
                 }  
             }              }
             else              else
             {              {
                 fprintf(flux, "SEQ ");                  fprintf(flux, "SEQ ");
   
                 if ((*l_element_courant).pointeur_objet_retour != NULL)                  if ((*l_element_courant).pointeur_adresse_retour != NULL)
                 {                  {
                     fprintf(flux, "A=%X", (*l_element_courant)                      fprintf(flux, "A=%016X ", (*l_element_courant)
                             .pointeur_objet_retour);                              .pointeur_adresse_retour);
   
                       // Calcul de la routine de départ
   
                       l_variable = (struct_liste_chainee *)
                               (*(*(*s_etat_processus)
                               .l_liste_variables_par_niveau).precedent).liste;
                       candidat = (*s_etat_processus)
                               .longueur_definitions_chainees;
                       l_candidat = NULL;
   
                       // l_variable balaie les variables de niveau 0.
   
                       while(l_variable != NULL)
                       {
                           if ( (*(*l_variable).donnee).objet ==
                                   (*l_element_courant).pointeur_adresse_retour)
                           {
                               l_candidat = l_variable;
                               break;
                           }
   
                           l_variable = (*l_variable).suivant;
                       }
   
                       if (l_candidat != NULL)
                       {
                           fprintf(flux, "\n  Branch to %s",
                                   (*((struct_variable *) (*l_candidat).donnee))
                                   .nom);
                       }
                       else
                       {
                           fprintf(flux, "\n  Branch to evaluation subroutine");
                       }
                 }                  }
             }              }
         }          }
   
         fprintf(flux, "\n");          fprintf(flux, "\n");
   
           if ((*l_element_courant).indice_boucle != NULL)
           {
               tampon = formateur(s_etat_processus, 0,
                       (*l_element_courant).indice_boucle);
               fprintf(flux, "  Index         = %s\n", tampon);
               free(tampon);
           }
   
           if ((*l_element_courant).limite_indice_boucle != NULL)
           {
               tampon = formateur(s_etat_processus, 0,
                       (*l_element_courant).limite_indice_boucle);
               fprintf(flux, "  Limit         = %s\n", tampon);
               free(tampon);
           }
   
           if ((*l_element_courant).objet_de_test != NULL)
           {
               tampon = formateur(s_etat_processus, 0,
                       (*l_element_courant).objet_de_test);
               fprintf(flux, "  Test object   = %s\n", tampon);
               free(tampon);
           }
   
           if ((*l_element_courant).nom_variable != NULL)
           {
               fprintf(flux, "  Variable name = %s\n",
                       (*l_element_courant).nom_variable);
           }
   
         l_element_courant = (*l_element_courant).suivant;          l_element_courant = (*l_element_courant).suivant;
     }      }
   
Removed from v.1.12  
changed lines
  Added in v.1.35

CVSweb interface <joel.bertrand@systella.fr>