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

Diff for /rpl/src/gestion_pile.c between versions 1.2 and 1.80

version 1.2, 2010/01/27 22:22:11 version 1.80, 2025/04/15 10:17:51
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.10    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2025 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 45  estimation_taille_pile(struct_processus Line 45  estimation_taille_pile(struct_processus
      * est estimée au travers d'une chaîne de Markov.       * est estimée au travers d'une chaîne de Markov.
      */       */
   
     (*s_etat_processus).estimation_taille_pile_tampon =      if ((*s_etat_processus).hauteur_pile_operationnelle >
             ((*s_etat_processus).estimation_taille_pile_tampon *              (*s_etat_processus).estimation_taille_pile_tampon)
             ((double) 0.9)) + ((*s_etat_processus)      {
             .hauteur_pile_operationnelle * ((double) 0.1));          (*s_etat_processus).estimation_taille_pile_tampon =
                   (*s_etat_processus).estimation_taille_pile_tampon;
       }
       else
       {
           (*s_etat_processus).estimation_taille_pile_tampon =
                   (((double) (*s_etat_processus).estimation_taille_pile_tampon) *
                   ((double) 0.95)) + (((double) (*s_etat_processus)
                   .hauteur_pile_operationnelle) * ((double) 0.05));
       }
   
     return;      return;
 }  }
   
