--- rpl/src/formateur_flux.c 2011/06/27 09:04:55 1.9 +++ rpl/src/formateur_flux.c 2012/06/21 16:07:25 1.25 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.0 - Copyright (C) 1989-2011 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.9 + Copyright (C) 1989-2012 Dr. BERTRAND Joël This file is part of RPL/2. @@ -241,4 +241,625 @@ formateur_flux(struct_processus *s_etat_ return(chaine); } + +/* +================================================================================ + Routine de d'analyse d'un flux +================================================================================ + Entrées : structure sur l'état du processus et objet à afficher +-------------------------------------------------------------------------------- + Sorties : chaine de caractères +-------------------------------------------------------------------------------- + Effets de bord : néant +================================================================================ +*/ + +unsigned char * +analyse_flux(struct_processus *s_etat_processus, unsigned char *donnees, + long longueur) +{ + long longueur_courante; + long offset; + + unsigned char *chaine; + unsigned char hexadecimal[3]; + unsigned char *ptr_ecriture; + unsigned char *ptr_lecture; + + if ((chaine = malloc((longueur_courante = longueur + 1) * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return(NULL); + } + + ptr_lecture = donnees; + ptr_ecriture = chaine; + + while(longueur > 0) + { + // Début de la séquence d'échappement + + switch((*ptr_lecture)) + { + case '"': + case '\b': + case '\n': + case '\t': + { + offset = ptr_ecriture - chaine; + + if ((chaine = realloc(chaine, (++longueur_courante) + * sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return(NULL); + } + + ptr_ecriture = chaine + offset; + *ptr_ecriture++ = '\\'; + + switch((*ptr_lecture++)) + { + case '"': + { + *ptr_ecriture++ = '"'; + break; + } + + case '\b': + { + *ptr_ecriture++ = 'b'; + break; + } + + case '\n': + { + *ptr_ecriture++ = 'n'; + break; + } + + case '\t': + { + *ptr_ecriture++ = 't'; + break; + } + } + + break; + } + + case ' ': + { + *ptr_ecriture++ = *ptr_lecture++; + break; + } + + default: + { + if (isgraph((*ptr_lecture))) + { + *ptr_ecriture++ = *ptr_lecture++; + } + else + { + offset = ptr_ecriture - chaine; + + if ((chaine = realloc(chaine, (longueur_courante = + longueur_courante + 3) * sizeof(unsigned char))) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return(NULL); + } + + ptr_ecriture = chaine + offset; + *ptr_ecriture++ = '\\'; + *ptr_ecriture++ = 'x'; + + sprintf(hexadecimal, "%02X", *ptr_lecture++); + + *ptr_ecriture++ = hexadecimal[0]; + *ptr_ecriture++ = hexadecimal[1]; + } + + break; + } + } + + longueur--; + } + + (*ptr_ecriture) = d_code_fin_chaine; + + return(chaine); +} + + +/* +================================================================================ + Routine testant la validité d'une chaîne de caractères +================================================================================ + Entrées : structure sur l'état du processus et chaîne courante +-------------------------------------------------------------------------------- + Sorties : pointeur sur le caractère suivant +-------------------------------------------------------------------------------- + Effets de bord : néant +================================================================================ +*/ + +logical1 +validation_chaine(unsigned char *chaine) +{ + if (chaine == NULL) + { + return(d_faux); + } + + while((*chaine) != d_code_fin_chaine) + { + if ((*chaine) == '\\') + { + if ((*(chaine + 1)) == '"') + { + chaine += 2; + } + else if ((*(chaine + 1)) == 'b') + { + chaine += 2; + } + else if ((*(chaine + 1)) == 'n') + { + chaine += 2; + } + else if ((*(chaine + 1)) == 't') + { + chaine += 2; + } + else if ((*(chaine + 1)) == 'x') + { + if ((*(chaine + 2)) != d_code_fin_chaine) + { + if ((*(chaine + 3)) != d_code_fin_chaine) + { + switch(*(chaine + 2)) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + break; + + default: + return(d_faux); + break; + } + + switch(*(chaine + 3)) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + break; + + default: + return(d_faux); + break; + } + } + else + { + return(d_faux); + } + } + else + { + return(d_faux); + } + + chaine += 4; + } + else if ((*(chaine + 1)) == '\\') + { + chaine += 2; + } + else + { + // Tous les autres cas sont invalides + return(d_faux); + } + } + else + { + chaine++; + } + } + + return(d_vrai); +} + + +/* +================================================================================ + Routine permettant de trouver le caractère suivant dans une chaîne +================================================================================ + Entrées : structure sur l'état du processus et chaîne courante +-------------------------------------------------------------------------------- + Sorties : pointeur sur le caractère suivant +-------------------------------------------------------------------------------- + Effets de bord : néant +================================================================================ +*/ + +static inline unsigned char * +prochain_caractere(struct_processus *s_etat_processus, unsigned char *chaine) +{ + unsigned char *suivant; + + if (chaine == NULL) + { + return(NULL); + } + + if ((*chaine) == '\\') + { + if ((*(chaine + 1)) == '"') + { + suivant = chaine + 2; + } + else if ((*(chaine + 1)) == 'b') + { + suivant = chaine + 2; + } + else if ((*(chaine + 1)) == 'n') + { + suivant = chaine + 2; + } + else if ((*(chaine + 1)) == 't') + { + suivant = chaine + 2; + } + else if ((*(chaine + 1)) == 'x') + { + if ((*(chaine + 2)) != d_code_fin_chaine) + { + if ((*(chaine + 3)) != d_code_fin_chaine) + { + logical1 erreur; + + erreur = d_faux; + + switch(*(chaine + 2)) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + break; + + default: + erreur = d_vrai; + break; + } + + switch(*(chaine + 3)) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + break; + + default: + erreur = d_vrai; + break; + } + + if (erreur == d_vrai) + { + if ((*s_etat_processus).langue == 'F') + { + printf("+++Information : " + "Séquence d'échappement " + "inconnue [%d]\n", + (int) getpid()); + } + else + { + printf("+++Warning : Unknown " + "escape code " + "[%d]\n", (int) getpid()); + } + + return(NULL); + } + + suivant = chaine + 4; + } + else + { + if ((*s_etat_processus).langue == 'F') + { + printf("+++Information : " + "Séquence d'échappement " + "inconnue [%d]\n", (int) getpid()); + } + else + { + printf("+++Warning : Unknown escape code " + "[%d]\n", (int) getpid()); + } + + return(NULL); + } + } + else + { + if ((*s_etat_processus).langue == 'F') + { + printf("+++Information : " + "Séquence d'échappement " + "inconnue [%d]\n", (int) getpid()); + } + else + { + printf("+++Warning : Unknown escape code " + "[%d]\n", (int) getpid()); + } + + return(NULL); + } + } + else if ((*(chaine + 1)) == '\\') + { + suivant = chaine + 2; + } + else + { + if ((*s_etat_processus).langue == 'F') + { + printf("+++Information : Séquence d'échappement " + "inconnue [%d]\n", (int) getpid()); + } + else + { + printf("+++Warning : Unknown escape code " + "[%d]\n", (int) getpid()); + } + + return(NULL); + } + } + else + { + suivant = chaine + 1; + } + + return(suivant); +} + + +/* +================================================================================ + Routine donnant la longueur d'une chaîne de caractères +================================================================================ + Entrées : structure sur l'état du processus et chaîne +-------------------------------------------------------------------------------- + Sorties : longueur de la chaîne +-------------------------------------------------------------------------------- + Effets de bord : néant +================================================================================ +*/ + +integer8 +longueur_chaine(struct_processus *s_etat_processus, unsigned char *chaine) +{ + integer8 nombre_caracteres; + + unsigned char *pointeur; + + pointeur = chaine; + nombre_caracteres = 0; + + if ((*pointeur) == '\0') + { + return(0); + } + + do + { + if ((pointeur = prochain_caractere(s_etat_processus, pointeur)) == NULL) + { + return(0); + } + + nombre_caracteres++; + } while((*pointeur) != 0); + + return(nombre_caracteres); +} + + +/* +================================================================================ + Routine retournant un pointeur sur le i-ème caractère d'une chaîne +================================================================================ + Entrées : structure sur l'état du processus, chaîne et position du caractère +-------------------------------------------------------------------------------- + Sorties : pointeur sur le caractère +-------------------------------------------------------------------------------- + Effets de bord : néant +================================================================================ +*/ + +unsigned char * +pointeur_ieme_caractere(struct_processus *s_etat_processus, + unsigned char *chaine, integer8 position) +{ + integer8 i; + + unsigned char *pointeur; + + if ((pointeur = chaine) == NULL) + { + return(NULL); + } + + for(i = 0; i < position; i++) + { + pointeur = prochain_caractere(s_etat_processus, pointeur); + + if ((*pointeur) == d_code_fin_chaine) + { + return(pointeur); + } + } + + return(pointeur); +} + + +/* +================================================================================ + Routine retournant la position du caractère en fonction du pointeur + dans la chaîne +================================================================================ + Entrées : structure sur l'état du processus, chaîne et position +-------------------------------------------------------------------------------- + Sorties : quantième dans la chaîne +-------------------------------------------------------------------------------- + Effets de bord : néant +================================================================================ +*/ + +integer8 +position_caractere_de_chaine(struct_processus *s_etat_processus, + unsigned char *chaine, unsigned char *position) +{ + integer8 i; + + i = 1; + + while(chaine != position) + { + chaine = prochain_caractere(s_etat_processus, chaine); + i++; + + if ((*chaine) == d_code_fin_chaine) + { + return(0); + } + } + + return(i); +} + + +/* +================================================================================ + Conversion d'une chaîne en majuscule ou en minuscule +================================================================================ + Entrées : chaîne et indicateur ('M' pour majuscules, 'm' pour minuscules) +-------------------------------------------------------------------------------- + Sorties : néant +-------------------------------------------------------------------------------- + Effets de bord : néant +================================================================================ +*/ + +void +conversion_chaine(struct_processus *s_etat_processus, + unsigned char *chaine, unsigned char type) +{ + int (*fonction_1)(int); + int (*fonction_2)(int); + + unsigned char *ptr; + unsigned char *ptr2; + unsigned char registre; + + if (type == 'M') + { + fonction_1 = toupper; + fonction_2 = tolower; + } + else + { + fonction_1 = tolower; + fonction_2 = toupper; + } + + ptr = chaine; + + while((*ptr) != d_code_fin_chaine) + { + ptr2 = prochain_caractere(s_etat_processus, ptr); + + if ((ptr2 - ptr) == 1) + { + registre = fonction_1((*ptr)); + + if (fonction_2(registre) == (*ptr)) + { + (*ptr) = registre; + } + } + + ptr = ptr2; + } + + return; +} + // vim: ts=4