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

Diff for /rpl/src/gestion_objets.c between versions 1.98 and 1.124

version 1.98, 2013/03/21 12:07:38 version 1.124, 2015/10/22 18:37:09
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.13    RPL/2 (R) version 4.1.23
   Copyright (C) 1989-2013 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 926  liberation(struct_processus *s_etat_proc Line 926  liberation(struct_processus *s_etat_proc
                 return;                  return;
             }              }
   
             free((unsigned char *) ((*s_objet).objet));              free((unsigned char *) (*s_objet).objet);
             break;              break;
         }          }
   
Line 1394  liberation(struct_processus *s_etat_proc Line 1394  liberation(struct_processus *s_etat_proc
                             .nombre_occurrences <= 1,                              .nombre_occurrences <= 1,
                             pthread_mutex_unlock(&((*s_objet).mutex)),                              pthread_mutex_unlock(&((*s_objet).mutex)),
                             printf("(*((*((struct_tableau *) (*s_objet).objet))"                              printf("(*((*((struct_tableau *) (*s_objet).objet))"
                             ".element[%lu])).nombre_occurrences=%ld\n", i,                              ".element[%lld])).nombre_occurrences=%ld\n", i,
                             (*((*((struct_tableau *) (*s_objet).objet))                              (*((*((struct_tableau *) (*s_objet).objet))
                             .elements[i])).nombre_occurrences));                              .elements[i])).nombre_occurrences));
                     liberation(s_etat_processus, (*((struct_tableau *)                      liberation(s_etat_processus, (*((struct_tableau *)
Line 2434  copie_objet(struct_processus *s_etat_pro Line 2434  copie_objet(struct_processus *s_etat_pro
                     (*((struct_socket *) ((*s_objet).objet))).pid;                      (*((struct_socket *) ((*s_objet).objet))).pid;
             (*((struct_socket *) ((*s_nouvel_objet).objet))).tid =              (*((struct_socket *) ((*s_nouvel_objet).objet))).tid =
                     (*((struct_socket *) ((*s_objet).objet))).tid;                      (*((struct_socket *) ((*s_objet).objet))).tid;
               (*((struct_socket *) ((*s_nouvel_objet).objet))).options =
                       (*((struct_socket *) ((*s_objet).objet))).options;
               (*((struct_socket *) ((*s_nouvel_objet).objet))).priorite =
                       (*((struct_socket *) ((*s_objet).objet))).priorite;
               (*((struct_socket *) ((*s_nouvel_objet).objet))).buffer_reception =
                       (*((struct_socket *) ((*s_objet).objet))).buffer_reception;
               (*((struct_socket *) ((*s_nouvel_objet).objet))).buffer_emission =
                       (*((struct_socket *) ((*s_objet).objet))).buffer_emission;
               (*((struct_socket *) ((*s_nouvel_objet).objet))).timeout_reception =
                       (*((struct_socket *) ((*s_objet).objet))).timeout_reception;
               (*((struct_socket *) ((*s_nouvel_objet).objet))).timeout_emission =
                       (*((struct_socket *) ((*s_objet).objet))).timeout_emission;
   
             if (((*((struct_socket *) ((*s_nouvel_objet).objet))).format =              if (((*((struct_socket *) ((*s_nouvel_objet).objet))).format =
                     copie_objet(s_etat_processus, (*((struct_socket *)                      copie_objet(s_etat_processus, (*((struct_socket *)
Line 2837  copie_etat_processus(struct_processus *s Line 2849  copie_etat_processus(struct_processus *s
   
     integer8                        i;      integer8                        i;
   
     if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)      if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return(NULL);          return(NULL);
     }      }
   
     if ((s_nouvel_etat_processus = malloc(sizeof(struct_processus))) == NULL)      if ((s_nouvel_etat_processus = sys_malloc(sizeof(struct_processus)))
               == NULL)
     {      {
           if (pthread_mutex_unlock(&((*s_etat_processus)
                   .mutex_pile_processus)) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return(NULL);
           }
   
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return(NULL);          return(NULL);
     }      }
   
     (*s_nouvel_etat_processus) = (*s_etat_processus);      (*s_nouvel_etat_processus) = (*s_etat_processus);
   
     // On réinitialise l'allocateur.      // On réinitialise les allocateurs.
   
       pthread_mutexattr_init(&attributs_mutex);
       pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
       pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_allocation_buffer),
               &attributs_mutex);
       pthread_mutexattr_destroy(&attributs_mutex);
   
       pthread_mutexattr_init(&attributs_mutex);
       pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
       pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_allocation),
               &attributs_mutex);
       pthread_mutexattr_destroy(&attributs_mutex);
   
     initialisation_allocateur(s_nouvel_etat_processus);      initialisation_allocateur(s_nouvel_etat_processus);
       initialisation_allocateur_buffer(s_nouvel_etat_processus);
   
     /*      /*
      * (*s_etat_processus).definition_chainee,       * (*s_etat_processus).definition_chainee,
Line 2863  copie_etat_processus(struct_processus *s Line 2896  copie_etat_processus(struct_processus *s
      * n'ont aucune raison de changer.       * n'ont aucune raison de changer.
      */       */
   
     pthread_mutexattr_init(&attributs_mutex);  
     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);  
     (*s_nouvel_etat_processus).sections_critiques = 0;      (*s_nouvel_etat_processus).sections_critiques = 0;
       (*s_nouvel_etat_processus).initialisation_scheduler = d_faux;
   
     // Les sémaphores sont initialisés dans le nouveau thread. Il      // Les sémaphores sont initialisés dans le nouveau thread. Il
     // s'agit d'une limitation de l'implantation de l'émulation      // s'agit d'une limitation de l'implantation de l'émulation
Line 2932  copie_etat_processus(struct_processus *s Line 2964  copie_etat_processus(struct_processus *s
   
     // Copie de la localisation      // Copie de la localisation
   
     if (((*s_nouvel_etat_processus).localisation = malloc((strlen(      if (((*s_nouvel_etat_processus).localisation = rpl_malloc(
             (*s_etat_processus).localisation) + 1) * sizeof(unsigned char)))              s_nouvel_etat_processus, (strlen((*s_etat_processus).localisation)
             == NULL)              + 1) * sizeof(unsigned char))) == NULL)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return(NULL);          return(NULL);
Line 2948  copie_etat_processus(struct_processus *s Line 2980  copie_etat_processus(struct_processus *s
         if (((*s_nouvel_etat_processus).indep = copie_objet(s_etat_processus,          if (((*s_nouvel_etat_processus).indep = copie_objet(s_etat_processus,
                 (*s_etat_processus).indep, 'P')) == NULL)                  (*s_etat_processus).indep, 'P')) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 2968  copie_etat_processus(struct_processus *s Line 3001  copie_etat_processus(struct_processus *s
         if (((*s_nouvel_etat_processus).depend = copie_objet(s_etat_processus,           if (((*s_nouvel_etat_processus).depend = copie_objet(s_etat_processus, 
                 (*s_etat_processus).depend, 'P')) == NULL)                  (*s_etat_processus).depend, 'P')) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 2989  copie_etat_processus(struct_processus *s Line 3023  copie_etat_processus(struct_processus *s
                 copie_objet(s_etat_processus, (*s_etat_processus)                  copie_objet(s_etat_processus, (*s_etat_processus)
                 .parametres_courbes_de_niveau, 'P')) == NULL)                  .parametres_courbes_de_niveau, 'P')) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3009  copie_etat_processus(struct_processus *s Line 3044  copie_etat_processus(struct_processus *s
     if (((*s_etat_processus).instruction_courante != NULL) &&      if (((*s_etat_processus).instruction_courante != NULL) &&
             (*s_etat_processus).evaluation_expression_compilee == 'N')              (*s_etat_processus).evaluation_expression_compilee == 'N')
     {      {
         if (((*s_nouvel_etat_processus).instruction_courante = malloc((strlen(          if (((*s_nouvel_etat_processus).instruction_courante = rpl_malloc(
                   s_nouvel_etat_processus, (strlen(
                 (*s_etat_processus).instruction_courante) + 1) *                  (*s_etat_processus).instruction_courante) + 1) *
                 sizeof(unsigned char))) == NULL)                  sizeof(unsigned char))) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3033  copie_etat_processus(struct_processus *s Line 3070  copie_etat_processus(struct_processus *s
   
     if ((*s_etat_processus).label_x != NULL)      if ((*s_etat_processus).label_x != NULL)
     {      {
         if (((*s_nouvel_etat_processus).label_x = malloc((strlen(          if (((*s_nouvel_etat_processus).label_x = rpl_malloc(
                   s_nouvel_etat_processus, (strlen(
                 (*s_etat_processus).label_x) + 1) *                  (*s_etat_processus).label_x) + 1) *
                 sizeof(unsigned char))) == NULL)                  sizeof(unsigned char))) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3057  copie_etat_processus(struct_processus *s Line 3096  copie_etat_processus(struct_processus *s
   
     if ((*s_etat_processus).label_y != NULL)      if ((*s_etat_processus).label_y != NULL)
     {      {
         if (((*s_nouvel_etat_processus).label_y = malloc((strlen(          if (((*s_nouvel_etat_processus).label_y = rpl_malloc(
                 (*s_etat_processus).label_y) + 1) *                  s_nouvel_etat_processus, (strlen((*s_etat_processus).label_y)
                 sizeof(unsigned char))) == NULL)                  + 1) * sizeof(unsigned char))) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3081  copie_etat_processus(struct_processus *s Line 3121  copie_etat_processus(struct_processus *s
   
     if ((*s_etat_processus).label_z != NULL)      if ((*s_etat_processus).label_z != NULL)
     {      {
         if (((*s_nouvel_etat_processus).label_z = malloc((strlen(          if (((*s_nouvel_etat_processus).label_z = rpl_malloc(
                 (*s_etat_processus).label_z) + 1) *                  s_nouvel_etat_processus, (strlen((*s_etat_processus).label_z)
                 sizeof(unsigned char))) == NULL)                  + 1) * sizeof(unsigned char))) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3105  copie_etat_processus(struct_processus *s Line 3146  copie_etat_processus(struct_processus *s
   
     if ((*s_etat_processus).titre != NULL)      if ((*s_etat_processus).titre != NULL)
     {      {
         if (((*s_nouvel_etat_processus).titre = malloc((strlen(          if (((*s_nouvel_etat_processus).titre = rpl_malloc(
                 (*s_etat_processus).titre) + 1) *                  s_nouvel_etat_processus, (strlen((*s_etat_processus).titre) + 1)
                 sizeof(unsigned char))) == NULL)                  * sizeof(unsigned char))) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3129  copie_etat_processus(struct_processus *s Line 3171  copie_etat_processus(struct_processus *s
   
     if ((*s_etat_processus).legende != NULL)      if ((*s_etat_processus).legende != NULL)
     {      {
         if (((*s_nouvel_etat_processus).legende = malloc((strlen(          if (((*s_nouvel_etat_processus).legende = rpl_malloc(
                 (*s_etat_processus).legende) + 1) *                  s_nouvel_etat_processus, (strlen((*s_etat_processus).legende)
                 sizeof(unsigned char))) == NULL)                  + 1) * sizeof(unsigned char))) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3178  copie_etat_processus(struct_processus *s Line 3221  copie_etat_processus(struct_processus *s
   
     while(l_element_lecture != NULL)      while(l_element_lecture != NULL)
     {      {
         if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)          if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
                   sizeof(struct_liste_chainee))) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3193  copie_etat_processus(struct_processus *s Line 3238  copie_etat_processus(struct_processus *s
         if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,          if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
                 (*l_element_lecture).donnee, 'P')) == NULL)                  (*l_element_lecture).donnee, 'P')) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3229  copie_etat_processus(struct_processus *s Line 3275  copie_etat_processus(struct_processus *s
   
     if ((*s_nouvel_etat_processus).erreur_systeme != d_es)      if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
     {      {
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
                   != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return(NULL);              return(NULL);
Line 3251  copie_etat_processus(struct_processus *s Line 3298  copie_etat_processus(struct_processus *s
   
     if ((*s_nouvel_etat_processus).erreur_systeme != d_es)      if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
     {      {
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
                   != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return(NULL);              return(NULL);
Line 3283  copie_etat_processus(struct_processus *s Line 3331  copie_etat_processus(struct_processus *s
   
     while(l_element_lecture != NULL)      while(l_element_lecture != NULL)
     {      {
         if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)          if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
                   sizeof(struct_liste_chainee))) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3298  copie_etat_processus(struct_processus *s Line 3348  copie_etat_processus(struct_processus *s
         if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,          if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
                 (*l_element_lecture).donnee, 'P')) == NULL)                  (*l_element_lecture).donnee, 'P')) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3329  copie_etat_processus(struct_processus *s Line 3380  copie_etat_processus(struct_processus *s
   
     while(l_element_lecture != NULL)      while(l_element_lecture != NULL)
     {      {
         if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)          if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
                   sizeof(struct_liste_chainee))) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3344  copie_etat_processus(struct_processus *s Line 3397  copie_etat_processus(struct_processus *s
         if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,          if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
                 (*l_element_lecture).donnee, 'P')) == NULL)                  (*l_element_lecture).donnee, 'P')) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3380  copie_etat_processus(struct_processus *s Line 3434  copie_etat_processus(struct_processus *s
   
     while(l_element_lecture != NULL)      while(l_element_lecture != NULL)
     {      {
         if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)          if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
                   sizeof(struct_liste_chainee))) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3395  copie_etat_processus(struct_processus *s Line 3451  copie_etat_processus(struct_processus *s
         if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,          if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
                 (*l_element_lecture).donnee, 'P')) == NULL)                  (*l_element_lecture).donnee, 'P')) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3426  copie_etat_processus(struct_processus *s Line 3483  copie_etat_processus(struct_processus *s
   
     while(l_element_lecture != NULL)      while(l_element_lecture != NULL)
     {      {
         if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)          if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
                   sizeof(struct_liste_chainee))) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3438  copie_etat_processus(struct_processus *s Line 3497  copie_etat_processus(struct_processus *s
             return(NULL);              return(NULL);
         }          }
   
         if (((*l_element_suivant).donnee = malloc(sizeof(struct_bibliotheque)))          if (((*l_element_suivant).donnee = rpl_malloc(s_nouvel_etat_processus,
                 == NULL)                  sizeof(struct_bibliotheque))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(NULL);              return(NULL);
Line 3454  copie_etat_processus(struct_processus *s Line 3513  copie_etat_processus(struct_processus *s
                 = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).tid;                  = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).tid;
   
         if (((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom =          if (((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom =
                 malloc((strlen((*((struct_bibliotheque *) (*l_element_lecture)                  rpl_malloc(s_nouvel_etat_processus,
                   (strlen((*((struct_bibliotheque *) (*l_element_lecture)
                 .donnee)).nom) + 1) * sizeof(unsigned char))) == NULL)                  .donnee)).nom) + 1) * sizeof(unsigned char))) == NULL)
         {          {
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3488  copie_etat_processus(struct_processus *s Line 3549  copie_etat_processus(struct_processus *s
     if ((*s_etat_processus).nombre_instructions_externes != 0)      if ((*s_etat_processus).nombre_instructions_externes != 0)
     {      {
         if (((*s_nouvel_etat_processus).s_instructions_externes =          if (((*s_nouvel_etat_processus).s_instructions_externes =
                 malloc(((size_t) (*s_etat_processus)                  rpl_malloc(s_nouvel_etat_processus, ((size_t)
                 .nombre_instructions_externes) *                  (*s_etat_processus).nombre_instructions_externes) *
                 sizeof(struct_instruction_externe))) == NULL)                  sizeof(struct_instruction_externe))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
Line 3499  copie_etat_processus(struct_processus *s Line 3560  copie_etat_processus(struct_processus *s
         for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)          for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
         {          {
             if (((*s_nouvel_etat_processus).s_instructions_externes[i].nom =              if (((*s_nouvel_etat_processus).s_instructions_externes[i].nom =
                     malloc((strlen((*s_etat_processus).s_instructions_externes                      rpl_malloc(s_nouvel_etat_processus,
                       (strlen((*s_etat_processus).s_instructions_externes
                     [i].nom) + 1) * sizeof(unsigned char))) == NULL)                      [i].nom) + 1) * sizeof(unsigned char))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
Line 3510  copie_etat_processus(struct_processus *s Line 3572  copie_etat_processus(struct_processus *s
                     (*s_etat_processus).s_instructions_externes[i].nom);                      (*s_etat_processus).s_instructions_externes[i].nom);
   
             if (((*s_nouvel_etat_processus).s_instructions_externes[i]              if (((*s_nouvel_etat_processus).s_instructions_externes[i]
                     .nom_bibliotheque = malloc((strlen((*s_etat_processus)                      .nom_bibliotheque = rpl_malloc(s_nouvel_etat_processus,
                     .s_instructions_externes[i].nom_bibliotheque) + 1) *                      (strlen((*s_etat_processus).s_instructions_externes[i]
                     sizeof(unsigned char))) == NULL)                      .nom_bibliotheque) + 1) * sizeof(unsigned char))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return(NULL);                  return(NULL);
Line 3534  copie_etat_processus(struct_processus *s Line 3596  copie_etat_processus(struct_processus *s
   
     pthread_mutexattr_init(&attributs_mutex);      pthread_mutexattr_init(&attributs_mutex);
     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);      pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
     pthread_mutex_init(&((*s_nouvel_etat_processus).mutex), &attributs_mutex);      pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_pile_processus),
               &attributs_mutex);
     pthread_mutexattr_destroy(&attributs_mutex);      pthread_mutexattr_destroy(&attributs_mutex);
   
     pthread_mutexattr_init(&attributs_mutex);      pthread_mutexattr_init(&attributs_mutex);
     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);      pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
     pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_allocation),      pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_interruptions),
               &attributs_mutex);
       pthread_mutexattr_destroy(&attributs_mutex);
   
       pthread_mutexattr_init(&attributs_mutex);
       pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
       pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_signaux),
               &attributs_mutex);
       pthread_mutexattr_destroy(&attributs_mutex);
   
       pthread_mutexattr_init(&attributs_mutex);
       pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
       pthread_mutex_init(&((*s_nouvel_etat_processus).protection_liste_mutexes),
             &attributs_mutex);              &attributs_mutex);
     pthread_mutexattr_destroy(&attributs_mutex);      pthread_mutexattr_destroy(&attributs_mutex);
   
     if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)      if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return(NULL);          return(NULL);
Removed from v.1.98  
changed lines
  Added in v.1.124

CVSweb interface <joel.bertrand@systella.fr>