version 1.12, 2010/06/24 09:21:43
|
version 1.48, 2012/12/19 09:58:23
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.0.16 |
RPL/2 (R) version 4.1.12 |
Copyright (C) 1989-2010 Dr. BERTRAND Joël |
Copyright (C) 1989-2012 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 131 empilement_pile_systeme(struct_processus
|
Line 131 empilement_pile_systeme(struct_processus
|
(*(*s_etat_processus).l_base_pile_systeme).clause = ' '; |
(*(*s_etat_processus).l_base_pile_systeme).clause = ' '; |
(*(*s_etat_processus).l_base_pile_systeme).adresse_retour = 0; |
(*(*s_etat_processus).l_base_pile_systeme).adresse_retour = 0; |
(*(*s_etat_processus).l_base_pile_systeme).niveau_courant = 0; |
(*(*s_etat_processus).l_base_pile_systeme).niveau_courant = 0; |
|
(*(*s_etat_processus).l_base_pile_systeme).pointeur_adresse_retour = NULL; |
(*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N'; |
(*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N'; |
(*(*s_etat_processus).l_base_pile_systeme).indice_boucle = NULL; |
(*(*s_etat_processus).l_base_pile_systeme).indice_boucle = NULL; |
(*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = NULL; |
(*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = NULL; |
Line 301 effacement_pile_systeme(struct_processus
|
Line 302 effacement_pile_systeme(struct_processus
|
void |
void |
trace(struct_processus *s_etat_processus, FILE *flux) |
trace(struct_processus *s_etat_processus, FILE *flux) |
{ |
{ |
|
integer8 i; |
|
integer8 candidat; |
|
|
|
long delta; |
|
|
|
struct_liste_chainee *l_variable; |
|
struct_liste_chainee *l_candidat; |
|
|
struct_liste_pile_systeme *l_element_courant; |
struct_liste_pile_systeme *l_element_courant; |
|
|
integer8 i; |
unsigned char *tampon; |
|
|
l_element_courant = (*s_etat_processus).l_base_pile_systeme; |
l_element_courant = (*s_etat_processus).l_base_pile_systeme; |
i = 0; |
i = 0; |
Line 324 trace(struct_processus *s_etat_processus
|
Line 333 trace(struct_processus *s_etat_processus
|
|
|
while(l_element_courant != NULL) |
while(l_element_courant != NULL) |
{ |
{ |
fprintf(flux, "%d : D=", i--); |
fprintf(flux, "%d : (%016X) D=", i--, l_element_courant); |
|
|
fprintf(flux, ((*l_element_courant).creation_variables_statiques |
fprintf(flux, ((*l_element_courant).creation_variables_statiques |
== d_vrai) ? "1" : "0"); |
== d_vrai) ? "1" : "0"); |
Line 344 trace(struct_processus *s_etat_processus
|
Line 353 trace(struct_processus *s_etat_processus
|
|
|
if ((*l_element_courant).retour_definition == 'Y') |
if ((*l_element_courant).retour_definition == 'Y') |
{ |
{ |
fprintf(flux, "RTRN "); |
fprintf(flux, "RTN "); |
|
|
if ((*l_element_courant).origine_routine_evaluation == 'Y') |
if ((*l_element_courant).origine_routine_evaluation == 'Y') |
{ |
{ |
fprintf(flux, "EVL "); |
fprintf(flux, "EVL "); |
|
|
if ((*l_element_courant).adresse_retour != 0) |
|
{ |
|
fprintf(flux, "P=%lu", (*l_element_courant) |
|
.adresse_retour); |
|
} |
|
} |
} |
else |
else |
{ |
{ |
fprintf(flux, "SEQ "); |
fprintf(flux, "SEQ "); |
|
|
if ((*l_element_courant).pointeur_objet_retour != NULL) |
if ((*l_element_courant).adresse_retour != 0) |
{ |
{ |
fprintf(flux, "A=%X", (*l_element_courant) |
fprintf(flux, "P=%016X", (*l_element_courant) |
.pointeur_objet_retour); |
.adresse_retour); |
|
|
|
// Calcul de la routine de départ |
|
|
|
l_variable = (struct_liste_chainee *) |
|
(*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).precedent).liste; |
|
candidat = (*s_etat_processus) |
|
.longueur_definitions_chainees; |
|
l_candidat = NULL; |
|
|
|
// l_variable balaie les variables de niveau 0. |
|
|
|
while(l_variable != NULL) |
|
{ |
|
if ((*(*((struct_variable *) (*l_variable).donnee)) |
|
.objet).type == ADR) |
|
{ |
|
delta = (*l_element_courant).adresse_retour |
|
- (*((unsigned long *) |
|
(*(*((struct_variable *) (*l_variable) |
|
.donnee)).objet).objet)); |
|
|
|
if ((delta > 0) && (delta < candidat)) |
|
{ |
|
candidat = delta; |
|
l_candidat = l_variable; |
|
} |
|
} |
|
|
|
l_variable = (*l_variable).suivant; |
|
} |
|
|
|
if (l_candidat != NULL) |
|
{ |
|
fprintf(flux, "\n Call from %s", |
|
(*((struct_variable *) (*l_candidat).donnee)) |
|
.nom); |
|
} |
|
else |
|
{ |
|
fprintf(flux, "\n Call from RPL/2 initialization"); |
|
} |
|
} |
|
else |
|
{ |
|
fprintf(flux, "RPL/2 initialization"); |
} |
} |
} |
} |
} |
} |
Line 374 trace(struct_processus *s_etat_processus
|
Line 423 trace(struct_processus *s_etat_processus
|
if ((*l_element_courant).origine_routine_evaluation == 'Y') |
if ((*l_element_courant).origine_routine_evaluation == 'Y') |
{ |
{ |
fprintf(flux, "EVL "); |
fprintf(flux, "EVL "); |
|
|
if ((*l_element_courant).adresse_retour != 0) |
|
{ |
|
fprintf(flux, "P=%lu", (*l_element_courant) |
|
.adresse_retour); |
|
} |
|
} |
} |
else |
else |
{ |
{ |
fprintf(flux, "SEQ "); |
fprintf(flux, "SEQ "); |
|
|
if ((*l_element_courant).pointeur_objet_retour != NULL) |
if ((*l_element_courant).pointeur_adresse_retour != NULL) |
{ |
{ |
fprintf(flux, "A=%X", (*l_element_courant) |
fprintf(flux, "A=%016X ", (*l_element_courant) |
.pointeur_objet_retour); |
.pointeur_adresse_retour); |
|
|
|
// Calcul de la routine de départ |
|
|
|
l_variable = (struct_liste_chainee *) |
|
(*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).precedent).liste; |
|
candidat = (*s_etat_processus) |
|
.longueur_definitions_chainees; |
|
l_candidat = NULL; |
|
|
|
// l_variable balaie les variables de niveau 0. |
|
|
|
while(l_variable != NULL) |
|
{ |
|
if ( (*(*l_variable).donnee).objet == |
|
(*l_element_courant).pointeur_adresse_retour) |
|
{ |
|
l_candidat = l_variable; |
|
break; |
|
} |
|
|
|
l_variable = (*l_variable).suivant; |
|
} |
|
|
|
if (l_candidat != NULL) |
|
{ |
|
fprintf(flux, "\n Branch to %s", |
|
(*((struct_variable *) (*l_candidat).donnee)) |
|
.nom); |
|
} |
|
else |
|
{ |
|
fprintf(flux, "\n Branch to evaluation subroutine"); |
|
} |
} |
} |
} |
} |
} |
} |
|
|
fprintf(flux, "\n"); |
fprintf(flux, "\n"); |
|
|
|
if ((*l_element_courant).indice_boucle != NULL) |
|
{ |
|
tampon = formateur(s_etat_processus, 0, |
|
(*l_element_courant).indice_boucle); |
|
fprintf(flux, " Index = %s\n", tampon); |
|
free(tampon); |
|
} |
|
|
|
if ((*l_element_courant).limite_indice_boucle != NULL) |
|
{ |
|
tampon = formateur(s_etat_processus, 0, |
|
(*l_element_courant).limite_indice_boucle); |
|
fprintf(flux, " Limit = %s\n", tampon); |
|
free(tampon); |
|
} |
|
|
|
if ((*l_element_courant).objet_de_test != NULL) |
|
{ |
|
tampon = formateur(s_etat_processus, 0, |
|
(*l_element_courant).objet_de_test); |
|
fprintf(flux, " Test object = %s\n", tampon); |
|
free(tampon); |
|
} |
|
|
|
if ((*l_element_courant).nom_variable != NULL) |
|
{ |
|
fprintf(flux, " Variable name = %s\n", |
|
(*l_element_courant).nom_variable); |
|
} |
|
|
l_element_courant = (*l_element_courant).suivant; |
l_element_courant = (*l_element_courant).suivant; |
} |
} |
|
|