--- rpl/src/compilation.c 2010/08/26 19:07:35 1.19 +++ rpl/src/compilation.c 2016/09/27 15:29:32 1.86 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.19 - Copyright (C) 1989-2010 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.26 + Copyright (C) 1989-2016 Dr. BERTRAND Joël This file is part of RPL/2. @@ -54,15 +54,15 @@ compilation(struct_processus *s_etat_pro unsigned char ouverture_definition; unsigned char position_debut_nom_definition_valide; - unsigned long *adresse; - unsigned long i; - unsigned long niveau_definition; - unsigned long niveau_definition_registre; - unsigned long position_courante; - unsigned long position_debut_nom_definition; - unsigned long position_fin_nom_definition; - unsigned long validation; - unsigned long validation_registre; + integer8 *adresse; + integer8 i; + integer8 niveau_definition; + integer8 niveau_definition_registre; + integer8 position_courante; + integer8 position_debut_nom_definition; + integer8 position_fin_nom_definition; + integer8 validation; + integer8 validation_registre; (*s_etat_processus).erreur_compilation = d_ec; (*s_etat_processus).erreur_systeme = d_es; @@ -257,9 +257,9 @@ compilation(struct_processus *s_etat_pro s_variable = (struct_variable *) malloc(sizeof(struct_variable)); adresse = (*s_objet).objet; - definition = (unsigned char *) malloc( + definition = (unsigned char *) malloc(((size_t) (position_fin_nom_definition - - position_debut_nom_definition + 2) * + position_debut_nom_definition + 2)) * sizeof(unsigned char)); if ((s_objet == NULL) || (s_variable == NULL) || @@ -281,6 +281,15 @@ compilation(struct_processus *s_etat_pro 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) .definitions_chainees[i++]; } @@ -290,6 +299,8 @@ compilation(struct_processus *s_etat_pro if (recherche_variable(s_etat_processus, (*s_variable).nom) == d_vrai) { + free(s_variable); + if ((*s_etat_processus).langue == 'F') { printf("+++Attention : Plusieurs définitions de" @@ -311,7 +322,6 @@ compilation(struct_processus *s_etat_pro if ((*s_etat_processus).erreur_systeme != d_es) { free(s_variable); - return(d_erreur); } @@ -358,84 +368,87 @@ compilation(struct_processus *s_etat_pro ================================================================================ */ -logical1 -analyse_syntaxique(struct_processus *s_etat_processus) -{ - enum t_condition { AN_IF = 1, AN_IFERR, AN_THEN, AN_ELSE, AN_ELSEIF, - 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; +enum t_condition { AN_IF = 1, AN_IFERR, AN_THEN, AN_ELSE, AN_ELSEIF, + 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, AN_CRITICAL, AN_FORALL }; - struct_pile_analyse *l_base_pile; - struct_pile_analyse *l_nouvelle_base_pile; +typedef struct 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 * - empilement_analyse(struct_pile_analyse *ancienne_base, - enum t_condition condition) + if ((nouvelle_base = malloc(sizeof(struct_pile_analyse))) == NULL) { - struct_pile_analyse *nouvelle_base; + return(NULL); + } - if ((nouvelle_base = malloc(sizeof(struct_pile_analyse))) == NULL) - { - return(NULL); - } + (*nouvelle_base).suivant = ancienne_base; + (*nouvelle_base).condition = condition; - (*nouvelle_base).suivant = ancienne_base; - (*nouvelle_base).condition = condition; + return(nouvelle_base); +} - 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 * - depilement_analyse(struct_pile_analyse *ancienne_base) + if (ancienne_base == NULL) { - struct_pile_analyse *nouvelle_base; + return(NULL); + } - if (ancienne_base == NULL) - { - return(NULL); - } + nouvelle_base = (*ancienne_base).suivant; + free(ancienne_base); - nouvelle_base = (*ancienne_base).suivant; - free(ancienne_base); + return(nouvelle_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 - 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); +} - 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 - liberation_analyse(struct_pile_analyse *l_base_pile) + while(l_base_pile != NULL) { - 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) - { - l_nouvelle_base_pile = (*l_base_pile).suivant; - free(l_base_pile); - l_base_pile = l_nouvelle_base_pile; - } + return; +} - 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_nouvelle_base_pile = NULL; @@ -471,16 +484,16 @@ analyse_syntaxique(struct_processus *s_e if (recherche_instruction_suivante(s_etat_processus) != d_absence_erreur) { - liberation_analyse(l_base_pile); + liberation_analyse(s_etat_processus, l_base_pile); (*s_etat_processus).autorisation_empilement_programme = registre; return(d_erreur); } - if ((instruction = conversion_majuscule( + if ((instruction = conversion_majuscule(s_etat_processus, (*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).erreur_systeme = d_es_allocation_memoire; @@ -489,10 +502,10 @@ analyse_syntaxique(struct_processus *s_e if (strcmp(instruction, "IF") == 0) { - if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_IF)) - == NULL) + if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, + 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; return(d_erreur); @@ -503,10 +516,23 @@ analyse_syntaxique(struct_processus *s_e } else if (strcmp(instruction, "IFERR") == 0) { - if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, - AN_IFERR)) == NULL) + if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, + 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; return(d_erreur); @@ -521,7 +547,7 @@ analyse_syntaxique(struct_processus *s_e (test_analyse(l_base_pile, AN_CASE) == 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 = registre; @@ -537,7 +563,7 @@ analyse_syntaxique(struct_processus *s_e { 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 = registre; @@ -553,7 +579,7 @@ analyse_syntaxique(struct_processus *s_e { 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 = registre; @@ -572,9 +598,10 @@ analyse_syntaxique(struct_processus *s_e (test_analyse(l_base_pile, AN_DEFAULT) == 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_CRITICAL) == 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 = registre; @@ -584,14 +611,14 @@ analyse_syntaxique(struct_processus *s_e 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) { - if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_DO)) - == NULL) + if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, + 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; return(d_erreur); @@ -603,7 +630,7 @@ analyse_syntaxique(struct_processus *s_e { 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 = registre; @@ -617,10 +644,10 @@ analyse_syntaxique(struct_processus *s_e } else if (strcmp(instruction, "WHILE") == 0) { - if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, - AN_WHILE)) == NULL) + if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, + 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; return(d_erreur); @@ -632,7 +659,7 @@ analyse_syntaxique(struct_processus *s_e { 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 = registre; @@ -646,10 +673,10 @@ analyse_syntaxique(struct_processus *s_e } else if (strcmp(instruction, "SELECT") == 0) { - if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, - AN_SELECT)) == NULL) + if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, + 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; return(d_erreur); @@ -661,7 +688,7 @@ analyse_syntaxique(struct_processus *s_e { 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 = registre; @@ -671,10 +698,10 @@ analyse_syntaxique(struct_processus *s_e return(d_erreur); } - if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, - AN_CASE)) == NULL) + if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, + 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; return(d_erreur); @@ -686,7 +713,7 @@ analyse_syntaxique(struct_processus *s_e { 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 = registre; @@ -700,10 +727,10 @@ analyse_syntaxique(struct_processus *s_e } else if (strcmp(instruction, "<<") == 0) { - if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_UP)) - == NULL) + if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, + 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; return(d_erreur); @@ -715,7 +742,7 @@ analyse_syntaxique(struct_processus *s_e { 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 = registre; @@ -725,14 +752,14 @@ analyse_syntaxique(struct_processus *s_e 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) { - if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_FOR)) - == NULL) + if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, + 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; return(d_erreur); @@ -742,10 +769,23 @@ analyse_syntaxique(struct_processus *s_e } else if (strcmp(instruction, "START") == 0) { - if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, - AN_START)) == NULL) + if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus, + 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; return(d_erreur); @@ -756,9 +796,10 @@ analyse_syntaxique(struct_processus *s_e else if (strcmp(instruction, "NEXT") == 0) { 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)) { - liberation_analyse(l_base_pile); + liberation_analyse(s_etat_processus, l_base_pile); (*s_etat_processus).autorisation_empilement_programme = registre; @@ -768,14 +809,14 @@ analyse_syntaxique(struct_processus *s_e 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) { if ((test_analyse(l_base_pile, AN_FOR) == 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 = registre; @@ -785,7 +826,7 @@ analyse_syntaxique(struct_processus *s_e 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 @@ -798,7 +839,7 @@ analyse_syntaxique(struct_processus *s_e 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).erreur_compilation = d_ec_source_incoherent; @@ -824,13 +865,13 @@ analyse_syntaxique(struct_processus *s_e */ 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_2; register unsigned char variable_temporaire; - register unsigned long i; + register integer8 i; t_var_1 = (unsigned char *) variable_1; t_var_2 = (unsigned char *) variable_2; @@ -861,24 +902,61 @@ swap(void *variable_1, void *variable_2, logical1 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 erreur; - logical1 erreur_analyse; - logical1 erreur_format; + + int erreur_analyse; + int erreur_format; unsigned char base_binaire; + unsigned char caractere_fin; unsigned char *pointeur_caractere_courant; unsigned char *pointeur_caractere_destination; unsigned char *pointeur_debut_instruction; unsigned char *pointeur_fin_instruction; signed long niveau; - signed long niveau_annexe; erreur_analyse = d_ex; erreur_format = d_ex; 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; niveau = 0; @@ -917,13 +995,16 @@ recherche_instruction_suivante(struct_pr while(((*pointeur_caractere_courant) != d_code_espace) && ((*pointeur_caractere_courant) != d_code_fin_chaine) && (drapeau_fin_objet == d_faux) && - (erreur_analyse == d_ex) && - (erreur_format == d_ex)) + (erreur_analyse == d_ex) && (erreur_format == d_ex)) { switch(*pointeur_caractere_courant++) { case ']' : case '}' : + { + break; + } + case ')' : { erreur_format = d_ex_syntaxe; @@ -1133,7 +1214,8 @@ recherche_instruction_suivante(struct_pr pointeur_caractere_courant++; 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; } @@ -1257,108 +1339,48 @@ recherche_instruction_suivante(struct_pr } niveau = 1; - niveau_annexe = 0; while((niveau != 0) && ((*pointeur_caractere_courant) != d_code_fin_chaine)) { - switch(*pointeur_caractere_courant) - { - case '{' : - { - if (niveau_annexe == 0) - { - niveau++; - } - else - { - erreur_analyse = d_ex_syntaxe; - } - - break; - } - - case '}' : - { - if (niveau_annexe == 0) - { - niveau--; - } - else - { - erreur_analyse = d_ex_syntaxe; - } + (*s_etat_processus).position_courante = + pointeur_caractere_courant + - (*s_etat_processus).definitions_chainees; - break; - } - - case '[' : - { - niveau_annexe++; - - if (niveau_annexe > 2) - { - erreur_analyse = d_ex_syntaxe; - } + registre_type_en_cours = (*s_etat_processus).type_en_cours; + (*s_etat_processus).type_en_cours = LST; - 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--; - - if (niveau_annexe < 0) - { - erreur_analyse = d_ex_syntaxe; - } - - break; + free((*s_etat_processus).instruction_courante); + (*s_etat_processus).instruction_courante = NULL; } - case '"' : - { - if (niveau_annexe == 0) - { - pointeur_caractere_courant++; + return(d_erreur); + } - while((*pointeur_caractere_courant != '"') && - ((*pointeur_caractere_courant) != - d_code_fin_chaine)) - { - 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; - } + (*s_etat_processus).type_en_cours = registre_type_en_cours; + pointeur_caractere_courant = + (*s_etat_processus).definitions_chainees + + (*s_etat_processus).position_courante; - 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; } @@ -1449,71 +1471,99 @@ recherche_instruction_suivante(struct_pr { if (((*s_etat_processus).autorisation_empilement_programme == 'Y') && ((*pointeur_caractere_courant) == '<')) - { + { // Cas << >> if (pointeur_debut_instruction != (pointeur_caractere_courant - 1)) { erreur_format = d_ex_syntaxe; } - niveau = 1; + pointeur_caractere_courant++; + drapeau_fin_objet = d_faux; - while((niveau != 0) && ((*pointeur_caractere_courant) != - d_code_fin_chaine)) + while(((*pointeur_caractere_courant) != d_code_fin_chaine) + && (erreur_format == d_absence_erreur)) { - if (((*pointeur_caractere_courant) == '<') && - ((*(pointeur_caractere_courant + 1)) == '<')) + while((*pointeur_caractere_courant) == d_code_espace) { - niveau++; 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++; + + 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 != '"') && - ((*pointeur_caractere_courant) != - d_code_fin_chaine)) + registre_type_en_cours = (*s_etat_processus) + .type_en_cours; + (*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 == '\\') - { - pointeur_caractere_courant++; + (*s_etat_processus).type_en_cours = + registre_type_en_cours; - switch(*pointeur_caractere_courant) - { - case '\\' : - case '"' : - { - pointeur_caractere_courant++; - break; - } - } - } - else + if ((*s_etat_processus).instruction_courante + != NULL) { - 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; + drapeau_fin_objet = d_vrai; } - - drapeau_fin_objet = d_vrai; } else if ((*pointeur_caractere_courant) == '[') - { + { // Cas <[ ]> if (pointeur_debut_instruction != (pointeur_caractere_courant - 1)) { @@ -1553,19 +1603,32 @@ recherche_instruction_suivante(struct_pr pointeur_caractere_courant - (*s_etat_processus).definitions_chainees; - if ((erreur = recherche_instruction_suivante( - s_etat_processus)) != d_absence_erreur) + registre_type_en_cours = (*s_etat_processus) + .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 != NULL) { free((*s_etat_processus) .instruction_courante); + (*s_etat_processus).instruction_courante + = NULL; } return(d_erreur); } + (*s_etat_processus).type_en_cours = + registre_type_en_cours; pointeur_caractere_courant = (*s_etat_processus) .definitions_chainees + (*s_etat_processus) .position_courante; @@ -1584,13 +1647,47 @@ recherche_instruction_suivante(struct_pr 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; + 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 *) - malloc(((pointeur_fin_instruction - pointeur_debut_instruction) - + 1) * sizeof(unsigned char)); + malloc((((size_t) (pointeur_fin_instruction + - pointeur_debut_instruction)) + 1) * sizeof(unsigned char)); if ((*s_etat_processus).instruction_courante == NULL) { @@ -1613,6 +1710,11 @@ recherche_instruction_suivante(struct_pr erreur = ((erreur_analyse == d_ex) && (erreur_format == d_ex)) ? d_absence_erreur : d_erreur; (*s_etat_processus).erreur_execution = erreur_analyse; + + if ((*s_etat_processus).erreur_execution == d_ex) + { + (*s_etat_processus).erreur_execution = erreur_format; + } } else { @@ -1628,11 +1730,11 @@ 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 routine. -------------------------------------------------------------------------------- @@ -1641,13 +1743,13 @@ recherche_instruction_suivante(struct_pr */ 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_converti; register unsigned char *chaine_convertie; - unsigned long longueur_chaine_plus_terminaison; + integer8 longueur_chaine_plus_terminaison; longueur_chaine_plus_terminaison = 0; caractere_courant = chaine; @@ -1660,7 +1762,8 @@ conversion_majuscule(unsigned char *chai caractere_courant = chaine; 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) { @@ -1688,9 +1791,9 @@ conversion_majuscule(unsigned char *chai void 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++) { @@ -1734,7 +1837,7 @@ initialisation_drapeaux(struct_processus { 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) { @@ -1749,9 +1852,9 @@ initialisation_drapeaux(struct_processus cf(s_etat_processus, 32); /* Impression automatique */ cf(s_etat_processus, 33); /* CR automatique (disp) */ - cf(s_etat_processus, 34); /* Valeur principale (intervalle de déf.) */ - sf(s_etat_processus, 35); /* Evaluation symbolique des constantes */ - sf(s_etat_processus, 36); /* Evaluation symbolique des fonctions */ + sf(s_etat_processus, 34); /* Évaluation des caractères de contrôle */ + sf(s_etat_processus, 35); /* Évaluation symbolique des constantes */ + sf(s_etat_processus, 36); /* Évaluation symbolique des fonctions */ sf(s_etat_processus, 37); /* Taille de mot pour les entiers binaires */ sf(s_etat_processus, 38); /* Taille de mot pour les entiers binaires */ sf(s_etat_processus, 39); /* Taille de mot pour les entiers binaires */