qu'est-ce que Linux Flex

Sous Linux, flex est un outil d'analyse lexicale qui peut identifier des modèles lexicaux dans le texte ; Flex lit un fichier d'entrée donné si aucun nom de fichier n'est donné, il lit à partir de l'entrée standard pour obtenir une description de ce qui est nécessaire. le scanner généré.

L'environnement d'exploitation de ce tutoriel : système linux5.9.8, ordinateur Dell G3.

flex : Analyseur Lexical

flex est un analyseur lexical. Utilisé pour générer un fichier .l dans un fichier programme .c. Autrement dit, un analyseur lexical est généré. Lisez ensuite l'entrée, faites-la correspondre avec l'expression régulière, puis effectuez l'action correspondante pour réaliser la fonction du programme. Nous pouvons constater que flex implémente la fonction d'accepter des entrées en dehors du programme.

Flex est un outil qui génère des scanners capables d'identifier des modèles lexicaux dans le texte. Flex lit le fichier d'entrée donné, ou l'entrée standard si aucun nom de fichier n'est donné, pour obtenir une description du scanner à générer. Cette description est appelée règle et se compose de paires d'expressions régulières et de code C. La sortie de Flex est un fichier de code C — lex.yy.c — dans lequel la fonction yylex() est définie. La compilation du fichier de sortie produit un fichier exécutable. Lorsque l'exécutable est exécuté, il analyse le fichier d'entrée, recherchant une correspondance pour chaque expression régulière. Lorsqu'une correspondance est trouvée, il exécute le code C associé à cette expression régulière. Flex n'est pas un projet GNU, mais GNU a écrit un manuel pour Flex. Installez flex hide-digits.l. Notez que %% dans ce fichier doit être au début de cette ligne (c'est-à-dire qu'il ne peut y avoir d'espace devant %%).

Après cela, entrez dans le terminal :

• sudo apt-get install flex
  //或者下载相应版本的安装文件安装

  À ce moment, il y a un fichier "lex.yy.c" supplémentaire dans le répertoire Compilez et exécutez ce fichier C :
.

• %%
  [0-9]+  printf("?");
  #       return 0;
  .       ECHO;
  %%
  int main(int argc, char* argv[]) {
      yylex();
      return 0;
  }
  int yywrap() { 
      return 1;
  }

  Ensuite, continuez à taper n'importe quelle touche du terminal et appuyez sur Entrée. Vous pouvez constater que dans le contenu saisi, tous les caractères, à l'exception des chiffres, sont affichés tels quels et chaque chaîne de caractères numériques est remplacée par ?. Enfin, tapez # et le programme se termine. Comme suit :

  flex hide-digits.l

Lors de l'exécution de flex sur la ligne de commande, le deuxième paramètre de ligne de commande (hide-digits.l ici) est le fichier de modèle de segmentation de mots fourni à flex. Ce fichier de modèle contient principalement les règles habituelles de l'utilisateur. La segmentation de mots. Le modèle de correspondance écrit dans l'expression sera traduit dans la fonction yylex au format de code C en utilisant flex et sorti dans le fichier lex.yy.c. Cette fonction peut être considérée comme un automate à états finis.

Lors de l'exécution de flex sur la ligne de commande, le deuxième paramètre de ligne de commande (hide-digits.l ici) est le fichier de modèle de segmentation de mots fourni à flex. Ce fichier de modèle est principalement écrit par l'utilisateur à l'aide d'expressions régulières. modèle de correspondance de segmentation, utilisez flex pour traduire ces expressions régulières en fonction yylex au format de code C et affichez-la dans le fichier lex.yy.c. Cette fonction peut être considérée comme un automate à états finis.

• Expliquons en détail le code dans le fichier hide-digits.l Tout d'abord, le premier paragraphe est :

 gcc -o hide-digits lex.yy.c
./hide-digits

• fichier en mode flex, utilisez %% et %% pour diviser le contenu. de la division ci-dessus C'est ce qu'on appelle des règles. Chaque ligne de ce fichier est une règle. Chaque règle est constituée d'un modèle correspondant et d'un événement. Le modèle est au premier plan, représenté par une expression régulière, et l'événement est au fond. qui est le code C. Chaque fois qu'un modèle correspond, le code C suivant est exécuté.

