[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.7 and 1.69

version 1.7, 2010/04/20 12:49:18 version 1.69, 2015/01/05 13:12:32
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.14    RPL/2 (R) version 4.1.19
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 39  static inline void Line 39  static inline void
 estimation_taille_pile_systeme(struct_processus *s_etat_processus)  estimation_taille_pile_systeme(struct_processus *s_etat_processus)
 {  {
     (*s_etat_processus).estimation_taille_pile_systeme_tampon =      (*s_etat_processus).estimation_taille_pile_systeme_tampon =
             ((*s_etat_processus).estimation_taille_pile_systeme_tampon *              (((double) (*s_etat_processus)
             ((double) 0.9)) + ((*s_etat_processus)              .estimation_taille_pile_systeme_tampon) *
             .hauteur_pile_systeme * ((double) 0.1));              ((double) 0.9)) + (((double) (*s_etat_processus)
               .hauteur_pile_systeme) * ((double) 0.1));
     return;      return;
 }  }
   
Line 130  empilement_pile_systeme(struct_processus Line 131  empilement_pile_systeme(struct_processus
     (*(*s_etat_processus).l_base_pile_systeme).type_cloture = ' ';      (*(*s_etat_processus).l_base_pile_systeme).type_cloture = ' ';
     (*(*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 =
               (*s_etat_processus).niveau_courant;
     (*(*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 284  effacement_pile_systeme(struct_processus Line 286  effacement_pile_systeme(struct_processus
   
     return;      return;
 }  }
   
   
   /*
   ================================================================================
     Procédure d'affichage de la pile système
   ================================================================================
     Entrée :
   --------------------------------------------------------------------------------
     Sortie :
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   void
   trace(struct_processus *s_etat_processus, FILE *flux)
   {
       integer8                        i;
       integer8                        j;
       integer8                        candidat;
       integer8                        candidat8;
       integer8                        delta;
       integer8                        nb_variables;
   
       struct_liste_chainee            *l_element_expression;
   
       struct_liste_pile_systeme       *l_element_courant;
   
       struct_tableau_variables        *tableau;
   
       unsigned char                   *tampon;
   
       l_element_courant = (*s_etat_processus).l_base_pile_systeme;
       i = 0;
   
       while(l_element_courant != NULL)
       {
           i++;
           l_element_courant = (*l_element_courant).suivant;
       }
   
       l_element_courant = (*s_etat_processus).l_base_pile_systeme;
       flockfile(flux);
   
       nb_variables = nombre_variables(s_etat_processus);
   
       if ((tableau = malloc(((size_t) nb_variables) *
               sizeof(struct_tableau_variables))) == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       liste_variables(s_etat_processus, tableau);
   
       if ((flux == stderr) || (flux == stdout))
       {
           fprintf(flux, "+++Backtrace\n");
       }
   
       while(l_element_courant != NULL)
       {
           fprintf(flux, "%lld : address # %016Xh\n", i--, l_element_courant);
   
           if ((*l_element_courant).creation_variables_statiques == d_vrai)
           {
               fprintf(flux, "    Variables         = static\n");
           }
           else if ((*l_element_courant).creation_variables_partagees == d_vrai)
           {
               fprintf(flux, "    Variables         = shared\n");
           }
           else
           {
               fprintf(flux, "    Variables         = automatic\n");
           }
   
           if ((*l_element_courant).arret_si_exception == d_vrai)
           {
               fprintf(flux, "    In exception      = abort\n");
           }
           else
           {
               fprintf(flux, "    In exception      = catch\n");
           }
   
           if ((*l_element_courant).clause != ' ')
           {
               fprintf(flux, "    Structure         = ");
   
               switch((*l_element_courant).clause)
               {
                   case 'I':
                       fprintf(flux, "IF\n");
                       break;
   
                   case 'R':
                       fprintf(flux, "IFERR\n");
                       break;
   
                   case 'X':
                       fprintf(flux, "exception caught by IFERR\n");
                       break;
   
                   case 'T':
                       fprintf(flux, "THEN\n");
                       break;
                   
                   case 'E':
                       fprintf(flux, "ELSE\n");
                       break;
   
                   case 'Z':
                       fprintf(flux, "ELSE (false condition)\n");
                       break;
   
                   case 'D':
                       fprintf(flux, "DO\n");
                       break;
   
                   case 'U':
                       fprintf(flux, "UNTIL\n");
                       break;
   
                   case 'W':
                       fprintf(flux, "WHILE\n");
                       break;
   
                   case 'M':
                       fprintf(flux, "WHILE (false condition)\n");
                       break;
   
                   case 'S':
                       fprintf(flux, "SELECT\n");
                       break;
   
                   case 'K':
                       fprintf(flux, "CASE (no true condition)\n");
                       break;
   
                   case 'C':
                       fprintf(flux, "CASE (one or more true conditions)\n");
                       break;
   
                   case 'Q':
                       fprintf(flux, "CASE (treatment of a true condition)\n");
                       break;
   
                   case 'F':
                       fprintf(flux, "CASE (treatment of default case)\n");
                       break;
               }
           }
   
           if ((*l_element_courant).type_cloture != ' ')
           {
               fprintf(flux, "    Next close        = ");
   
               switch((*l_element_courant).type_cloture)
               {
                   case 'C':
                       fprintf(flux, "SELECT\n");
                       break;
   
                   case 'D':
                       fprintf(flux, "DO\n");
                       break;
   
                   case 'I':
                       fprintf(flux, "IF\n");
                       break;
   
                   case 'J':
                       fprintf(flux, "IFERR\n");
                       break;
   
                   case 'K':
                       fprintf(flux, "CASE\n");
                       break;
   
                   case 'W':
                       fprintf(flux, "WHILE\n");
                       break;
   
                   case 'Q':
                       fprintf(flux, "CRITICAL\n");
                       break;
   
                   case 'F':
                       fprintf(flux, "FOR\n");
                       break;
   
                   case 'S':
                       fprintf(flux, "START\n");
                       break;
   
                   case 'L':
                       fprintf(flux, "internal loop\n");
                       break;
   
                   case 'A':
                       fprintf(flux, "FORALL\n");
                       break;
               }
           }
   
           fprintf(flux, "    Level             = %lld\n",
                   (long long int) (*l_element_courant).niveau_courant);
   
           if ((*l_element_courant).retour_definition == 'Y')
           {
               fprintf(flux, "    Return            = yes\n");
   
               if ((*l_element_courant).origine_routine_evaluation == 'Y')
               {
                   if ((*l_element_courant).pointeur_objet_retour != NULL)
                   {
                       fprintf(flux, "    Come from         = compiled code ");
                       fprintf(flux, "(address # %016Xh)\n", (*l_element_courant)
                               .pointeur_objet_retour);
   
                       // Calcul de la routine de départ
   
                       candidat = -1;
   
                       for(j = 0; j < nb_variables; j++)
                       {
                           if (((*(tableau[j].objet)).type == RPN) ||
                                   ((*(tableau[j].objet)).type == ALG))
                           {
                               l_element_expression = (*(tableau[j].objet)).objet;
   
                               while(l_element_expression != NULL)
                               {
                                   if (l_element_expression == (*l_element_courant)
                                           .pointeur_objet_retour)
                                   {
                                       candidat = j;
                                       break;
                                   }
   
                                   l_element_expression =
                                           (*l_element_expression).suivant;
                               }
   
                               if (candidat != -1)
                               {
                                   break;
                               }
                           }
                       }
   
                       if (candidat != -1)
                       {
                           fprintf(flux, "                      = %s [",
                                   tableau[candidat].nom);
                          
                           if ((*(tableau[candidat].objet)).type == RPN)
                           {
                               fprintf(flux, "definition");
                           }
                           else if ((*(tableau[candidat].objet)).type == ALG)
                           {
                               fprintf(flux, "algebraic");
                           }
                           else if ((*(tableau[candidat].objet)).type == NOM)
                           {
                               fprintf(flux, "name");
                           }
                           else
                           {
                               fprintf(flux, "unknown");
                           }
   
                           fprintf(flux, "]\n");
                       }
                       else
                       {
                           fprintf(flux, "                      = "
                                   "optimized definition\n");
                       }
                   }
                   else
                   {
                       fprintf(flux, "    Come from         = compiled code\n");
                       fprintf(flux, "                      = "
                               "optimized definition\n");
                   }
               }
               else
               {
                   fprintf(flux, "    Come from         = interpreted code ");
   
                   if ((*l_element_courant).adresse_retour != 0)
                   {
                       fprintf(flux, "(offset # %016Xh)\n", (*l_element_courant)
                               .adresse_retour);
   
                       // Calcul de la routine de départ
   
                       candidat8 = (*s_etat_processus)
                               .longueur_definitions_chainees;
                       candidat = -1;
   
                       for(j = 0; j < nb_variables; j++)
                       {
                           if ((*(tableau[j].objet)).type == ADR)
                           {
                               delta = (*l_element_courant).adresse_retour
                                       - (*((integer8 *)
                                       (*(tableau[j].objet)).objet));
   
                               if ((delta >= 0) && (delta < candidat8))
                               {
                                   candidat8 = delta;
                                   candidat = j;
                               }
                           }
                       }
   
                       if (candidat != -1)
                       {
                           fprintf(flux, "                      = %s\n",
                                   tableau[candidat].nom);
                       }
                       else
                       {
                           fprintf(flux, "                      = "
                                   "unknown definition\n");
                       }
                   }
                   else if ((*l_element_courant).niveau_courant == 0)
                   {
                       fprintf(flux, "\n");
                       fprintf(flux, "                      = RPL/2 "
                               "initialization\n");
                   }
                   else
                   {
                       fprintf(flux, "\n");
                   }
               }
           }
           else
           {
               fprintf(flux, "    Return            = no\n");
           }
   
           if (((*l_element_courant).indice_boucle != NULL) &&
                   ((*l_element_courant).type_cloture != 'A'))
           {
               tampon = formateur(s_etat_processus, 24,
                       (*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, 24,
                       (*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, 24,
                       (*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);
           }
   
           fprintf(flux, "\n");
   
           l_element_courant = (*l_element_courant).suivant;
       }
   
       funlockfile(flux);
   
       free(tableau);
   
       return;
   }
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.7  
changed lines
  Added in v.1.69

CVSweb interface <joel.bertrand@systella.fr>