version 1.19, 2011/06/10 11:35:13
|
version 1.49, 2013/02/27 17:11:44
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.1.0.prerelease.0 |
RPL/2 (R) version 4.1.13 |
Copyright (C) 1989-2011 Dr. BERTRAND Joël |
Copyright (C) 1989-2013 Dr. BERTRAND Joël |
|
|
This file is part of RPL/2. |
This file is part of RPL/2. |
|
|
Line 237 instruction_version(struct_processus *s_
|
Line 237 instruction_version(struct_processus *s_
|
struct_objet *s_objet_resultat; |
struct_objet *s_objet_resultat; |
|
|
unsigned char texte[] = "RPL/2 version "; |
unsigned char texte[] = "RPL/2 version "; |
|
unsigned char tampon[256 + 1]; |
|
|
(*s_etat_processus).erreur_execution = d_ex; |
(*s_etat_processus).erreur_execution = d_ex; |
|
|
Line 499 instruction_version(struct_processus *s_
|
Line 500 instruction_version(struct_processus *s_
|
return; |
return; |
} |
} |
|
|
if (((*(*l_element_courant).donnee).objet = malloc((strlen(d_date_en_rpl) |
if (((*(*l_element_courant).donnee).objet = date_compilation()) == 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; |
return; |
} |
} |
|
|
strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, |
|
d_date_en_rpl); |
|
|
|
/* |
/* |
* Ajout des options de compilation |
* Ajout des options de compilation |
*/ |
*/ |
Line 830 instruction_version(struct_processus *s_
|
Line 827 instruction_version(struct_processus *s_
|
return; |
return; |
} |
} |
|
|
#ifdef DEBUG |
#ifdef RPLCAS |
if (((*(*l_element_courant).donnee).objet = malloc(6 * |
if (((*(*l_element_courant).donnee).objet = malloc(8 * |
sizeof(unsigned char))) == NULL) |
sizeof(unsigned char))) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
Line 839 instruction_version(struct_processus *s_
|
Line 836 instruction_version(struct_processus *s_
|
} |
} |
|
|
strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, |
strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, |
"DEBUG"); |
"RPL/CAS"); |
#else |
#else |
if (((*(*l_element_courant).donnee).objet = malloc(15 * |
if (((*(*l_element_courant).donnee).objet = malloc(17 * |
sizeof(unsigned char))) == NULL) |
sizeof(unsigned char))) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
Line 849 instruction_version(struct_processus *s_
|
Line 846 instruction_version(struct_processus *s_
|
} |
} |
|
|
strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, |
strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, |
"DEBUG DISABLED"); |
"RPL/CAS DISABLED"); |
#endif |
#endif |
|
|
if (((*l_element_courant).suivant = |
if (((*l_element_courant).suivant = |
Line 891 instruction_version(struct_processus *s_
|
Line 888 instruction_version(struct_processus *s_
|
"EXPERIMENTAL CODE DISABLED"); |
"EXPERIMENTAL CODE DISABLED"); |
#endif |
#endif |
|
|
|
if (((*l_element_courant).suivant = |
|
allocation_maillon(s_etat_processus)) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
l_element_courant = (*l_element_courant).suivant; |
|
(*l_element_courant).suivant = NULL; |
|
|
|
if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) |
|
== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
sprintf(tampon, "%zu BITS ABI", sizeof(void *) * 8); |
|
|
|
if (((*(*l_element_courant).donnee).objet = malloc((strlen(tampon) + 1 ) |
|
* sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, tampon); |
|
|
|
if (((*l_element_courant).suivant = |
|
allocation_maillon(s_etat_processus)) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
l_element_courant = (*l_element_courant).suivant; |
|
(*l_element_courant).suivant = NULL; |
|
|
|
if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) |
|
== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
if (((*(*l_element_courant).donnee).objet = conversion_majuscule(HOST)) |
|
== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
/* |
/* |
* Empilement du résultat |
* Empilement du résultat |
*/ |
*/ |
Line 920 instruction_version(struct_processus *s_
|
Line 969 instruction_version(struct_processus *s_
|
void |
void |
instruction_vars(struct_processus *s_etat_processus) |
instruction_vars(struct_processus *s_etat_processus) |
{ |
{ |
|
int i; |
|
int nb_variables; |
|
|
logical1 variable_partagee; |
logical1 variable_partagee; |
|
|
struct_liste_chainee *l_element_courant; |
struct_liste_chainee *l_element_courant; |
Line 927 instruction_vars(struct_processus *s_eta
|
Line 979 instruction_vars(struct_processus *s_eta
|
|
|
struct_objet *s_objet_resultat; |
struct_objet *s_objet_resultat; |
|
|
unsigned long i; |
struct_tableau_variables *tableau; |
|
|
(*s_etat_processus).erreur_execution = d_ex; |
(*s_etat_processus).erreur_execution = d_ex; |
|
|
Line 971 instruction_vars(struct_processus *s_eta
|
Line 1023 instruction_vars(struct_processus *s_eta
|
(*s_objet_resultat).objet = NULL; |
(*s_objet_resultat).objet = NULL; |
l_element_precedent = NULL; |
l_element_precedent = NULL; |
|
|
#if 0 |
nb_variables = nombre_variables(s_etat_processus); |
for(i = 0; i < (*s_etat_processus).nombre_variables; i++) |
|
|
if ((tableau = malloc(nb_variables * sizeof(struct_tableau_variables))) |
|
== NULL) |
|
{ |
|
liberation_mutexes_arbre_variables_partagees(s_etat_processus, |
|
(*(*s_etat_processus).s_arbre_variables_partagees)); |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
liste_variables(s_etat_processus, tableau); |
|
|
|
for(i = 0; i < nb_variables; i++) |
{ |
{ |
if (l_element_precedent == NULL) |
if (l_element_precedent == NULL) |
{ |
{ |
Line 1022 instruction_vars(struct_processus *s_eta
|
Line 1086 instruction_vars(struct_processus *s_eta
|
* Mise en place d'un verrou si la variable est partagée. |
* Mise en place d'un verrou si la variable est partagée. |
*/ |
*/ |
|
|
if ((*s_etat_processus).s_liste_variables[i].objet == NULL) |
if (tableau[i].objet == NULL) |
{ |
{ |
if (pthread_mutex_lock(&((*(*s_etat_processus) |
|
.s_liste_variables_partagees).mutex)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
|
|
if (recherche_variable_partagee(s_etat_processus, |
if (recherche_variable_partagee(s_etat_processus, |
((*s_etat_processus).s_liste_variables[i]).nom, |
tableau[i].nom, tableau[i].variable_partagee, |
((*s_etat_processus).s_liste_variables[i]) |
tableau[i].origine) == NULL) |
.variable_partagee, ((*s_etat_processus) |
|
.s_liste_variables[i]).origine) == d_faux) |
|
{ |
{ |
// La variable partagée n'existe plus. |
// La variable partagée n'existe plus. |
|
|
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
|
.s_liste_variables_partagees).mutex)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
|
|
continue; |
continue; |
} |
} |
|
|
Line 1067 instruction_vars(struct_processus *s_eta
|
Line 1115 instruction_vars(struct_processus *s_eta
|
if (variable_partagee == d_vrai) |
if (variable_partagee == d_vrai) |
{ |
{ |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
.s_liste_variables_partagees).mutex)) != 0) |
.pointeur_variable_partagee_courante).mutex)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 1084 instruction_vars(struct_processus *s_eta
|
Line 1132 instruction_vars(struct_processus *s_eta
|
|
|
if (((*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *) |
if (((*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *) |
(*l_element_courant).donnee)).objet)).donnee).objet)).nom = |
(*l_element_courant).donnee)).objet)).donnee).objet)).nom = |
malloc((strlen((*s_etat_processus).s_liste_variables[i].nom) |
malloc((strlen(tableau[i].nom) |
+ 1) * sizeof(unsigned char))) == NULL) |
+ 1) * sizeof(unsigned char))) == NULL) |
{ |
{ |
if (variable_partagee == d_vrai) |
if (variable_partagee == d_vrai) |
{ |
{ |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
.s_liste_variables_partagees).mutex)) != 0) |
.pointeur_variable_partagee_courante).mutex)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 1103 instruction_vars(struct_processus *s_eta
|
Line 1151 instruction_vars(struct_processus *s_eta
|
|
|
strcpy((*((struct_nom *) (*(*((struct_liste_chainee *) |
strcpy((*((struct_nom *) (*(*((struct_liste_chainee *) |
(*((struct_objet *) (*l_element_courant).donnee)).objet)) |
(*((struct_objet *) (*l_element_courant).donnee)).objet)) |
.donnee).objet)).nom, (*s_etat_processus) |
.donnee).objet)).nom, tableau[i].nom); |
.s_liste_variables[i].nom); |
|
|
|
/* |
/* |
* Préparation du niveau |
* Préparation du niveau |
Line 1117 instruction_vars(struct_processus *s_eta
|
Line 1164 instruction_vars(struct_processus *s_eta
|
if (variable_partagee == d_vrai) |
if (variable_partagee == d_vrai) |
{ |
{ |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
.s_liste_variables_partagees).mutex)) != 0) |
.pointeur_variable_partagee_courante).mutex)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 1135 instruction_vars(struct_processus *s_eta
|
Line 1182 instruction_vars(struct_processus *s_eta
|
if (variable_partagee == d_vrai) |
if (variable_partagee == d_vrai) |
{ |
{ |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
.s_liste_variables_partagees).mutex)) != 0) |
.pointeur_variable_partagee_courante).mutex)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 1148 instruction_vars(struct_processus *s_eta
|
Line 1195 instruction_vars(struct_processus *s_eta
|
|
|
(*((integer8 *) (*(*(*((struct_liste_chainee *) (*((struct_objet *) |
(*((integer8 *) (*(*(*((struct_liste_chainee *) (*((struct_objet *) |
(*l_element_courant).donnee)).objet)).suivant).donnee).objet)) = |
(*l_element_courant).donnee)).objet)).suivant).donnee).objet)) = |
(integer8) (*s_etat_processus).s_liste_variables[i].niveau; |
(integer8) tableau[i].niveau; |
|
|
/* |
/* |
* Préparation du contenu de la variable |
* Préparation du contenu de la variable |
Line 1161 instruction_vars(struct_processus *s_eta
|
Line 1208 instruction_vars(struct_processus *s_eta
|
if (variable_partagee == d_vrai) |
if (variable_partagee == d_vrai) |
{ |
{ |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
.s_liste_variables_partagees).mutex)) != 0) |
.pointeur_variable_partagee_courante).mutex)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 1172 instruction_vars(struct_processus *s_eta
|
Line 1219 instruction_vars(struct_processus *s_eta
|
return; |
return; |
} |
} |
|
|
if ((*s_etat_processus).s_liste_variables[i].objet == NULL) |
if (tableau[i].objet == NULL) |
{ |
{ |
// Variable partagée |
// Variable partagée |
|
|
if (((*(*(*((struct_liste_chainee *) (*((struct_objet *) |
if (((*(*(*((struct_liste_chainee *) (*((struct_objet *) |
(*l_element_courant).donnee)).objet)).suivant).suivant) |
(*l_element_courant).donnee)).objet)).suivant).suivant) |
.donnee = copie_objet(s_etat_processus, |
.donnee = copie_objet(s_etat_processus, |
(*(*s_etat_processus) |
(*(*s_etat_processus).pointeur_variable_partagee_courante) |
.s_liste_variables_partagees).table[(*(*s_etat_processus) |
.objet, 'P')) == NULL) |
.s_liste_variables_partagees).position_variable].objet, |
|
'P')) == NULL) |
|
{ |
{ |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
.s_liste_variables_partagees).mutex)) != 0) |
.pointeur_variable_partagee_courante).mutex)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 1196 instruction_vars(struct_processus *s_eta
|
Line 1241 instruction_vars(struct_processus *s_eta
|
} |
} |
|
|
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
.s_liste_variables_partagees).mutex)) != 0) |
.pointeur_variable_partagee_courante).mutex)) != 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 1208 instruction_vars(struct_processus *s_eta
|
Line 1253 instruction_vars(struct_processus *s_eta
|
|
|
if (((*(*(*((struct_liste_chainee *) (*((struct_objet *) |
if (((*(*(*((struct_liste_chainee *) (*((struct_objet *) |
(*l_element_courant).donnee)).objet)).suivant).suivant) |
(*l_element_courant).donnee)).objet)).suivant).suivant) |
.donnee = copie_objet(s_etat_processus, (*s_etat_processus) |
.donnee = copie_objet(s_etat_processus, tableau[i].objet, |
.s_liste_variables[i].objet, 'P')) == NULL) |
'P')) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return; |
return; |
Line 1236 instruction_vars(struct_processus *s_eta
|
Line 1281 instruction_vars(struct_processus *s_eta
|
return; |
return; |
} |
} |
|
|
if (((*s_etat_processus).s_liste_variables[i].origine == 'P') |
if ((tableau[i].origine == 'P') |
? ((*s_etat_processus).s_liste_variables[i] |
? (tableau[i].variable_statique.adresse != 0) |
.variable_statique.adresse != 0) |
: (tableau[i].variable_statique.pointeur != NULL)) |
: ((*s_etat_processus).s_liste_variables[i] |
|
.variable_statique.pointeur != NULL)) |
|
{ |
{ |
if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) |
if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) |
(*l_element_courant).donnee)).objet)).suivant).suivant) |
(*l_element_courant).donnee)).objet)).suivant).suivant) |
Line 1251 instruction_vars(struct_processus *s_eta
|
Line 1294 instruction_vars(struct_processus *s_eta
|
return; |
return; |
} |
} |
|
|
strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *) |
if (tableau[i].variable_masquee == d_vrai) |
(*((struct_objet *) (*l_element_courant).donnee)).objet)) |
{ |
.suivant).suivant) .suivant).donnee).objet, "STATIC"); |
strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *) |
|
(*((struct_objet *) (*l_element_courant).donnee)) |
|
.objet)).suivant).suivant).suivant).donnee).objet, |
|
"SHADOW"); |
|
} |
|
else |
|
{ |
|
strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *) |
|
(*((struct_objet *) (*l_element_courant).donnee)) |
|
.objet)).suivant).suivant).suivant).donnee).objet, |
|
"STATIC"); |
|
} |
} |
} |
else |
else |
{ |
{ |
Line 1293 instruction_vars(struct_processus *s_eta
|
Line 1347 instruction_vars(struct_processus *s_eta
|
return; |
return; |
} |
} |
|
|
if ((*s_etat_processus).s_liste_variables[i].variable_verrouillee |
if (tableau[i].variable_verrouillee == d_vrai) |
== d_vrai) |
|
{ |
{ |
if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) |
if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) |
(*l_element_courant).donnee)).objet)).suivant).suivant) |
(*l_element_courant).donnee)).objet)).suivant).suivant) |
Line 1392 instruction_vars(struct_processus *s_eta
|
Line 1445 instruction_vars(struct_processus *s_eta
|
|
|
l_element_precedent = l_element_courant; |
l_element_precedent = l_element_courant; |
} |
} |
#endif |
|
|
free(tableau); |
|
|
if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), |
if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), |
s_objet_resultat) == d_erreur) |
s_objet_resultat) == d_erreur) |