flex traduira ce paragraphe en une fonction appelée yylex. La fonction de cette fonction est d'analyser le fichier d'entrée (entrée standard par défaut lorsqu'une expression régulière complète, la plus longue et certaine correspond à une chaîne). cette fonction exécute le code C qui suit la règle. S'il n'y a pas d'instruction return dans ces codes C, après avoir exécuté ces codes C, la fonction yylex continuera à s'exécuter et lancera le prochain cycle d'analyse et de correspondance.

Lorsque le modèle de plusieurs règles correspond, yylex sélectionnera la règle avec la longueur correspondante la plus longue. S'il existe des règles avec une longueur correspondante égale, la règle supérieure sera sélectionnée.

• eruiewdkfj
  eruiewdkfj
  1245
  ?
  fdsaf4578
  fdsaf?
  ...
  #

• La fonction principale du deuxième paragraphe est le point d'entrée du programme. Flex copiera ces codes à la fin du fichier lex.yy.c tels quels. La fonction yywrap de la dernière ligne, flex nécessite une telle fonction.

Exemple

• word-spliter.l

• %%
  [0-9]+  printf("?");
  #       return 0;
  .       ECHO;
  %%

  Dans cet exemple, deux variables globales yytext et yyleng fournies par flex sont utilisées pour représenter la chaîne qui vient de correspondre et sa longueur de

• est compilé et exécuté

flex word-spliter.l
gcc -o word-spliter lex.yy.c
./word-spliter < word-spliter.l
输出：
WORD:       %{
WORD:       #define
...
WORD:       }
Chars       Words   Lines
470 70      27

可见此程序其实就是一个原始的分词器，它将输入文件分割成一个个的 WORD 再输出到终端，同时统计输入文件中的字符数、单词数和行数。此处的 WORD 指一串连续的非空格字符。

扩展

（1） 列出所需的所有类型的 token；

（2） 为每种类型的 token 分配一个唯一的编号，同时写出此 token 的正则表达式；

（3） 写出每种 token 的 rule （相应的 pattern 和 action ）。

第 1 类为单字符运算符，一共 15 种：

+ * - / % = , ; ! < > ( ) { }

第 2 类为双字符运算符和关键字，一共 16 种：

<=, >=, ==, !=, &&, ||
void, int, while, if, else, return, break, continue, print, readint

第 3 类为整数常量、字符串常量和标识符（变量名和函数名），一共 3 种。

拓展后

%{
#include "token.h"
int cur_line_num = 1;
void init_scanner();
void lex_error(char* msg, int line);
%}
/* Definitions, note: \042 is '"' */
INTEGER             ([0-9]+)
UNTERM_STRING       (\042[^\042\n]*)
STRING              (\042[^\042\n]*\042)
IDENTIFIER          ([_a-zA-Z][_a-zA-Z0-9]*)
OPERATOR            ([+*-/%=,;!<>(){}])
SINGLE_COMMENT1     ("//"[^\n]*)
SINGLE_COMMENT2     ("#"[^\n]*)
%%
[\n]                { cur_line_num++;                       }
[ \t\r\a]+          { /* ignore all spaces */               }
{SINGLE_COMMENT1}   { /* skip for single line comment */    }
{SINGLE_COMMENT2}   { /* skip for single line commnet */    }
{OPERATOR}          { return yytext[0];         }   
"<="                { return T_Le;              }
">="                { return T_Ge;              }
"=="                { return T_Eq;              }
"!="                { return T_Ne;              }
"&&"                { return T_And;             }
"||"                { return T_Or;              }
"void"              { return T_Void;            }
"int"               { return T_Int;             }
"while"             { return T_While;           }
"if"                { return T_If;              }
"else"              { return T_Else;            }
"return"            { return T_Return;          }
"break"             { return T_Break;           }
"continue"          { return T_Continue;        }
"print"             { return T_Print;           }
"readint"           { return T_ReadInt;         }
{INTEGER}           { return T_IntConstant;     }
{STRING}            { return T_StringConstant;  }
{IDENTIFIER}        { return T_Identifier;      }
<<EOF>>             { return 0; }
{UNTERM_STRING}     { lex_error("Unterminated string constant", cur_line_num);  }
.                   { lex_error("Unrecognized character", cur_line_num);        }
%%
int main(int argc, char* argv[]) {
    int token;
    init_scanner();
    while (token = yylex()) {
        print_token(token);
        puts(yytext);
    }
    return 0;
}
void init_scanner() {
    printf("%-20s%s\n", "TOKEN-TYPE", "TOKEN-VALUE");
    printf("-------------------------------------------------\n");
}
void lex_error(char* msg, int line) {
    printf("\nError at line %-3d: %s\n\n", line, msg);
}
int yywrap(void) {
    return 1;
}

上面这个文件中，需要注意的是，正则表达式中，用双引号括起来的字符串就是原始字符串，里面的特殊字符是不需要转义的，而双引号本身必须转义（必须用 \” 或 \042 ），这是 flex 中不同于常规的正则表达式的一个特性。

除单字符运算符外的 token 的编号则在下面这个 token.h 文件，该文件中同时提供了一个 print_token 函数，可以根据 token 的编号打印其名称。

#ifndef TOKEN_H
#define TOKEN_H
typedef enum {
    T_Le = 256, T_Ge, T_Eq, T_Ne, T_And, T_Or, T_IntConstant,
    T_StringConstant, T_Identifier, T_Void, T_Int, T_While,
    T_If, T_Else, T_Return, T_Break, T_Continue, T_Print,
    T_ReadInt
} TokenType;
static void print_token(int token) {
    static char* token_strs[] = {
        "T_Le", "T_Ge", "T_Eq", "T_Ne", "T_And", "T_Or", "T_IntConstant",
        "T_StringConstant", "T_Identifier", "T_Void", "T_Int", "T_While",
        "T_If", "T_Else", "T_Return", "T_Break", "T_Continue", "T_Print",
        "T_ReadInt"
    };
    if (token < 256) {
        printf("%-20c", token);
    } else {
        printf("%-20s", token_strs[token-256]);
    }
}
#endif

makefile

out: scanner
scanner: lex.yy.c token.h
gcc -o $@ $<
lex.yy.c: scanner.l
flex $<



相关推荐：《Linux视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!