version 1.32, 2011/07/22 07:38:34
|
version 1.84, 2015/11/26 11:44:29
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.1.1 |
RPL/2 (R) version 4.1.24 |
Copyright (C) 1989-2011 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 54 compilation(struct_processus *s_etat_pro
|
Line 54 compilation(struct_processus *s_etat_pro
|
unsigned char ouverture_definition; |
unsigned char ouverture_definition; |
unsigned char position_debut_nom_definition_valide; |
unsigned char position_debut_nom_definition_valide; |
|
|
unsigned long *adresse; |
integer8 *adresse; |
unsigned long i; |
integer8 i; |
unsigned long niveau_definition; |
integer8 niveau_definition; |
unsigned long niveau_definition_registre; |
integer8 niveau_definition_registre; |
unsigned long position_courante; |
integer8 position_courante; |
unsigned long position_debut_nom_definition; |
integer8 position_debut_nom_definition; |
unsigned long position_fin_nom_definition; |
integer8 position_fin_nom_definition; |
unsigned long validation; |
integer8 validation; |
unsigned long validation_registre; |
integer8 validation_registre; |
|
|
(*s_etat_processus).erreur_compilation = d_ec; |
(*s_etat_processus).erreur_compilation = d_ec; |
(*s_etat_processus).erreur_systeme = d_es; |
(*s_etat_processus).erreur_systeme = d_es; |
Line 257 compilation(struct_processus *s_etat_pro
|
Line 257 compilation(struct_processus *s_etat_pro
|
s_variable = (struct_variable *) |
s_variable = (struct_variable *) |
malloc(sizeof(struct_variable)); |
malloc(sizeof(struct_variable)); |
adresse = (*s_objet).objet; |
adresse = (*s_objet).objet; |
definition = (unsigned char *) malloc( |
definition = (unsigned char *) malloc(((size_t) |
(position_fin_nom_definition - |
(position_fin_nom_definition - |
position_debut_nom_definition + 2) * |
position_debut_nom_definition + 2)) * |
sizeof(unsigned char)); |
sizeof(unsigned char)); |
|
|
if ((s_objet == NULL) || (s_variable == NULL) || |
if ((s_objet == NULL) || (s_variable == NULL) || |
Line 281 compilation(struct_processus *s_etat_pro
|
Line 281 compilation(struct_processus *s_etat_pro
|
|
|
while(i <= position_fin_nom_definition) |
while(i <= position_fin_nom_definition) |
{ |
{ |
|
if ((*s_etat_processus).pointeurs_caracteres_variables |
|
[(*s_etat_processus).definitions_chainees[i]] < 0) |
|
{ |
|
free(s_variable); |
|
|
|
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
return(d_erreur); |
|
} |
|
|
*(definition++) = (*s_etat_processus) |
*(definition++) = (*s_etat_processus) |
.definitions_chainees[i++]; |
.definitions_chainees[i++]; |
} |
} |
Line 290 compilation(struct_processus *s_etat_pro
|
Line 299 compilation(struct_processus *s_etat_pro
|
if (recherche_variable(s_etat_processus, (*s_variable).nom) |
if (recherche_variable(s_etat_processus, (*s_variable).nom) |
== d_vrai) |
== d_vrai) |
{ |
{ |
|
free(s_variable); |
|
|
if ((*s_etat_processus).langue == 'F') |
if ((*s_etat_processus).langue == 'F') |
{ |
{ |
printf("+++Attention : Plusieurs définitions de" |
printf("+++Attention : Plusieurs définitions de" |
Line 311 compilation(struct_processus *s_etat_pro
|
Line 322 compilation(struct_processus *s_etat_pro
|
if ((*s_etat_processus).erreur_systeme != d_es) |
if ((*s_etat_processus).erreur_systeme != d_es) |
{ |
{ |
free(s_variable); |
free(s_variable); |
|
|
return(d_erreur); |
return(d_erreur); |
} |
} |
|
|
Line 358 compilation(struct_processus *s_etat_pro
|
Line 368 compilation(struct_processus *s_etat_pro
|
================================================================================ |
================================================================================ |
*/ |
*/ |
|
|
logical1 |
enum t_condition { AN_IF = 1, AN_IFERR, AN_THEN, AN_ELSE, AN_ELSEIF, |
analyse_syntaxique(struct_processus *s_etat_processus) |
AN_END, AN_DO, AN_UNTIL, AN_WHILE, AN_REPEAT, AN_SELECT, |
{ |
AN_CASE, AN_DEFAULT, AN_UP, AN_DOWN, AN_FOR, AN_START, |
enum t_condition { AN_IF = 1, AN_IFERR, AN_THEN, AN_ELSE, AN_ELSEIF, |
AN_NEXT, AN_STEP, AN_CRITICAL, AN_FORALL }; |
AN_END, AN_DO, AN_UNTIL, AN_WHILE, AN_REPEAT, AN_SELECT, |
|
AN_CASE, AN_DEFAULT, AN_UP, AN_DOWN, AN_FOR, AN_START, |
|
AN_NEXT, AN_STEP }; |
|
|
|
unsigned char *instruction; |
|
unsigned char registre; |
|
|
|
typedef struct pile |
|
{ |
|
enum t_condition condition; |
|
struct pile *suivant; |
|
} struct_pile_analyse; |
|
|
|
struct_pile_analyse *l_base_pile; |
typedef struct pile |
struct_pile_analyse *l_nouvelle_base_pile; |
{ |
|
enum t_condition condition; |
|
struct pile *suivant; |
|
} struct_pile_analyse; |
|
|
|
static inline struct_pile_analyse * |
|
empilement_analyse(struct_processus *s_etat_processus, |
|
struct_pile_analyse *ancienne_base, |
|
enum t_condition condition) |
|
{ |
|
struct_pile_analyse *nouvelle_base; |
|
|
inline struct_pile_analyse * |
if ((nouvelle_base = malloc(sizeof(struct_pile_analyse))) == NULL) |
empilement_analyse(struct_pile_analyse *ancienne_base, |
|
enum t_condition condition) |
|
{ |
{ |
struct_pile_analyse *nouvelle_base; |
return(NULL); |
|
} |
|
|
if ((nouvelle_base = malloc(sizeof(struct_pile_analyse))) == NULL) |
(*nouvelle_base).suivant = ancienne_base; |
{ |
(*nouvelle_base).condition = condition; |
return(NULL); |
|
} |
|
|
|
(*nouvelle_base).suivant = ancienne_base; |
return(nouvelle_base); |
(*nouvelle_base).condition = condition; |
} |
|
|
return(nouvelle_base); |
static inline struct_pile_analyse * |
} |
depilement_analyse(struct_processus *s_etat_processus, |
|
struct_pile_analyse *ancienne_base) |
|
{ |
|
struct_pile_analyse *nouvelle_base; |
|
|
inline struct_pile_analyse * |
if (ancienne_base == NULL) |
depilement_analyse(struct_pile_analyse *ancienne_base) |
|
{ |
{ |
struct_pile_analyse *nouvelle_base; |
return(NULL); |
|
} |
|
|
if (ancienne_base == NULL) |
nouvelle_base = (*ancienne_base).suivant; |
{ |
free(ancienne_base); |
return(NULL); |
|
} |
|
|
|
nouvelle_base = (*ancienne_base).suivant; |
return(nouvelle_base); |
free(ancienne_base); |
} |
|
|
return(nouvelle_base); |
static inline logical1 |
|
test_analyse(struct_pile_analyse *l_base_pile, enum t_condition condition) |
|
{ |
|
if (l_base_pile == NULL) |
|
{ |
|
return(d_faux); |
} |
} |
|
|
inline logical1 |
return(((*l_base_pile).condition == condition) ? d_vrai : d_faux); |
test_analyse(struct_pile_analyse *l_base_pile, enum t_condition condition) |
} |
{ |
|
if (l_base_pile == NULL) |
|
{ |
|
return(d_faux); |
|
} |
|
|
|
return(((*l_base_pile).condition == condition) ? d_vrai : d_faux); |
static inline void |
} |
liberation_analyse(struct_processus *s_etat_processus, |
|
struct_pile_analyse *l_base_pile) |
|
{ |
|
struct_pile_analyse *l_nouvelle_base_pile; |
|
|
inline void |
while(l_base_pile != NULL) |
liberation_analyse(struct_pile_analyse *l_base_pile) |
|
{ |
{ |
struct_pile_analyse *l_nouvelle_base_pile; |
l_nouvelle_base_pile = (*l_base_pile).suivant; |
|
free(l_base_pile); |
|
l_base_pile = l_nouvelle_base_pile; |
|
} |
|
|
while(l_base_pile != NULL) |
return; |
{ |
} |
l_nouvelle_base_pile = (*l_base_pile).suivant; |
|
free(l_base_pile); |
|
l_base_pile = l_nouvelle_base_pile; |
|
} |
|
|
|
return; |
logical1 |
} |
analyse_syntaxique(struct_processus *s_etat_processus) |
|
{ |
|
unsigned char *instruction; |
|
unsigned char registre; |
|
|
|
struct_pile_analyse *l_base_pile; |
|
struct_pile_analyse *l_nouvelle_base_pile; |
|
|
l_base_pile = NULL; |
l_base_pile = NULL; |
l_nouvelle_base_pile = NULL; |
l_nouvelle_base_pile = NULL; |
Line 471 analyse_syntaxique(struct_processus *s_e
|
Line 484 analyse_syntaxique(struct_processus *s_e
|
if (recherche_instruction_suivante(s_etat_processus) != |
if (recherche_instruction_suivante(s_etat_processus) != |
d_absence_erreur) |
d_absence_erreur) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = registre; |
(*s_etat_processus).autorisation_empilement_programme = registre; |
return(d_erreur); |
return(d_erreur); |
} |
} |
|
|
if ((instruction = conversion_majuscule( |
if ((instruction = conversion_majuscule(s_etat_processus, |
(*s_etat_processus).instruction_courante)) == NULL) |
(*s_etat_processus).instruction_courante)) == NULL) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = registre; |
(*s_etat_processus).autorisation_empilement_programme = registre; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
Line 489 analyse_syntaxique(struct_processus *s_e
|
Line 502 analyse_syntaxique(struct_processus *s_e
|
|
|
if (strcmp(instruction, "IF") == 0) |
if (strcmp(instruction, "IF") == 0) |
{ |
{ |
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_IF)) |
if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, |
== NULL) |
l_base_pile, AN_IF)) == NULL) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 503 analyse_syntaxique(struct_processus *s_e
|
Line 516 analyse_syntaxique(struct_processus *s_e
|
} |
} |
else if (strcmp(instruction, "IFERR") == 0) |
else if (strcmp(instruction, "IFERR") == 0) |
{ |
{ |
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, |
if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, |
AN_IFERR)) == NULL) |
l_base_pile, AN_IFERR)) == NULL) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
l_base_pile = l_nouvelle_base_pile; |
|
} |
|
else if (strcmp(instruction, "CRITICAL") == 0) |
|
{ |
|
if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, |
|
l_base_pile, AN_CRITICAL)) == NULL) |
|
{ |
|
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 521 analyse_syntaxique(struct_processus *s_e
|
Line 547 analyse_syntaxique(struct_processus *s_e
|
(test_analyse(l_base_pile, AN_CASE) == d_faux) && |
(test_analyse(l_base_pile, AN_CASE) == d_faux) && |
(test_analyse(l_base_pile, AN_IFERR) == d_faux)) |
(test_analyse(l_base_pile, AN_IFERR) == d_faux)) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = |
(*s_etat_processus).autorisation_empilement_programme = |
registre; |
registre; |
Line 537 analyse_syntaxique(struct_processus *s_e
|
Line 563 analyse_syntaxique(struct_processus *s_e
|
{ |
{ |
if (test_analyse(l_base_pile, AN_THEN) == d_faux) |
if (test_analyse(l_base_pile, AN_THEN) == d_faux) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = |
(*s_etat_processus).autorisation_empilement_programme = |
registre; |
registre; |
Line 553 analyse_syntaxique(struct_processus *s_e
|
Line 579 analyse_syntaxique(struct_processus *s_e
|
{ |
{ |
if (test_analyse(l_base_pile, AN_THEN) == d_faux) |
if (test_analyse(l_base_pile, AN_THEN) == d_faux) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = |
(*s_etat_processus).autorisation_empilement_programme = |
registre; |
registre; |
Line 572 analyse_syntaxique(struct_processus *s_e
|
Line 598 analyse_syntaxique(struct_processus *s_e
|
(test_analyse(l_base_pile, AN_DEFAULT) == d_faux) && |
(test_analyse(l_base_pile, AN_DEFAULT) == d_faux) && |
(test_analyse(l_base_pile, AN_SELECT) == d_faux) && |
(test_analyse(l_base_pile, AN_SELECT) == d_faux) && |
(test_analyse(l_base_pile, AN_THEN) == d_faux) && |
(test_analyse(l_base_pile, AN_THEN) == d_faux) && |
|
(test_analyse(l_base_pile, AN_CRITICAL) == d_faux) && |
(test_analyse(l_base_pile, AN_ELSE) == d_faux)) |
(test_analyse(l_base_pile, AN_ELSE) == d_faux)) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = |
(*s_etat_processus).autorisation_empilement_programme = |
registre; |
registre; |
Line 584 analyse_syntaxique(struct_processus *s_e
|
Line 611 analyse_syntaxique(struct_processus *s_e
|
return(d_erreur); |
return(d_erreur); |
} |
} |
|
|
l_base_pile = depilement_analyse(l_base_pile); |
l_base_pile = depilement_analyse(s_etat_processus, l_base_pile); |
} |
} |
else if (strcmp(instruction, "DO") == 0) |
else if (strcmp(instruction, "DO") == 0) |
{ |
{ |
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_DO)) |
if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, |
== NULL) |
l_base_pile, AN_DO)) == NULL) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 603 analyse_syntaxique(struct_processus *s_e
|
Line 630 analyse_syntaxique(struct_processus *s_e
|
{ |
{ |
if (test_analyse(l_base_pile, AN_DO) == d_faux) |
if (test_analyse(l_base_pile, AN_DO) == d_faux) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = |
(*s_etat_processus).autorisation_empilement_programme = |
registre; |
registre; |
Line 617 analyse_syntaxique(struct_processus *s_e
|
Line 644 analyse_syntaxique(struct_processus *s_e
|
} |
} |
else if (strcmp(instruction, "WHILE") == 0) |
else if (strcmp(instruction, "WHILE") == 0) |
{ |
{ |
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, |
if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, |
AN_WHILE)) == NULL) |
l_base_pile, AN_WHILE)) == NULL) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 632 analyse_syntaxique(struct_processus *s_e
|
Line 659 analyse_syntaxique(struct_processus *s_e
|
{ |
{ |
if (test_analyse(l_base_pile, AN_WHILE) == d_faux) |
if (test_analyse(l_base_pile, AN_WHILE) == d_faux) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = |
(*s_etat_processus).autorisation_empilement_programme = |
registre; |
registre; |
Line 646 analyse_syntaxique(struct_processus *s_e
|
Line 673 analyse_syntaxique(struct_processus *s_e
|
} |
} |
else if (strcmp(instruction, "SELECT") == 0) |
else if (strcmp(instruction, "SELECT") == 0) |
{ |
{ |
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, |
if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, |
AN_SELECT)) == NULL) |
l_base_pile, AN_SELECT)) == NULL) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 661 analyse_syntaxique(struct_processus *s_e
|
Line 688 analyse_syntaxique(struct_processus *s_e
|
{ |
{ |
if (test_analyse(l_base_pile, AN_SELECT) == d_faux) |
if (test_analyse(l_base_pile, AN_SELECT) == d_faux) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = |
(*s_etat_processus).autorisation_empilement_programme = |
registre; |
registre; |
Line 671 analyse_syntaxique(struct_processus *s_e
|
Line 698 analyse_syntaxique(struct_processus *s_e
|
return(d_erreur); |
return(d_erreur); |
} |
} |
|
|
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, |
if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, |
AN_CASE)) == NULL) |
l_base_pile, AN_CASE)) == NULL) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 686 analyse_syntaxique(struct_processus *s_e
|
Line 713 analyse_syntaxique(struct_processus *s_e
|
{ |
{ |
if (test_analyse(l_base_pile, AN_SELECT) == d_faux) |
if (test_analyse(l_base_pile, AN_SELECT) == d_faux) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = |
(*s_etat_processus).autorisation_empilement_programme = |
registre; |
registre; |
Line 700 analyse_syntaxique(struct_processus *s_e
|
Line 727 analyse_syntaxique(struct_processus *s_e
|
} |
} |
else if (strcmp(instruction, "<<") == 0) |
else if (strcmp(instruction, "<<") == 0) |
{ |
{ |
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_UP)) |
if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, |
== NULL) |
l_base_pile, AN_UP)) == NULL) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 715 analyse_syntaxique(struct_processus *s_e
|
Line 742 analyse_syntaxique(struct_processus *s_e
|
{ |
{ |
if (test_analyse(l_base_pile, AN_UP) == d_faux) |
if (test_analyse(l_base_pile, AN_UP) == d_faux) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = |
(*s_etat_processus).autorisation_empilement_programme = |
registre; |
registre; |
Line 725 analyse_syntaxique(struct_processus *s_e
|
Line 752 analyse_syntaxique(struct_processus *s_e
|
return(d_erreur); |
return(d_erreur); |
} |
} |
|
|
l_base_pile = depilement_analyse(l_base_pile); |
l_base_pile = depilement_analyse(s_etat_processus, l_base_pile); |
} |
} |
else if (strcmp(instruction, "FOR") == 0) |
else if (strcmp(instruction, "FOR") == 0) |
{ |
{ |
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_FOR)) |
if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, |
== NULL) |
l_base_pile, AN_FOR)) == NULL) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 742 analyse_syntaxique(struct_processus *s_e
|
Line 769 analyse_syntaxique(struct_processus *s_e
|
} |
} |
else if (strcmp(instruction, "START") == 0) |
else if (strcmp(instruction, "START") == 0) |
{ |
{ |
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, |
if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, |
AN_START)) == NULL) |
l_base_pile, AN_START)) == NULL) |
|
{ |
|
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
l_base_pile = l_nouvelle_base_pile; |
|
} |
|
else if (strcmp(instruction, "FORALL") == 0) |
|
{ |
|
if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, |
|
l_base_pile, AN_FORALL)) == NULL) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return(d_erreur); |
return(d_erreur); |
Line 756 analyse_syntaxique(struct_processus *s_e
|
Line 796 analyse_syntaxique(struct_processus *s_e
|
else if (strcmp(instruction, "NEXT") == 0) |
else if (strcmp(instruction, "NEXT") == 0) |
{ |
{ |
if ((test_analyse(l_base_pile, AN_FOR) == d_faux) && |
if ((test_analyse(l_base_pile, AN_FOR) == d_faux) && |
|
(test_analyse(l_base_pile, AN_FORALL) == d_faux) && |
(test_analyse(l_base_pile, AN_START) == d_faux)) |
(test_analyse(l_base_pile, AN_START) == d_faux)) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = |
(*s_etat_processus).autorisation_empilement_programme = |
registre; |
registre; |
Line 768 analyse_syntaxique(struct_processus *s_e
|
Line 809 analyse_syntaxique(struct_processus *s_e
|
return(d_erreur); |
return(d_erreur); |
} |
} |
|
|
l_base_pile = depilement_analyse(l_base_pile); |
l_base_pile = depilement_analyse(s_etat_processus, l_base_pile); |
} |
} |
else if (strcmp(instruction, "STEP") == 0) |
else if (strcmp(instruction, "STEP") == 0) |
{ |
{ |
if ((test_analyse(l_base_pile, AN_FOR) == d_faux) && |
if ((test_analyse(l_base_pile, AN_FOR) == d_faux) && |
(test_analyse(l_base_pile, AN_START) == d_faux)) |
(test_analyse(l_base_pile, AN_START) == d_faux)) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = |
(*s_etat_processus).autorisation_empilement_programme = |
registre; |
registre; |
Line 785 analyse_syntaxique(struct_processus *s_e
|
Line 826 analyse_syntaxique(struct_processus *s_e
|
return(d_erreur); |
return(d_erreur); |
} |
} |
|
|
l_base_pile = depilement_analyse(l_base_pile); |
l_base_pile = depilement_analyse(s_etat_processus, l_base_pile); |
} |
} |
|
|
// Invalidation de l'instruction courante dans le fichier rpl-core |
// Invalidation de l'instruction courante dans le fichier rpl-core |
Line 798 analyse_syntaxique(struct_processus *s_e
|
Line 839 analyse_syntaxique(struct_processus *s_e
|
|
|
if (l_base_pile != NULL) |
if (l_base_pile != NULL) |
{ |
{ |
liberation_analyse(l_base_pile); |
liberation_analyse(s_etat_processus, l_base_pile); |
|
|
(*s_etat_processus).autorisation_empilement_programme = registre; |
(*s_etat_processus).autorisation_empilement_programme = registre; |
(*s_etat_processus).erreur_compilation = d_ec_source_incoherent; |
(*s_etat_processus).erreur_compilation = d_ec_source_incoherent; |
Line 824 analyse_syntaxique(struct_processus *s_e
|
Line 865 analyse_syntaxique(struct_processus *s_e
|
*/ |
*/ |
|
|
void |
void |
swap(void *variable_1, void *variable_2, unsigned long taille) |
swap(void *variable_1, void *variable_2, integer8 taille) |
{ |
{ |
register unsigned char *t_var_1; |
register unsigned char *t_var_1; |
register unsigned char *t_var_2; |
register unsigned char *t_var_2; |
register unsigned char variable_temporaire; |
register unsigned char variable_temporaire; |
|
|
register unsigned long i; |
register integer8 i; |
|
|
t_var_1 = (unsigned char *) variable_1; |
t_var_1 = (unsigned char *) variable_1; |
t_var_2 = (unsigned char *) variable_2; |
t_var_2 = (unsigned char *) variable_2; |
Line 861 swap(void *variable_1, void *variable_2,
|
Line 902 swap(void *variable_1, void *variable_2,
|
logical1 |
logical1 |
recherche_instruction_suivante(struct_processus *s_etat_processus) |
recherche_instruction_suivante(struct_processus *s_etat_processus) |
{ |
{ |
|
return(recherche_instruction_suivante_recursive(s_etat_processus, 0)); |
|
} |
|
|
|
logical1 |
|
recherche_instruction_suivante_recursive(struct_processus *s_etat_processus, |
|
integer8 recursivite) |
|
{ |
|
enum t_type registre_type_en_cours; |
|
|
logical1 drapeau_fin_objet; |
logical1 drapeau_fin_objet; |
logical1 erreur; |
logical1 erreur; |
logical1 erreur_analyse; |
|
logical1 erreur_format; |
int erreur_analyse; |
|
int erreur_format; |
|
|
unsigned char base_binaire; |
unsigned char base_binaire; |
|
unsigned char caractere_fin; |
unsigned char *pointeur_caractere_courant; |
unsigned char *pointeur_caractere_courant; |
unsigned char *pointeur_caractere_destination; |
unsigned char *pointeur_caractere_destination; |
unsigned char *pointeur_debut_instruction; |
unsigned char *pointeur_debut_instruction; |
unsigned char *pointeur_fin_instruction; |
unsigned char *pointeur_fin_instruction; |
|
|
signed long niveau; |
signed long niveau; |
signed long niveau_annexe; |
|
|
|
erreur_analyse = d_ex; |
erreur_analyse = d_ex; |
erreur_format = d_ex; |
erreur_format = d_ex; |
erreur = d_absence_erreur; |
erreur = d_absence_erreur; |
|
|
|
switch((*s_etat_processus).type_en_cours) |
|
{ |
|
case RPN: |
|
{ |
|
caractere_fin = '>'; |
|
break; |
|
} |
|
|
|
case LST: |
|
{ |
|
caractere_fin = '}'; |
|
break; |
|
} |
|
|
|
case TBL: |
|
{ |
|
caractere_fin = ']'; |
|
break; |
|
} |
|
|
|
default: |
|
{ |
|
caractere_fin = d_code_espace; |
|
break; |
|
} |
|
} |
|
|
drapeau_fin_objet = d_faux; |
drapeau_fin_objet = d_faux; |
niveau = 0; |
niveau = 0; |
|
|
Line 917 recherche_instruction_suivante(struct_pr
|
Line 995 recherche_instruction_suivante(struct_pr
|
while(((*pointeur_caractere_courant) != d_code_espace) && |
while(((*pointeur_caractere_courant) != d_code_espace) && |
((*pointeur_caractere_courant) != d_code_fin_chaine) && |
((*pointeur_caractere_courant) != d_code_fin_chaine) && |
(drapeau_fin_objet == d_faux) && |
(drapeau_fin_objet == d_faux) && |
(erreur_analyse == d_ex) && |
(erreur_analyse == d_ex) && (erreur_format == d_ex)) |
(erreur_format == d_ex)) |
|
{ |
{ |
switch(*pointeur_caractere_courant++) |
switch(*pointeur_caractere_courant++) |
{ |
{ |
case ']' : |
case ']' : |
case '}' : |
case '}' : |
|
{ |
|
break; |
|
} |
|
|
case ')' : |
case ')' : |
{ |
{ |
erreur_format = d_ex_syntaxe; |
erreur_format = d_ex_syntaxe; |
Line 1133 recherche_instruction_suivante(struct_pr
|
Line 1214 recherche_instruction_suivante(struct_pr
|
pointeur_caractere_courant++; |
pointeur_caractere_courant++; |
|
|
if (((*pointeur_caractere_courant) != d_code_fin_chaine) && |
if (((*pointeur_caractere_courant) != d_code_fin_chaine) && |
((*pointeur_caractere_courant) != ' ')) |
((*pointeur_caractere_courant) != d_code_espace) && |
|
((*pointeur_caractere_courant) != caractere_fin)) |
{ |
{ |
erreur_analyse = d_ex_syntaxe; |
erreur_analyse = d_ex_syntaxe; |
} |
} |
Line 1257 recherche_instruction_suivante(struct_pr
|
Line 1339 recherche_instruction_suivante(struct_pr
|
} |
} |
|
|
niveau = 1; |
niveau = 1; |
niveau_annexe = 0; |
|
|
|
while((niveau != 0) && ((*pointeur_caractere_courant) != |
while((niveau != 0) && ((*pointeur_caractere_courant) != |
d_code_fin_chaine)) |
d_code_fin_chaine)) |
{ |
{ |
switch(*pointeur_caractere_courant) |
(*s_etat_processus).position_courante = |
{ |
pointeur_caractere_courant |
case '{' : |
- (*s_etat_processus).definitions_chainees; |
{ |
|
if (niveau_annexe == 0) |
|
{ |
|
niveau++; |
|
} |
|
else |
|
{ |
|
erreur_analyse = d_ex_syntaxe; |
|
} |
|
|
|
break; |
|
} |
|
|
|
case '}' : |
|
{ |
|
if (niveau_annexe == 0) |
|
{ |
|
niveau--; |
|
} |
|
else |
|
{ |
|
erreur_analyse = d_ex_syntaxe; |
|
} |
|
|
|
break; |
registre_type_en_cours = (*s_etat_processus).type_en_cours; |
} |
(*s_etat_processus).type_en_cours = LST; |
|
|
case '[' : |
|
{ |
|
niveau_annexe++; |
|
|
|
if (niveau_annexe > 2) |
|
{ |
|
erreur_analyse = d_ex_syntaxe; |
|
} |
|
|
|
break; |
if (recherche_instruction_suivante_recursive( |
} |
s_etat_processus, recursivite + 1) == d_erreur) |
|
{ |
|
(*s_etat_processus).type_en_cours = |
|
registre_type_en_cours; |
|
|
case ']' : |
if ((*s_etat_processus).instruction_courante |
|
!= NULL) |
{ |
{ |
niveau_annexe--; |
free((*s_etat_processus).instruction_courante); |
|
(*s_etat_processus).instruction_courante = NULL; |
if (niveau_annexe < 0) |
|
{ |
|
erreur_analyse = d_ex_syntaxe; |
|
} |
|
|
|
break; |
|
} |
} |
|
|
case '"' : |
return(d_erreur); |
{ |
} |
if (niveau_annexe == 0) |
|
{ |
|
pointeur_caractere_courant++; |
|
|
|
while((*pointeur_caractere_courant != '"') && |
(*s_etat_processus).type_en_cours = registre_type_en_cours; |
((*pointeur_caractere_courant) != |
pointeur_caractere_courant = |
d_code_fin_chaine)) |
(*s_etat_processus).definitions_chainees + |
{ |
(*s_etat_processus).position_courante; |
if (*pointeur_caractere_courant == '\\') |
|
{ |
|
pointeur_caractere_courant++; |
|
|
|
switch(*pointeur_caractere_courant) |
|
{ |
|
case '\\' : |
|
case '"' : |
|
{ |
|
pointeur_caractere_courant++; |
|
break; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
pointeur_caractere_courant++; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
erreur_analyse = d_ex_syntaxe; |
|
} |
|
|
|
break; |
if (strcmp((*s_etat_processus).instruction_courante, "}") |
} |
== 0) |
|
{ |
|
niveau--; |
} |
} |
|
|
pointeur_caractere_courant++; |
free((*s_etat_processus).instruction_courante); |
} |
} |
|
|
if ((niveau != 0) || (niveau_annexe != 0)) |
if (niveau != 0) |
{ |
{ |
erreur_analyse = d_ex_syntaxe; |
erreur_analyse = d_ex_syntaxe; |
} |
} |
Line 1449 recherche_instruction_suivante(struct_pr
|
Line 1471 recherche_instruction_suivante(struct_pr
|
{ |
{ |
if (((*s_etat_processus).autorisation_empilement_programme |
if (((*s_etat_processus).autorisation_empilement_programme |
== 'Y') && ((*pointeur_caractere_courant) == '<')) |
== 'Y') && ((*pointeur_caractere_courant) == '<')) |
{ |
{ // Cas << >> |
if (pointeur_debut_instruction != |
if (pointeur_debut_instruction != |
(pointeur_caractere_courant - 1)) |
(pointeur_caractere_courant - 1)) |
{ |
{ |
erreur_format = d_ex_syntaxe; |
erreur_format = d_ex_syntaxe; |
} |
} |
|
|
niveau = 1; |
pointeur_caractere_courant++; |
|
drapeau_fin_objet = d_faux; |
|
|
while((niveau != 0) && ((*pointeur_caractere_courant) != |
while(((*pointeur_caractere_courant) != d_code_fin_chaine) |
d_code_fin_chaine)) |
&& (erreur_format == d_absence_erreur)) |
{ |
{ |
if (((*pointeur_caractere_courant) == '<') && |
while((*pointeur_caractere_courant) == d_code_espace) |
((*(pointeur_caractere_courant + 1)) == '<')) |
|
{ |
{ |
niveau++; |
|
pointeur_caractere_courant++; |
pointeur_caractere_courant++; |
} |
} |
else if (((*pointeur_caractere_courant) == '>') && |
|
((*(pointeur_caractere_courant + 1)) == '>')) |
if (((*pointeur_caractere_courant) == '>') && |
|
((*(pointeur_caractere_courant - 1)) == |
|
d_code_espace)) |
{ |
{ |
niveau--; |
|
pointeur_caractere_courant++; |
pointeur_caractere_courant++; |
|
|
|
if ((*pointeur_caractere_courant) == '>') |
|
{ // Cas de '>>' |
|
drapeau_fin_objet = d_vrai; |
|
pointeur_caractere_courant++; |
|
break; |
|
} |
|
else if ((*pointeur_caractere_courant) == '=') |
|
{ // Cas de '>=' |
|
pointeur_caractere_courant++; |
|
} |
|
else if ((*pointeur_caractere_courant) != |
|
d_code_espace) |
|
{ // Tous les cas différents de '>' |
|
erreur_analyse = d_ex_syntaxe; |
|
break; |
|
} |
|
|
|
pointeur_caractere_courant--; |
} |
} |
else if ((*pointeur_caractere_courant) == '"') |
|
|
if ((erreur_format == d_absence_erreur) && |
|
(drapeau_fin_objet == d_faux)) |
{ |
{ |
pointeur_caractere_courant++; |
(*s_etat_processus).position_courante = |
|
pointeur_caractere_courant |
|
- (*s_etat_processus).definitions_chainees; |
|
|
while((*pointeur_caractere_courant != '"') && |
registre_type_en_cours = (*s_etat_processus) |
((*pointeur_caractere_courant) != |
.type_en_cours; |
d_code_fin_chaine)) |
(*s_etat_processus).type_en_cours = RPN; |
|
|
|
if ((erreur = |
|
recherche_instruction_suivante_recursive( |
|
s_etat_processus, recursivite + 1)) |
|
!= d_absence_erreur) |
{ |
{ |
if (*pointeur_caractere_courant == '\\') |
(*s_etat_processus).type_en_cours = |
{ |
registre_type_en_cours; |
pointeur_caractere_courant++; |
|
|
|
switch(*pointeur_caractere_courant) |
if ((*s_etat_processus).instruction_courante |
{ |
!= NULL) |
case '\\' : |
|
case '"' : |
|
{ |
|
pointeur_caractere_courant++; |
|
break; |
|
} |
|
} |
|
} |
|
else |
|
{ |
{ |
pointeur_caractere_courant++; |
free((*s_etat_processus) |
|
.instruction_courante); |
|
(*s_etat_processus).instruction_courante |
|
= NULL; |
} |
} |
|
|
|
return(d_erreur); |
} |
} |
} |
|
|
|
pointeur_caractere_courant++; |
(*s_etat_processus).type_en_cours = |
|
registre_type_en_cours; |
|
pointeur_caractere_courant = (*s_etat_processus) |
|
.definitions_chainees + (*s_etat_processus) |
|
.position_courante; |
|
|
|
free((*s_etat_processus).instruction_courante); |
|
} |
} |
} |
|
|
if (niveau != 0) |
if (drapeau_fin_objet == d_faux) |
{ |
{ |
erreur_analyse = d_ex_syntaxe; |
erreur_analyse = d_ex_syntaxe; |
|
drapeau_fin_objet = d_vrai; |
} |
} |
|
|
drapeau_fin_objet = d_vrai; |
|
} |
} |
else if ((*pointeur_caractere_courant) == '[') |
else if ((*pointeur_caractere_courant) == '[') |
{ |
{ // Cas <[ ]> |
if (pointeur_debut_instruction != |
if (pointeur_debut_instruction != |
(pointeur_caractere_courant - 1)) |
(pointeur_caractere_courant - 1)) |
{ |
{ |
Line 1553 recherche_instruction_suivante(struct_pr
|
Line 1603 recherche_instruction_suivante(struct_pr
|
pointeur_caractere_courant |
pointeur_caractere_courant |
- (*s_etat_processus).definitions_chainees; |
- (*s_etat_processus).definitions_chainees; |
|
|
if ((erreur = recherche_instruction_suivante( |
registre_type_en_cours = (*s_etat_processus) |
s_etat_processus)) != d_absence_erreur) |
.type_en_cours; |
|
(*s_etat_processus).type_en_cours = TBL; |
|
|
|
if ((erreur = |
|
recherche_instruction_suivante_recursive( |
|
s_etat_processus, recursivite + 1)) |
|
!= d_absence_erreur) |
{ |
{ |
|
(*s_etat_processus).type_en_cours = |
|
registre_type_en_cours; |
|
|
if ((*s_etat_processus).instruction_courante |
if ((*s_etat_processus).instruction_courante |
!= NULL) |
!= NULL) |
{ |
{ |
free((*s_etat_processus) |
free((*s_etat_processus) |
.instruction_courante); |
.instruction_courante); |
|
(*s_etat_processus).instruction_courante |
|
= NULL; |
} |
} |
|
|
return(d_erreur); |
return(d_erreur); |
} |
} |
|
|
|
(*s_etat_processus).type_en_cours = |
|
registre_type_en_cours; |
pointeur_caractere_courant = (*s_etat_processus) |
pointeur_caractere_courant = (*s_etat_processus) |
.definitions_chainees + (*s_etat_processus) |
.definitions_chainees + (*s_etat_processus) |
.position_courante; |
.position_courante; |
Line 1584 recherche_instruction_suivante(struct_pr
|
Line 1647 recherche_instruction_suivante(struct_pr
|
break; |
break; |
} |
} |
} |
} |
|
|
|
if ((*(pointeur_caractere_courant - 1)) == caractere_fin) |
|
{ |
|
// Cas des objets composites (LST, RPN, TBL) |
|
break; |
|
} |
|
else if ((*pointeur_caractere_courant) == caractere_fin) |
|
{ |
|
// Condition pour traiter les cas 123} |
|
break; |
|
} |
} |
} |
|
|
pointeur_fin_instruction = pointeur_caractere_courant; |
pointeur_fin_instruction = pointeur_caractere_courant; |
|
|
|
if (recursivite == 0) |
|
{ |
|
// Si la variable récursivité est nulle, il faut que le caractère |
|
// suivant l'objet soit un espace ou une fin de chaîne. Si ce n'est pas |
|
// le cas, il faut retourner une erreur car les objets de type |
|
// [[ 1 4 ]]3 doivent être invalides. |
|
|
|
switch((*pointeur_fin_instruction)) |
|
{ |
|
case d_code_fin_chaine: |
|
case d_code_espace: |
|
{ |
|
break; |
|
} |
|
|
|
default: |
|
{ |
|
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
// return(d_erreur); |
|
} |
|
} |
|
} |
|
|
(*s_etat_processus).instruction_courante = (unsigned char *) |
(*s_etat_processus).instruction_courante = (unsigned char *) |
malloc(((pointeur_fin_instruction - pointeur_debut_instruction) |
malloc((((size_t) (pointeur_fin_instruction |
+ 1) * sizeof(unsigned char)); |
- pointeur_debut_instruction)) + 1) * sizeof(unsigned char)); |
|
|
if ((*s_etat_processus).instruction_courante == NULL) |
if ((*s_etat_processus).instruction_courante == NULL) |
{ |
{ |
Line 1613 recherche_instruction_suivante(struct_pr
|
Line 1710 recherche_instruction_suivante(struct_pr
|
erreur = ((erreur_analyse == d_ex) && (erreur_format == d_ex)) |
erreur = ((erreur_analyse == d_ex) && (erreur_format == d_ex)) |
? d_absence_erreur : d_erreur; |
? d_absence_erreur : d_erreur; |
(*s_etat_processus).erreur_execution = erreur_analyse; |
(*s_etat_processus).erreur_execution = erreur_analyse; |
|
|
|
if ((*s_etat_processus).erreur_execution == d_ex) |
|
{ |
|
(*s_etat_processus).erreur_execution = erreur_format; |
|
} |
} |
} |
else |
else |
{ |
{ |
Line 1628 recherche_instruction_suivante(struct_pr
|
Line 1730 recherche_instruction_suivante(struct_pr
|
|
|
/* |
/* |
================================================================================ |
================================================================================ |
Routine mettant la chaine d'entrée en majuscule |
Routine mettant la chaîne d'entrée en majuscule |
================================================================================ |
================================================================================ |
Entrée : pointeur sur une chaine en minuscules. |
Entrée : pointeur sur une chaîne en minuscules. |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Sortie : pointeur sur la chaine en majuscules. Si le pointeur retourné |
Sortie : pointeur sur la chaîne en majuscules. Si le pointeur retourné |
est nul, il s'est produit une erreur. L'allocation est faite dans la |
est nul, il s'est produit une erreur. L'allocation est faite dans la |
routine. |
routine. |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Line 1641 recherche_instruction_suivante(struct_pr
|
Line 1743 recherche_instruction_suivante(struct_pr
|
*/ |
*/ |
|
|
unsigned char * |
unsigned char * |
conversion_majuscule(unsigned char *chaine) |
conversion_majuscule(struct_processus *s_etat_processus, unsigned char *chaine) |
{ |
{ |
register unsigned char *caractere_courant; |
register unsigned char *caractere_courant; |
register unsigned char *caractere_courant_converti; |
register unsigned char *caractere_courant_converti; |
register unsigned char *chaine_convertie; |
register unsigned char *chaine_convertie; |
|
|
unsigned long longueur_chaine_plus_terminaison; |
integer8 longueur_chaine_plus_terminaison; |
|
|
longueur_chaine_plus_terminaison = 0; |
longueur_chaine_plus_terminaison = 0; |
caractere_courant = chaine; |
caractere_courant = chaine; |
Line 1660 conversion_majuscule(unsigned char *chai
|
Line 1762 conversion_majuscule(unsigned char *chai
|
|
|
caractere_courant = chaine; |
caractere_courant = chaine; |
caractere_courant_converti = chaine_convertie = (unsigned char *) malloc( |
caractere_courant_converti = chaine_convertie = (unsigned char *) malloc( |
(longueur_chaine_plus_terminaison + 1) * sizeof(unsigned char)); |
((size_t) (longueur_chaine_plus_terminaison + 1)) |
|
* sizeof(unsigned char)); |
|
|
if (chaine_convertie != NULL) |
if (chaine_convertie != NULL) |
{ |
{ |
Line 1688 conversion_majuscule(unsigned char *chai
|
Line 1791 conversion_majuscule(unsigned char *chai
|
|
|
void |
void |
conversion_majuscule_limitee(unsigned char *chaine_entree, |
conversion_majuscule_limitee(unsigned char *chaine_entree, |
unsigned char *chaine_sortie, unsigned long longueur) |
unsigned char *chaine_sortie, integer8 longueur) |
{ |
{ |
unsigned long i; |
integer8 i; |
|
|
for(i = 0; i < longueur; i++) |
for(i = 0; i < longueur; i++) |
{ |
{ |
Line 1734 initialisation_drapeaux(struct_processus
|
Line 1837 initialisation_drapeaux(struct_processus
|
{ |
{ |
unsigned long i; |
unsigned long i; |
|
|
for(i = 0; i < 31; cf(s_etat_processus, i++)); |
for(i = 0; i < 31; cf(s_etat_processus, (unsigned char) i++)); |
|
|
if ((*s_etat_processus).lancement_interactif == d_vrai) |
if ((*s_etat_processus).lancement_interactif == d_vrai) |
{ |
{ |