--- rpl/src/gestion_objets.c 2011/04/14 10:32:59 1.47 +++ rpl/src/gestion_objets.c 2013/05/22 09:05:20 1.101 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.0.prerelease.0 - Copyright (C) 1989-2011 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.14 + Copyright (C) 1989-2013 Dr. BERTRAND Joël This file is part of RPL/2. @@ -111,6 +111,13 @@ initialisation_allocateur(struct_process (*s_etat_processus).pointeur_vec = 0; (*s_etat_processus).pointeur_maillons = 0; + (*s_etat_processus).pointeur_variables_noeud = 0; + (*s_etat_processus).pointeur_variables_partagees_noeud = 0; + (*s_etat_processus).pointeur_variables_feuille = 0; + (*s_etat_processus).pointeur_variables_variable = 0; + (*s_etat_processus).pointeur_variables_tableau_noeuds = 0; + (*s_etat_processus).pointeur_variables_tableau_noeuds_partages = 0; + return; } @@ -143,6 +150,20 @@ liberation_allocateur(struct_processus * for(i = 0; i < (*s_etat_processus).pointeur_maillons; free((*s_etat_processus).maillons[i++])); + for(i = 0; i < (*s_etat_processus).pointeur_variables_noeud; + free((*s_etat_processus).variables_noeud[i++])); + for(i = 0; i < (*s_etat_processus).pointeur_variables_partagees_noeud; + free((*s_etat_processus).variables_partagees_noeud[i++])); + for(i = 0; i < (*s_etat_processus).pointeur_variables_feuille; + free((*s_etat_processus).variables_feuille[i++])); + for(i = 0; i < (*s_etat_processus).pointeur_variables_variable; + free((*s_etat_processus).variables_variable[i++])); + for(i = 0; i < (*s_etat_processus).pointeur_variables_tableau_noeuds; + free((*s_etat_processus).variables_tableau_noeuds[i++])); + for(i = 0; i < (*s_etat_processus) + .pointeur_variables_tableau_noeuds_partages; + free((*s_etat_processus).variables_tableau_noeuds_partages[i++])); + { struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_suivant; @@ -224,6 +245,7 @@ allocation_maillon(struct_processus *s_e { if ((s_maillon = malloc(sizeof(struct_liste_chainee))) == NULL) { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } } @@ -234,7 +256,7 @@ allocation_maillon(struct_processus *s_e /* ================================================================================ - Routine d'allocation d'un maillon d'un objet (liste, expression...) + Routine de libération d'un maillon d'un objet (liste, expression...) ================================================================================ Entrées : structure sur l'état du processus et objet à afficher -------------------------------------------------------------------------------- @@ -274,7 +296,7 @@ liberation_maillon(struct_processus *s_e ================================================================================ */ -void * +struct_objet * allocation(struct_processus *s_etat_processus, enum t_type type) { struct_objet *s_objet; @@ -297,6 +319,7 @@ allocation(struct_processus *s_etat_proc if ((s_objet = malloc(sizeof(struct_objet))) == NULL) { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } @@ -332,8 +355,10 @@ allocation(struct_processus *s_etat_proc } else { - if (((*s_objet).objet = malloc(sizeof(unsigned long))) == NULL) + if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -359,6 +384,8 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(logical8))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -385,6 +412,8 @@ allocation(struct_processus *s_etat_proc if (((*s_objet).objet = malloc(sizeof(struct_complexe16))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -397,6 +426,7 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(struct_fichier))) == NULL) { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -416,6 +446,8 @@ allocation(struct_processus *s_etat_proc if (((*s_objet).objet = malloc(sizeof(struct_fonction))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -439,6 +471,8 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -464,6 +498,8 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -487,6 +523,8 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -510,6 +548,8 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -526,10 +566,12 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(struct_mutex))) == NULL) { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; free(s_objet); return(NULL); } + (*((struct_mutex *) (*s_objet).objet)).tid = pthread_self(); break; } @@ -544,6 +586,8 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -563,6 +607,7 @@ allocation(struct_processus *s_etat_proc if (((*s_objet).objet = malloc(sizeof(struct_processus_fils))) == NULL) { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -581,6 +626,8 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(real8))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -599,6 +646,7 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(struct_socket))) == NULL) { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -611,6 +659,7 @@ allocation(struct_processus *s_etat_proc if (((*s_objet).objet = malloc(sizeof(struct_bibliotheque))) == NULL) { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -622,6 +671,7 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(struct_semaphore))) == NULL) { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -634,6 +684,7 @@ allocation(struct_processus *s_etat_proc if (((*s_objet).objet = malloc(sizeof(struct_connecteur_sql))) == NULL) { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -652,6 +703,8 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -673,6 +726,8 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -695,6 +750,8 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -717,6 +774,8 @@ allocation(struct_processus *s_etat_proc { if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL) { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; free(s_objet); return(NULL); } @@ -758,13 +817,10 @@ liberation(struct_processus *s_etat_proc { logical1 drapeau; - sigset_t oldset; - sigset_t set; - struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_suivant; - unsigned long i; + integer8 i; if (s_objet == NULL) { @@ -803,7 +859,7 @@ liberation(struct_processus *s_etat_proc } else { - free((unsigned long *) ((*s_objet).objet)); + free((*s_objet).objet); } break; @@ -1092,6 +1148,28 @@ liberation(struct_processus *s_etat_proc return; } + if (pthread_mutex_trylock(&((*((struct_mutex *) + (*s_objet).objet)).mutex)) == 0) + { + // On a pu verrouiller le mutex. Il faut donc spécifier le tid. + (*((struct_mutex *) (*s_objet).objet)).tid = pthread_self(); + } + + if (pthread_equal(pthread_self(), + (*((struct_mutex *) (*s_objet).objet)).tid) != 0) + { + pthread_mutex_unlock(&((*((struct_mutex *) + (*s_objet).objet)).mutex)); + } + else + { + (*s_etat_processus).erreur_systeme = + d_es_mutex_acquis_autre_thread; + return; + } + + pthread_mutex_destroy(&((*((struct_mutex *) + (*s_objet).objet)).mutex)); free((struct_mutex *) (*s_objet).objet); break; } @@ -1130,15 +1208,9 @@ liberation(struct_processus *s_etat_proc case PRC : { - sigfillset(&set); - pthread_sigmask(SIG_BLOCK, &set, &oldset); - if (pthread_mutex_lock(&((*(*((struct_processus_fils *) (*s_objet).objet)).thread).mutex_nombre_references)) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - (*s_etat_processus).erreur_systeme = d_es_processus; return; } @@ -1166,16 +1238,10 @@ liberation(struct_processus *s_etat_proc if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) (*s_objet).objet)).thread).mutex_nombre_references)) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - (*s_etat_processus).erreur_systeme = d_es_processus; return; } - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - if (drapeau == d_vrai) { pthread_mutex_destroy(&((*(*((struct_processus_fils *) @@ -1328,7 +1394,7 @@ liberation(struct_processus *s_etat_proc .nombre_occurrences <= 1, pthread_mutex_unlock(&((*s_objet).mutex)), 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)) .elements[i])).nombre_occurrences)); liberation(s_etat_processus, (*((struct_tableau *) @@ -1513,9 +1579,6 @@ struct_objet * copie_objet(struct_processus *s_etat_processus, struct_objet *s_objet, unsigned char type) { - sigset_t oldset; - sigset_t set; - struct_liste_chainee *l_element_base; struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_courant_ecriture; @@ -1526,8 +1589,8 @@ copie_objet(struct_processus *s_etat_pro struct_objet *s_nouvel_objet; struct_objet *s_objet_tampon; - unsigned long i; - unsigned long j; + integer8 i; + integer8 j; if (pthread_mutex_lock(&((*s_objet).mutex)) != 0) { @@ -1578,8 +1641,8 @@ copie_objet(struct_processus *s_etat_pro return(NULL); } - (*((unsigned long *) ((*s_nouvel_objet).objet))) = - (*((unsigned long *) ((*s_objet).objet))); + (*((integer8 *) ((*s_nouvel_objet).objet))) = + (*((integer8 *) ((*s_objet).objet))); break; } @@ -1644,7 +1707,7 @@ copie_objet(struct_processus *s_etat_pro (*l_element_courant_lecture).suivant; } - (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *) + (*s_nouvel_objet).objet = ((struct_liste_chainee *) l_element_base); } else // type == 'P' @@ -1696,7 +1759,7 @@ copie_objet(struct_processus *s_etat_pro return(NULL); } - (*s_nouvel_objet).objet = (void *) ((unsigned char *) + (*s_nouvel_objet).objet = ((unsigned char *) malloc((strlen((unsigned char *) ((*s_objet).objet)) + 1) * sizeof(unsigned char))); @@ -1790,7 +1853,7 @@ copie_objet(struct_processus *s_etat_pro (*l_element_courant_lecture).suivant; } - (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *) + (*s_nouvel_objet).objet = ((struct_liste_chainee *) l_element_base); } else // type == 'P' @@ -1997,7 +2060,7 @@ copie_objet(struct_processus *s_etat_pro (*l_element_courant_lecture).suivant; } - (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *) + (*s_nouvel_objet).objet = ((struct_liste_chainee *) l_element_base); } else @@ -2032,9 +2095,8 @@ copie_objet(struct_processus *s_etat_pro } (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau = - (void **) ((integer8 **) malloc( - ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes) - * sizeof(integer8 *))); + malloc(((size_t) ((*((struct_matrice *) + ((*s_objet).objet))).nombre_lignes)) * sizeof(integer8 *)); if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau == NULL) @@ -2056,9 +2118,9 @@ copie_objet(struct_processus *s_etat_pro { if ((((integer8 **) ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau))[i] = - (void *) ((integer8 *) malloc( + ((integer8 *) malloc(((size_t) ((*((struct_matrice *) ((*s_objet).objet))) - .nombre_colonnes) * sizeof(integer8)))) == NULL) + .nombre_colonnes)) * sizeof(integer8)))) == NULL) { for(j = 0; j < i; j++) { @@ -2099,9 +2161,9 @@ copie_objet(struct_processus *s_etat_pro } (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau = - (void **) ((struct_complexe16 **) malloc( - ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes) - * sizeof(struct_complexe16 *))); + malloc(((size_t) ((*((struct_matrice *) + ((*s_objet).objet))).nombre_lignes)) + * sizeof(struct_complexe16 *)); if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau == NULL) @@ -2123,9 +2185,9 @@ copie_objet(struct_processus *s_etat_pro { if ((((struct_complexe16 **) ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau))[i] = - (void *) ((struct_complexe16 *) malloc( + ((struct_complexe16 *) malloc(((size_t) ((*((struct_matrice *) ((*s_objet).objet))) - .nombre_colonnes) * sizeof(struct_complexe16)))) + .nombre_colonnes)) * sizeof(struct_complexe16)))) == NULL) { for(j = 0; j < i; j++) @@ -2166,9 +2228,8 @@ copie_objet(struct_processus *s_etat_pro } (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau = - (void **) ((real8 **) malloc( - ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes) - * sizeof(real8 *))); + malloc(((size_t) ((*((struct_matrice *) + ((*s_objet).objet))).nombre_lignes)) * sizeof(real8 *)); if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau == NULL) @@ -2190,9 +2251,9 @@ copie_objet(struct_processus *s_etat_pro { if ((((real8 **) ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau))[i] = - (void *) ((real8 *) malloc( + ((real8 *) malloc(((size_t) ((*((struct_matrice *) ((*s_objet).objet))) - .nombre_colonnes) * sizeof(real8)))) == NULL) + .nombre_colonnes)) * sizeof(real8)))) == NULL) { for(j = 0; j < i; j++) { @@ -2220,20 +2281,9 @@ copie_objet(struct_processus *s_etat_pro case MTX : { - if (type != 'O') - { - incrementation_atomique(s_objet); - return(s_objet); - } - - if ((s_nouvel_objet = allocation(s_etat_processus, MTX)) == NULL) - { - return(NULL); - } - - (*((struct_mutex *) ((*s_nouvel_objet).objet))).mutex = - (*((struct_mutex *) ((*s_objet).objet))).mutex; - break; + // La duplication d'un mutex renvoie le même objet. + incrementation_atomique(s_objet); + return(s_objet); } case NOM : @@ -2275,26 +2325,25 @@ copie_objet(struct_processus *s_etat_pro return(s_objet); } + // Un objet de type NON est un objet encapsulé dans une + // structure de type struct_objet. Elle peut très bien contenir + // une donnée, mais c'est à l'utilisateur de la libérer + // explicitement avec un free(). + if ((s_nouvel_objet = allocation(s_etat_processus, NON)) == NULL) { return(NULL); } - (*s_nouvel_objet).objet = NULL; + (*s_nouvel_objet).objet = (*s_objet).objet; break; } case PRC : { - sigfillset(&set); - pthread_sigmask(SIG_BLOCK, &set, &oldset); - if (pthread_mutex_lock(&((*(*((struct_processus_fils *) (*s_objet).objet)).thread).mutex_nombre_references)) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - return(NULL); } @@ -2304,15 +2353,9 @@ copie_objet(struct_processus *s_etat_pro if (pthread_mutex_unlock(&((*(*((struct_processus_fils *) (*s_objet).objet)).thread).mutex_nombre_references)) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - return(NULL); } - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - if (type != 'O') { incrementation_atomique(s_objet); @@ -2500,6 +2543,8 @@ copie_objet(struct_processus *s_etat_pro return(NULL); } + (*((struct_semaphore *) (*s_nouvel_objet).objet)).semaphore = + (*((struct_semaphore *) (*s_objet).objet)).semaphore; strcpy((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom, (*((struct_semaphore *) (*s_objet).objet)).nom); break; @@ -2578,8 +2623,9 @@ copie_objet(struct_processus *s_etat_pro (*s_objet).objet)).nombre_elements; if (((*((struct_tableau *) (*s_nouvel_objet).objet)).elements = - malloc((*((struct_tableau *) (*s_objet).objet)) - .nombre_elements * sizeof(struct_objet *))) == NULL) + malloc(((size_t) (*((struct_tableau *) + (*s_objet).objet)).nombre_elements) + * sizeof(struct_objet *))) == NULL) { return(NULL); } @@ -2639,8 +2685,8 @@ copie_objet(struct_processus *s_etat_pro } (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau = - (void *) ((integer8 *) malloc( - ((*((struct_vecteur *) ((*s_objet).objet))).taille) + ((integer8 *) malloc(((size_t) + ((*((struct_vecteur *) ((*s_objet).objet))).taille)) * sizeof(integer8))); if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau @@ -2682,8 +2728,8 @@ copie_objet(struct_processus *s_etat_pro } (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau = - (void *) ((struct_complexe16 *) malloc( - ((*((struct_vecteur *) ((*s_objet).objet))).taille) + ((struct_complexe16 *) malloc(((size_t) + ((*((struct_vecteur *) ((*s_objet).objet))).taille)) * sizeof(struct_complexe16))); if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau @@ -2725,8 +2771,8 @@ copie_objet(struct_processus *s_etat_pro } (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau = - (void *) ((real8 *) malloc( - ((*((struct_vecteur *) ((*s_objet).objet))).taille) + ((real8 *) malloc(((size_t) + ((*((struct_vecteur *) ((*s_objet).objet))).taille)) * sizeof(real8))); if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau @@ -2789,7 +2835,7 @@ copie_etat_processus(struct_processus *s struct_processus *s_nouvel_etat_processus; - unsigned long i; + integer8 i; if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) { @@ -2817,16 +2863,14 @@ copie_etat_processus(struct_processus *s * n'ont aucune raison de changer. */ -# ifndef SEMAPHORES_NOMMES - sem_init(&((*s_nouvel_etat_processus).semaphore_fork), 0, 0); -# else - if (((*s_nouvel_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) - == SEM_FAILED) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return(NULL); - } -# endif + (*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 + // s'agit d'une limitation de l'implantation de l'émulation + // de sem_init(). + + initialisation_contexte_cas(s_etat_processus); (*s_nouvel_etat_processus).var_volatile_processus_pere = 0; (*s_nouvel_etat_processus).var_volatile_processus_racine = 0; @@ -3110,76 +3154,18 @@ copie_etat_processus(struct_processus *s * Copie de la table des variables */ - if (((*s_nouvel_etat_processus).s_arbre_variables = - copie_arbre_variables(s_etat_processus)) == NULL) - { - return(NULL); - } - - // La pile des variables par niveau n'est pas copiée puisqu'il est - // impossible n'enlever dans un thread une variable créée dans le père. + (*s_nouvel_etat_processus).l_liste_variables_statiques = NULL; + copie_arbre_variables(s_etat_processus, s_nouvel_etat_processus); - (*s_etat_processus).l_liste_variables_par_niveau = NULL; - - /* - * Copie de la table des variables statiques - */ - - if (((*s_nouvel_etat_processus).s_liste_variables_statiques = - malloc((*s_etat_processus).nombre_variables_statiques_allouees * - sizeof(struct_variable_statique))) == NULL) + if ((*s_nouvel_etat_processus).erreur_systeme != d_es) { - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return(NULL); - } - - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } - for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++) - { - if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom = - malloc((strlen((*s_etat_processus).s_liste_variables_statiques - [i].nom) + 1) * sizeof(unsigned char))) == NULL) - { - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return(NULL); - } - - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return(NULL); - } - - strcpy((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom, - (*s_etat_processus).s_liste_variables_statiques[i].nom); - - (*s_nouvel_etat_processus).s_liste_variables_statiques[i].origine = - (*s_etat_processus).s_liste_variables_statiques[i].origine; - (*s_nouvel_etat_processus).s_liste_variables_statiques[i].niveau = - (*s_etat_processus).s_liste_variables_statiques[i].niveau; - (*s_nouvel_etat_processus).s_liste_variables_statiques[i] - .variable_statique = (*s_etat_processus) - .s_liste_variables_statiques[i].variable_statique; - - if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].objet = - copie_objet(s_etat_processus, (*s_etat_processus) - .s_liste_variables_statiques[i].objet, 'P')) == NULL) - { - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return(NULL); - } - - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return(NULL); - } - } + (*(*s_nouvel_etat_processus).l_liste_variables_partagees) = + (*(*s_etat_processus).l_liste_variables_partagees); + (*(*s_nouvel_etat_processus).s_arbre_variables_partagees) = + (*(*s_etat_processus).s_arbre_variables_partagees); /* * Copie de la pile opérationnelle @@ -3288,6 +3274,9 @@ copie_etat_processus(struct_processus *s * Copie des différents contextes */ + (*s_nouvel_etat_processus).pointeur_signal_lecture = d_faux; + (*s_nouvel_etat_processus).pointeur_signal_ecriture = d_faux; + (*s_nouvel_etat_processus).l_base_pile_contextes = NULL; l_element_lecture = (*s_etat_processus).l_base_pile_contextes; @@ -3498,7 +3487,8 @@ copie_etat_processus(struct_processus *s if ((*s_etat_processus).nombre_instructions_externes != 0) { if (((*s_nouvel_etat_processus).s_instructions_externes = - malloc((*s_etat_processus).nombre_instructions_externes * + malloc(((size_t) (*s_etat_processus) + .nombre_instructions_externes) * sizeof(struct_instruction_externe))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -3952,22 +3942,10 @@ debug_fork() pthread_mutex_lock(&mutex_allocation); pid = fork(); -# ifdef OS2 if (pid == 0) { - sem_init(&semaphore_liste_threads, 0, 1); - sem_init(&semaphore_gestionnaires_signaux, 0, 0); - sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1); - sem_init(&((*s_etat_processus).semaphore_fork), 0, 0); - } -# endif - - if (pid == 0) - { -# ifdef _BROKEN_SIGINFO - liberation_fifos_signaux(s_etat_processus); - creation_fifos_signaux(s_etat_processus); -# endif + liberation_queue_signaux(s_etat_processus); + creation_queue_signaux(s_etat_processus); pthread_mutex_destroy(&mutex_allocation); debug_memoire_initialisation();