Line 118  empilement(struct_processus *s_etat_proc Line 128  empilement(struct_processus *s_etat_proc
             if ((*s_etat_processus).langue == 'F')              if ((*s_etat_processus).langue == 'F')
             {              {
                 printf("[%d] Empilement de type %d "                  printf("[%d] Empilement de type %d "
                         "(profondeur %lu)\n", (int) getpid(),                          "(profondeur %lld)\n", (int) getpid(),
                         (*s_objet).type,                          (*s_objet).type,
                         (*s_etat_processus).hauteur_pile_operationnelle);                          (*s_etat_processus).hauteur_pile_operationnelle);
             }              }
             else              else
             {              {
                 printf("[%d] Pushing a type %d object "                  printf("[%d] Pushing a type %d object "
                         "(depth %lu)\n", (int) getpid(), (*s_objet).type,                          "(depth %lld)\n", (int) getpid(), (*s_objet).type,
                         (*s_etat_processus).hauteur_pile_operationnelle);                          (*s_etat_processus).hauteur_pile_operationnelle);
             }              }
   
Line 182  depilement(struct_processus *s_etat_proc Line 192  depilement(struct_processus *s_etat_proc
                 if ((*s_etat_processus).langue == 'F')                  if ((*s_etat_processus).langue == 'F')
                 {                  {
                     printf("[%d] Dépilement de type %d "                      printf("[%d] Dépilement de type %d "
                             "(profondeur %lu)\n", (int) getpid(),                              "(profondeur %lld)\n", (int) getpid(),
                             (*(*s_objet)).type,                              (*(*s_objet)).type,
                             (*s_etat_processus).hauteur_pile_operationnelle);                              (*s_etat_processus).hauteur_pile_operationnelle);
                 }                  }
                 else                  else
                 {                  {
                     printf("[%d] Pulling a type %d object "                      printf("[%d] Pulling a type %d object "
                             "(depth %lu)\n", (int) getpid(), (*(*s_objet)).type,                              "(depth %lld)\n", (int) getpid(),
                               (*(*s_objet)).type,
                             (*s_etat_processus).hauteur_pile_operationnelle);                              (*s_etat_processus).hauteur_pile_operationnelle);
                 }                  }
   
Line 241  depilement(struct_processus *s_etat_proc Line 252  depilement(struct_processus *s_etat_proc
   
 void  void
 affichage_pile(struct_processus *s_etat_processus, struct_liste_chainee  affichage_pile(struct_processus *s_etat_processus, struct_liste_chainee
         *l_element_courant, unsigned long niveau_courant)          *l_element_courant, integer8 niveau_courant)
 {  {
       unsigned char           registre;
   
       registre = (*s_etat_processus).autorisation_conversion_chaine;
       (*s_etat_processus).autorisation_conversion_chaine = 'N';
   
       routine_recursive = 1;
     ecriture_pile(s_etat_processus, stdout, l_element_courant, niveau_courant);      ecriture_pile(s_etat_processus, stdout, l_element_courant, niveau_courant);
       routine_recursive = 0;
   
       (*s_etat_processus).autorisation_conversion_chaine = registre;
     return;      return;
 }  }
   
   // Bug de gcc à partir de gcc 4.6 (bug 48544)
   #pragma GCC diagnostic push
   #pragma GCC diagnostic ignored "-Wclobbered"
   
 void  void
 ecriture_pile(struct_processus *s_etat_processus, file *flux,  ecriture_pile(struct_processus *s_etat_processus, file *flux,
         struct_liste_chainee *l_element_courant, unsigned long niveau_courant)          struct_liste_chainee *l, integer8 niveau_courant)
 {  {
     unsigned char               *chaine;      unsigned char               *chaine;
     unsigned char               *registre;      unsigned char               *registre;
     unsigned char               tampon[32 + 1];      unsigned char               tampon[32 + 1];
   
       // Évite le warning : argument l_element_courant might be clobbered by
       // longjmp or vfork
       volatile struct_liste_chainee   *l_element_courant;
   
       l_element_courant = l;
   
     if (l_element_courant != NULL)      if (l_element_courant != NULL)
     {      {
         if (setjmp(contexte) == 0)          if (setjmp(contexte_ecriture) == 0)
         {          {
             (*s_etat_processus).var_volatile_recursivite = -1;              (*s_etat_processus).var_volatile_recursivite = -1;
             ecriture_pile(s_etat_processus, flux,              ecriture_pile(s_etat_processus, flux,
Line 269  ecriture_pile(struct_processus *s_etat_p Line 299  ecriture_pile(struct_processus *s_etat_p
   
                 if ((*s_etat_processus).var_volatile_recursivite == 0)                  if ((*s_etat_processus).var_volatile_recursivite == 0)
                 {                  {
                     if (fprintf(flux, "%lu: ...\n", niveau_courant) < 0)                      if (fprintf(flux, "%lld: ...\n", niveau_courant) < 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
                                 d_es_erreur_fichier;                                  d_es_erreur_fichier;
Line 296  ecriture_pile(struct_processus *s_etat_p Line 326  ecriture_pile(struct_processus *s_etat_p
             return;              return;
         }          }
   
         sprintf(tampon, "%lu: ", niveau_courant);          sprintf(tampon, "%lld: ", niveau_courant);
   
         if ((chaine = formateur(s_etat_processus, strlen(tampon),          if ((chaine = formateur(s_etat_processus, (long) strlen(tampon),
                 (*l_element_courant).donnee)) == NULL)                  (*l_element_courant).donnee)) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 320  ecriture_pile(struct_processus *s_etat_p Line 350  ecriture_pile(struct_processus *s_etat_p
             free(registre);              free(registre);
         }          }
   
         if (fprintf(flux, "%lu: %s\n", niveau_courant, chaine) < 0)          if (fprintf(flux, "%lld: %s\n", niveau_courant, chaine) < 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;              (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
             return;              return;
Line 347  ecriture_pile(struct_processus *s_etat_p Line 377  ecriture_pile(struct_processus *s_etat_p
   
 void  void
 impression_pile(struct_processus *s_etat_processus,  impression_pile(struct_processus *s_etat_processus,
         struct_liste_chainee *l_element_courant, unsigned char methode,          struct_liste_chainee *l, unsigned char methode, integer8 niveau_courant)
         unsigned long niveau_courant)  
 {  {
     struct_objet                s_objet;      struct_objet                s_objet;
   
Line 356  impression_pile(struct_processus *s_etat Line 385  impression_pile(struct_processus *s_etat
     unsigned char               *registre;      unsigned char               *registre;
     unsigned char               tampon[32 + 1];      unsigned char               tampon[32 + 1];
   
       // Évite le warning : argument l_element_courant might be clobbered by
       // longjmp or vfork
       volatile struct_liste_chainee   *l_element_courant;
   
       l_element_courant = l;
   
     if (l_element_courant != NULL)      if (l_element_courant != NULL)
     {      {
         if (setjmp(contexte) == 0)          if (setjmp(contexte_impression) == 0)
         {          {
             (*s_etat_processus).var_volatile_recursivite = -1;              (*s_etat_processus).var_volatile_recursivite = -1;
             impression_pile(s_etat_processus, (*l_element_courant).suivant,              impression_pile(s_etat_processus, (*l_element_courant).suivant,
Line 390  impression_pile(struct_processus *s_etat Line 425  impression_pile(struct_processus *s_etat
         if (methode == 'C')          if (methode == 'C')
         {          {
             s_objet.type = CHN;              s_objet.type = CHN;
             sprintf(tampon, "%lu: ", niveau_courant);              sprintf(tampon, "%lld: ", niveau_courant);
   
             if ((chaine = formateur(s_etat_processus, strlen(tampon),              if ((chaine = formateur(s_etat_processus, (long) strlen(tampon),
                     (*l_element_courant).donnee)) == NULL)                      (*l_element_courant).donnee)) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 423  impression_pile(struct_processus *s_etat Line 458  impression_pile(struct_processus *s_etat
             }              }
   
             sprintf((unsigned char *) s_objet.objet,              sprintf((unsigned char *) s_objet.objet,
                     "\n\\noindent\\begin{verbatim}\n%lu: %s\n\\end{verbatim}",                      "\n\\noindent\\begin{verbatim}\n%lld: %s\n\\end{verbatim}",
                     niveau_courant, chaine);                      niveau_courant, chaine);
             free(chaine);              free(chaine);
   
Line 439  impression_pile(struct_processus *s_etat Line 474  impression_pile(struct_processus *s_etat
     return;      return;
 }  }
   
   #pragma GCC diagnostic pop
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.2  
changed lines
  Added in v.1.80

CVSweb interface <joel.bertrand@systella.fr>