 |
||||||
|
||||||
SCR/AL1 - TOME III. Les librairies utilitaires
Le groupe s_yy offre une série de facilités intéressantes pour l'interprétation de fichiers ASCII ou de buffers de caractères (strings). Il est notamment utilisé par les différents compilateurs de SCR/AL1 : scr4_e, scr4_drv, scr4_h.
L'objectif est d'analyser un texte ASCII en identifiant les différents éléments constitutifs du texte. Une fonction de lecture lit et interprète un élément du texte et en retourne le type (string, mot, entier, etc). Le prochain appel retourne le type de l'élément suivant, etc. La valeur de l'élément lu est disponible dans un buffer.
Si le texte à analyser peut contenir des mots-clés, ceux-ci peuvent être spécifiés et les fonctions de s_yy reconnaîtront les mots-clés comme des entités différentes de celles de base (mot, string, entier, etc).
De plus, des directives du type de celles utilisées en C peuvent être incorporées dans le fichier (include, define, etc). Ceci permet d'accroître considérablement la puissance d'un interpréteur.
Par exemple, le texte suivant
NOM "Durand"
PRENOM "Bernard"
ADRESSE "rue de l'Informatique"
CODEPOST 1040
CHAFF 100.42E5
NOM "Dupont"
CHAFF 1200
peut être décomposé très simplement par le programme qui suit. Celui-ci affiche simplement les valeurs détectées par YY_lex(). On étendra aisément sa portée en fonction d'une application sous-jacente.
/* Table des mots-clés */
YYKEYS MY_KEYWS[] = {
"ADRESSE", 1,
"CHAFF", 2,
"CODEPOST", 3,
"NOM", 4,
"PRENOM", 5
};
main()
{
YYFILE *yy;
int type;
yy = YY_open("test", MY_KEYWS,
sizeof(MY_KEYWS) / sizeof(YYKEYS), YY_FILE);
if(yy == 0) {
fprintf(stderr, "Cannot open test\n");
exit(1);
}
while(1) {
type = YY_lex(yy);
printf("Read : %d - ", type);
switch(type) {
case YY_WORD :
case YY_STRING : printf("%s\n", yy->yy_text); break;
case YY_LONG : printf("%ld\n", yy->yy_long); break;
case YY_DOUBLE : printf("%lf\n", yy->yy_double); break;
case YY_SPECIAL:
case YY_LETTER : printf("%c\n", yy->yy_text[0]); break;
case YY_EOF : YY_close(yy); exit(0);
case 1 : printf("Mot-clé ADRESSE\n"); break;
case 2 : printf("Mot-clé CHAFF\n"); break;
case 3 : printf("Mot-clé CODEPOST\n"); break;
case 4 : printf("Mot-clé NOM\n"); break;
case 5 : printf("Mot-clé PRENOM\n"); break;
default : break;
}
}
}
Les exemples proposés en fin de chapitre indiqueront de façon plus détaillée les avantages que l'on peut tirer de cette librairie.
Un texte à analyser peut être de trois types :
Le texte est d'abord ouvert et le pointeur vers une structure YYFILE est retourné (fonction YY_open()). Ensuite différentes fonctions sont disponibles pour en interpréter le contenu : YY_read(), YY_lex(), YY_getc(), YY_ungetc(), YY_unread(), YY_skip_to_*(), etc.
Enfin, le texte est fermé (et la structure YYFILE désallouée) par la fonction YY_close().
Eléments interprétés par les fonctions de s_yy
Les éléments constitutifs du texte sont déterminés suivant un certaine logique et une syntaxe sous-jacente. Les règles d'interprétation de tout ce qui peut se trouver dans un fichier est décrite ci-dessous. Elles ne sont pas valables pour YY_getc qui lit caractère par caractère, quel que soit celui-ci. Par contre, elles sont d'application pour YY_read() et YY_lex(), qui sont les deux fonctions les plus utilisées.
Les fonctions YY_read() et YY_lex() retournent une valeur entière qui indique ce qui a été lu. Ces valeurs entières sont définies plus bas sous le titre "Define".
Valeurs spéciales des caractères
Entre quotes simples et doubles, certaines suites de caractères sont interprétées de façon particulière. Le but est de permettre de définir certaines valeurs de la table des 256 caractères ASCII qui n'ont pas d'équivalent graphique.
Les règles sont les suivantes :
\' vaut SINGLE QUOTE
\" vaut DOUBLE QUOTE
\\ vaut BACKSLASH
\a vaut \a
\b vaut BACKSPACE
\f vaut FORMFEED
\n vaut NEWLINE
\r vaut RETURN
\t vaut TAB
\v vaut VTAB
\^ vaut ^
\xAA ou \XAA représentent le code HEXADECIMAL du caractère
\dnnn ou \Dnnn représentent le code DECIMAL du caractère
\nnn ou \nnn représentent le code OCTAL du caractère (0 <= n <= 7)
^[ vaut ESCAPE
^a ou ^A vaut CTRL-A
^b ou ^B vaut CTRL-B
...
^z ou ^Z vaut CTRL-Z
Directives
Les directives de s_yy permettent une série d'opérations dans le fichier ASCII qui se rapprochent des directives du langage C. Elles commencent toutes par le caractère # suivi d'un mot et de paramètres éventuels.
Les directives reconnues par YY_read() et YY_lex() sont les suivantes :
Définition des macros
Les macros peuvent être définies de deux manières. La plus courante est d'introduire dans le texte des directive #define, comme décrit ci-dessus. Pour gagner du temps, certains programmes peuvent être amenés à construire eux-mêmes la table des définitions (prédéfinies). Cette table (statique) de définition est stockée dans la structure YYFILE par l'utilisateur.
yy->yy_stdefs = defs;
yy->yy_nb_stdefs = nbdefs;
La table defs est simplement un ensemble de structure YYDEF (voir plus bas).
Messages d'erreur
Les messages d'erreur suivants sont envoyés vers le standard error (écran en général). Il n'arrêtent pas le programme mais peuvent conduire à des erreurs ou à des incohérences dans la lecture.
Fonctions d'ouverture, de fermeture et d'erreur
Fonctions de lecture syntaxiques
Fonctions de lecture orientées caractères
Fonctions de lecture jusqu'à une borne
Fonctions de debugging
Variables
Les variables suivantes sont utilisées par les fonctions de la librairie. Elles permettent de personnaliser quelque peu l'outil.
Defines
Les définitions suivantes se trouvent dans le fichier s_yy.h. Le premier groupe reprend toutes les valeurs de retour possibles de YY_read(), YY_lex2() et YY_lex().
Le second groupe contient les valeurs possibles du paramètre de YY_open() définissant le type d'output.
Limites
Les limites suivantes sont définies dans s_yy.h.
Les structures YYKEYS, YYFILE, YYDEF
Trois structures (typedef) sont utilisables par l'utilisateur. Ce sont :
La première correspond aux définitions de mots-clés passées à la fonction YY_open(). La seconde est une structure reprenant les informations concernant un fichier ouvert. La troisième est une sous-structure de YYFILE qui contient une table de #defines.
Elles sont définies en détail plus bas dans le texte et reprises dans s_yy.h.
4.1 YY_open (file s_ybase.c:76)
4.2 YY_close (file s_ybase.c:197)
4.3 YY_error (file s_yerror.c:18)
4.4 YY_read (file s_yread.c:310)
4.5 YY_unread (file s_yread.c:91)
4.6 YY_lex (file s_ylex.c:146)
4.7 YY_lex2 (file s_ylex.c:82)
4.8 YY_getc (file s_ybase.c:319)
4.9 YY_ungetc (file s_ybase.c:278)
4.10 YY_record (file s_ybase.c:228)
4.11 YY_skip_spaces (file s_yread.c:55)
4.12 YY_skip_to_eol (file s_yread.c:108)
4.13 YY_skip_to_char (file s_yread.c:125)
4.14 YY_read_to_char (file s_yread.c:158)
4.15 YY_read_to_chars (file s_yread.c:200)
4.16 YY_read_to_string (file s_yread.c:236)
4.17 YY_debug (file s_ydebug.c:16)
Copyright © 1998-2015 Jean-Marc Paul and Bernard PAUL - Envoyez vos remarques ou commentaires à bernard@xon.be