version 1.10, 2010/04/21 13:45:47
|
version 1.61, 2013/12/12 07:26:53
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.0.15 |
RPL/2 (R) version 4.1.17 |
Copyright (C) 1989-2010 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 20
|
Line 20
|
*/ |
*/ |
|
|
|
|
#include "rpl.conv.h" |
#include "rpl-conv.h" |
|
|
|
|
/* |
/* |
Line 53 instruction_fleche(struct_processus *s_e
|
Line 53 instruction_fleche(struct_processus *s_e
|
logical1 fin_scrutation; |
logical1 fin_scrutation; |
logical1 presence_expression_algebrique; |
logical1 presence_expression_algebrique; |
|
|
|
pthread_mutexattr_t attributs_mutex; |
|
|
union_position_variable position_variable; |
union_position_variable position_variable; |
|
|
unsigned char instruction_valide; |
unsigned char instruction_valide; |
unsigned char *tampon; |
unsigned char *tampon; |
unsigned char test_instruction; |
unsigned char test_instruction; |
|
|
unsigned long i; |
integer8 i; |
unsigned long nombre_variables; |
integer8 nombre_variables; |
|
|
void (*fonction)(); |
void (*fonction)(); |
|
|
Line 339 instruction_fleche(struct_processus *s_e
|
Line 341 instruction_fleche(struct_processus *s_e
|
{ |
{ |
if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
{ |
{ |
printf("[%d] Nombre de variables de niveau %lu : %lu\n", |
printf("[%d] Nombre de variables de niveau %lld : %lld\n", |
(int) getpid(), |
(int) getpid(), |
(*s_etat_processus).niveau_courant, nombre_variables); |
(*s_etat_processus).niveau_courant, nombre_variables); |
} |
} |
else |
else |
{ |
{ |
printf("[%d] Number of level %lu variables : %lu\n", |
printf("[%d] Number of level %lld variables : %lld\n", |
(int) getpid(), |
(int) getpid(), |
(*s_etat_processus).niveau_courant, nombre_variables); |
(*s_etat_processus).niveau_courant, nombre_variables); |
} |
} |
Line 357 instruction_fleche(struct_processus *s_e
|
Line 359 instruction_fleche(struct_processus *s_e
|
|
|
for(i = 0; i < nombre_variables; i++) |
for(i = 0; i < nombre_variables; i++) |
{ |
{ |
|
if (l_emplacement_valeurs == NULL) |
|
{ |
|
(*s_etat_processus).erreur_execution = d_ex_manque_argument; |
|
return; |
|
} |
|
|
l_emplacement_valeurs = (*l_emplacement_valeurs).suivant; |
l_emplacement_valeurs = (*l_emplacement_valeurs).suivant; |
} |
} |
|
|
Line 422 instruction_fleche(struct_processus *s_e
|
Line 430 instruction_fleche(struct_processus *s_e
|
if (recherche_variable(s_etat_processus, s_variable.nom) == d_vrai) |
if (recherche_variable(s_etat_processus, s_variable.nom) == d_vrai) |
{ |
{ |
if ((*s_etat_processus).niveau_courant == |
if ((*s_etat_processus).niveau_courant == |
(*s_etat_processus).s_liste_variables[(*s_etat_processus) |
(*(*s_etat_processus).pointeur_variable_courante).niveau) |
.position_variable_courante].niveau) |
|
{ |
{ |
liberation(s_etat_processus, s_objet); |
liberation(s_etat_processus, s_objet); |
free(s_variable.nom); |
free(s_variable.nom); |
Line 452 instruction_fleche(struct_processus *s_e
|
Line 459 instruction_fleche(struct_processus *s_e
|
if (recherche_variable_statique(s_etat_processus, s_variable.nom, |
if (recherche_variable_statique(s_etat_processus, s_variable.nom, |
position_variable, |
position_variable, |
((*s_etat_processus).mode_execution_programme == 'Y') |
((*s_etat_processus).mode_execution_programme == 'Y') |
? 'P' : 'E') == d_vrai) |
? 'P' : 'E') != NULL) |
{ |
{ |
// Variable statique à utiliser |
// Variable statique à utiliser |
|
|
Line 465 instruction_fleche(struct_processus *s_e
|
Line 472 instruction_fleche(struct_processus *s_e
|
s_variable.origine = 'E'; |
s_variable.origine = 'E'; |
} |
} |
|
|
s_variable.objet = (*s_etat_processus) |
s_variable.objet = (*(*s_etat_processus) |
.s_liste_variables_statiques[(*s_etat_processus) |
.pointeur_variable_statique_courante).objet; |
.position_variable_statique_courante].objet; |
(*(*s_etat_processus).pointeur_variable_statique_courante) |
(*s_etat_processus).s_liste_variables_statiques |
.objet = NULL; |
[(*s_etat_processus) |
|
.position_variable_statique_courante].objet = NULL; |
|
} |
} |
else |
else |
{ |
{ |
Line 546 instruction_fleche(struct_processus *s_e
|
Line 551 instruction_fleche(struct_processus *s_e
|
(*s_etat_processus).objet_courant; |
(*s_etat_processus).objet_courant; |
} |
} |
|
|
if (pthread_mutex_lock(&((*(*s_etat_processus) |
if (pthread_mutex_lock(&mutex_creation_variable_partagee) != 0) |
.s_liste_variables_partagees).mutex)) != 0) |
|
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
Line 556 instruction_fleche(struct_processus *s_e
|
Line 560 instruction_fleche(struct_processus *s_e
|
if (recherche_variable_partagee(s_etat_processus, s_variable.nom, |
if (recherche_variable_partagee(s_etat_processus, s_variable.nom, |
position_variable, |
position_variable, |
((*s_etat_processus).mode_execution_programme == 'Y') |
((*s_etat_processus).mode_execution_programme == 'Y') |
? 'P' : 'E') == d_vrai) |
? 'P' : 'E') != NULL) |
{ |
{ |
// Variable partagée à utiliser |
// Variable partagée à utiliser |
|
|
|
if (pthread_mutex_unlock(&mutex_creation_variable_partagee) |
|
!= 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
|
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 584 instruction_fleche(struct_processus *s_e
|
Line 595 instruction_fleche(struct_processus *s_e
|
} |
} |
else |
else |
{ |
{ |
// Variable partagée à utiliser |
// Variable partagée à créer |
// Variable partagee à créer |
|
|
|
(*s_etat_processus).erreur_systeme = d_es; |
(*s_etat_processus).erreur_systeme = d_es; |
|
|
if ((s_variable_partagee.nom = malloc((strlen(s_variable.nom) |
if ((s_variable_partagee.nom = malloc((strlen(s_variable.nom) |
+ 1) * sizeof(unsigned char))) == NULL) |
+ 1) * sizeof(unsigned char))) == NULL) |
{ |
{ |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
|
.s_liste_variables_partagees).mutex)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
|
|
(*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
d_es_allocation_memoire; |
d_es_allocation_memoire; |
return; |
return; |
Line 639 instruction_fleche(struct_processus *s_e
|
Line 642 instruction_fleche(struct_processus *s_e
|
(*s_etat_processus).objet_courant; |
(*s_etat_processus).objet_courant; |
} |
} |
|
|
|
// Création du mutex |
|
|
|
pthread_mutexattr_init(&attributs_mutex); |
|
pthread_mutexattr_settype(&attributs_mutex, |
|
PTHREAD_MUTEX_RECURSIVE); |
|
pthread_mutex_init(&(s_variable_partagee.mutex), |
|
&attributs_mutex); |
|
pthread_mutexattr_destroy(&attributs_mutex); |
|
|
s_variable_partagee.objet = (*l_emplacement_valeurs).donnee; |
s_variable_partagee.objet = (*l_emplacement_valeurs).donnee; |
(*l_emplacement_valeurs).donnee = NULL; |
(*l_emplacement_valeurs).donnee = NULL; |
|
|
if (creation_variable_partagee(s_etat_processus, |
if (creation_variable_partagee(s_etat_processus, |
&s_variable_partagee) == d_erreur) |
&s_variable_partagee) == d_erreur) |
{ |
{ |
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
|
.s_liste_variables_partagees).mutex)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
|
|
return; |
return; |
} |
} |
|
|
if (pthread_mutex_unlock(&((*(*s_etat_processus) |
s_variable.objet = NULL; |
.s_liste_variables_partagees).mutex)) != 0) |
|
|
if (pthread_mutex_unlock(&mutex_creation_variable_partagee) |
|
!= 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
} |
} |
|
|
s_variable.objet = NULL; |
|
} |
} |
} |
} |
else |
else |
Line 730 instruction_fleche(struct_processus *s_e
|
Line 735 instruction_fleche(struct_processus *s_e
|
|
|
(*s_etat_processus).niveau_courant--; |
(*s_etat_processus).niveau_courant--; |
|
|
if (retrait_variable_par_niveau(s_etat_processus) == d_erreur) |
if (retrait_variables_par_niveau(s_etat_processus) == d_erreur) |
{ |
{ |
return; |
return; |
} |
} |
Line 761 instruction_fleche_list(struct_processus
|
Line 766 instruction_fleche_list(struct_processus
|
|
|
struct_objet *s_objet; |
struct_objet *s_objet; |
|
|
signed long i; |
integer8 i; |
signed long nombre_elements; |
integer8 nombre_elements; |
|
|
(*s_etat_processus).erreur_execution = d_ex; |
(*s_etat_processus).erreur_execution = d_ex; |
|
|
Line 837 instruction_fleche_list(struct_processus
|
Line 842 instruction_fleche_list(struct_processus
|
return; |
return; |
} |
} |
|
|
if ((unsigned long) nombre_elements >= |
if (nombre_elements >= (*s_etat_processus).hauteur_pile_operationnelle) |
(*s_etat_processus).hauteur_pile_operationnelle) |
|
{ |
{ |
(*s_etat_processus).erreur_execution = d_ex_manque_argument; |
(*s_etat_processus).erreur_execution = d_ex_manque_argument; |
return; |
return; |
Line 979 instruction_for(struct_processus *s_etat
|
Line 983 instruction_for(struct_processus *s_etat
|
} |
} |
} |
} |
|
|
empilement_pile_systeme(s_etat_processus); |
|
|
|
if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), |
if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), |
&s_objet_1) == d_erreur) |
&s_objet_1) == d_erreur) |
{ |
{ |
Line 1006 instruction_for(struct_processus *s_etat
|
Line 1008 instruction_for(struct_processus *s_etat
|
return; |
return; |
} |
} |
|
|
if (((*s_objet_2).type != INT) && |
if (((*s_objet_2).type != INT) && ((*s_objet_2).type != REL)) |
((*s_objet_2).type != REL)) |
|
{ |
{ |
liberation(s_etat_processus, s_objet_1); |
liberation(s_etat_processus, s_objet_1); |
liberation(s_etat_processus, s_objet_2); |
liberation(s_etat_processus, s_objet_2); |
Line 1016 instruction_for(struct_processus *s_etat
|
Line 1017 instruction_for(struct_processus *s_etat
|
return; |
return; |
} |
} |
|
|
tampon = (*s_etat_processus).instruction_courante; |
empilement_pile_systeme(s_etat_processus); |
test_instruction = (*s_etat_processus).test_instruction; |
|
instruction_valide = (*s_etat_processus).instruction_valide; |
if ((*s_etat_processus).erreur_systeme != d_es) |
(*s_etat_processus).test_instruction = 'Y'; |
{ |
|
return; |
|
} |
|
|
if ((*s_etat_processus).mode_execution_programme == 'Y') |
if ((*s_etat_processus).mode_execution_programme == 'Y') |
{ |
{ |
|
tampon = (*s_etat_processus).instruction_courante; |
|
test_instruction = (*s_etat_processus).test_instruction; |
|
instruction_valide = (*s_etat_processus).instruction_valide; |
|
(*s_etat_processus).test_instruction = 'Y'; |
|
|
if (recherche_instruction_suivante(s_etat_processus) == d_erreur) |
if (recherche_instruction_suivante(s_etat_processus) == d_erreur) |
{ |
{ |
return; |
return; |
Line 1037 instruction_for(struct_processus *s_etat
|
Line 1045 instruction_for(struct_processus *s_etat
|
|
|
free((*s_etat_processus).instruction_courante); |
free((*s_etat_processus).instruction_courante); |
(*s_etat_processus).instruction_courante = tampon; |
(*s_etat_processus).instruction_courante = tampon; |
|
(*s_etat_processus).instruction_valide = instruction_valide; |
|
(*s_etat_processus).test_instruction = test_instruction; |
|
|
|
depilement_pile_systeme(s_etat_processus); |
|
|
(*s_etat_processus).erreur_execution = d_ex_nom_reserve; |
(*s_etat_processus).erreur_execution = d_ex_nom_reserve; |
return; |
return; |
Line 1046 instruction_for(struct_processus *s_etat
|
Line 1058 instruction_for(struct_processus *s_etat
|
|
|
free((*s_etat_processus).instruction_courante); |
free((*s_etat_processus).instruction_courante); |
(*s_etat_processus).instruction_courante = tampon; |
(*s_etat_processus).instruction_courante = tampon; |
|
(*s_etat_processus).instruction_valide = instruction_valide; |
|
(*s_etat_processus).test_instruction = test_instruction; |
|
|
if ((*s_etat_processus).erreur_execution != d_ex) |
if ((*s_etat_processus).erreur_execution != d_ex) |
{ |
{ |
liberation(s_etat_processus, s_objet_1); |
liberation(s_etat_processus, s_objet_1); |
liberation(s_etat_processus, s_objet_2); |
liberation(s_etat_processus, s_objet_2); |
|
|
|
depilement_pile_systeme(s_etat_processus); |
return; |
return; |
} |
} |
|
|
Line 1061 instruction_for(struct_processus *s_etat
|
Line 1076 instruction_for(struct_processus *s_etat
|
liberation(s_etat_processus, s_objet_1); |
liberation(s_etat_processus, s_objet_1); |
liberation(s_etat_processus, s_objet_2); |
liberation(s_etat_processus, s_objet_2); |
|
|
|
depilement_pile_systeme(s_etat_processus); |
|
|
(*s_etat_processus).erreur_execution = d_ex_manque_argument; |
(*s_etat_processus).erreur_execution = d_ex_manque_argument; |
return; |
return; |
} |
} |
Line 1072 instruction_for(struct_processus *s_etat
|
Line 1089 instruction_for(struct_processus *s_etat
|
{ |
{ |
if ((*s_etat_processus).expression_courante == NULL) |
if ((*s_etat_processus).expression_courante == NULL) |
{ |
{ |
|
depilement_pile_systeme(s_etat_processus); |
(*s_etat_processus).erreur_execution = d_ex_manque_argument; |
(*s_etat_processus).erreur_execution = d_ex_manque_argument; |
return; |
return; |
} |
} |
Line 1096 instruction_for(struct_processus *s_etat
|
Line 1114 instruction_for(struct_processus *s_etat
|
liberation(s_etat_processus, s_objet_1); |
liberation(s_etat_processus, s_objet_1); |
liberation(s_etat_processus, s_objet_2); |
liberation(s_etat_processus, s_objet_2); |
|
|
|
depilement_pile_systeme(s_etat_processus); |
|
|
(*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle; |
(*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle; |
return; |
return; |
} |
} |
Line 1104 instruction_for(struct_processus *s_etat
|
Line 1124 instruction_for(struct_processus *s_etat
|
liberation(s_etat_processus, s_objet_1); |
liberation(s_etat_processus, s_objet_1); |
liberation(s_etat_processus, s_objet_2); |
liberation(s_etat_processus, s_objet_2); |
|
|
|
depilement_pile_systeme(s_etat_processus); |
|
|
(*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle; |
(*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle; |
return; |
return; |
} |
} |
Line 1129 instruction_for(struct_processus *s_etat
|
Line 1151 instruction_for(struct_processus *s_etat
|
|
|
liberation(s_etat_processus, s_objet_3); |
liberation(s_etat_processus, s_objet_3); |
|
|
(*s_etat_processus).test_instruction = test_instruction; |
|
(*s_etat_processus).instruction_valide = instruction_valide; |
|
|
|
(*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = s_objet_1; |
(*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = s_objet_1; |
|
|
if ((*s_etat_processus).mode_execution_programme == 'Y') |
if ((*s_etat_processus).mode_execution_programme == 'Y') |
Line 1828 instruction_fact(struct_processus *s_eta
|
Line 1847 instruction_fact(struct_processus *s_eta
|
for (i = 1; i <= (*((integer8 *) (*s_objet_argument).objet)); |
for (i = 1; i <= (*((integer8 *) (*s_objet_argument).objet)); |
i++) |
i++) |
{ |
{ |
produit *= i; |
produit *= (real8) i; |
} |
} |
|
|
if ((s_objet_resultat = allocation(s_etat_processus, REL)) |
if ((s_objet_resultat = allocation(s_etat_processus, REL)) |
Line 2152 instruction_floor(struct_processus *s_et
|
Line 2171 instruction_floor(struct_processus *s_et
|
return; |
return; |
} |
} |
|
|
(*((integer8 *) (*s_objet_resultat).objet)) = |
(*((integer8 *) (*s_objet_resultat).objet)) = (integer8) |
floor((*((real8 *) (*s_objet_argument).objet))); |
floor((*((real8 *) (*s_objet_argument).objet))); |
|
|
if (!((((*((integer8 *) (*s_objet_resultat).objet)) < |
if (!((((*((integer8 *) (*s_objet_resultat).objet)) < |
Line 2784 instruction_fix(struct_processus *s_etat
|
Line 2803 instruction_fix(struct_processus *s_etat
|
return; |
return; |
} |
} |
|
|
(*((logical8 *) (*s_objet).objet)) = |
(*((logical8 *) (*s_objet).objet)) = (logical8) |
(*((integer8 *) (*s_objet_argument).objet)); |
(*((integer8 *) (*s_objet_argument).objet)); |
|
|
i43 = test_cfsf(s_etat_processus, 43); |
i43 = test_cfsf(s_etat_processus, 43); |
Line 2822 instruction_fix(struct_processus *s_etat
|
Line 2841 instruction_fix(struct_processus *s_etat
|
{ |
{ |
if (valeur_binaire[i] == '0') |
if (valeur_binaire[i] == '0') |
{ |
{ |
cf(s_etat_processus, j++); |
cf(s_etat_processus, (unsigned char) j++); |
} |
} |
else |
else |
{ |
{ |
sf(s_etat_processus, j++); |
sf(s_etat_processus, (unsigned char) j++); |
} |
} |
} |
} |
|
|
for(; j <= 56; cf(s_etat_processus, j++)); |
for(; j <= 56; cf(s_etat_processus, (unsigned char) j++)); |
|
|
sf(s_etat_processus, 49); |
sf(s_etat_processus, 49); |
cf(s_etat_processus, 50); |
cf(s_etat_processus, 50); |