Lex和Yacc.之Lex

Lex(Lexical Analyzar 词法分析生成器)，Yacc(Yet Another Compiler Compiler

编译器代码生成器)是Unix下十分重要的词法分析，语法分析的工具。经常用于语言分
析，公式编译等广泛领域。遗憾的是网上中文资料介绍不是过于简单，就是跳跃太大，
入门参考意义并不大。本文通过循序渐进的例子，从0开始了解掌握Lex和Yacc的用法。

<本系列文章的地址：http://blog.csdn.net/liwei_cmg/category/207528.aspx>

一.Lex(Lexical Analyzar) 初步示例

先看简单的例子(注：本文所有实例皆在RetHat Linux下完成):

一个简单的Lex文件 exfirst.l 内容：

%{
#include "stdio.h"
%}
%%
[/n]                  ;
[0-9]+                printf("Int     : %s/n",yytext);
[0-9]*/.[0-9]+        printf("Float   : %s/n",yytext);
[a-zA-Z][a-zA-Z0-9]*  printf("Var     : %s/n",yytext);
[/+/-/*///%]          printf("Op      : %s/n",yytext);
.                     printf("Unknown : %c/n",yytext[0]);
%%

在命令行下执行命令flex解析，会自动生成lex.yy.c文件：
[root@localhost liweitest]flex exfirst.l

进行编译生成parser可执行程序：
[root@localhost liweitest]cc -o parser lex.yy.c -ll

[注意：如果不加-ll链结选项，cc编译时会出现以下错误，后面会进一步说明。]

/usr/lib/gcc-lib/i386-redhat-linux/3.2.2/../../../crt1.o(.text+0x18): In function `_start':
../sysdeps/i386/elf/start.S:77: undefined reference to `main'
/tmp/cciACkbX.o(.text+0x37b): In function `yylex':
: undefined reference to `yywrap'
/tmp/cciACkbX.o(.text+0xabd): In function `input':
: undefined reference to `yywrap'
collect2: ld returned 1 exit status

创建待解析的文件 file.txt：

title
i=1+3.9;
a3=909/6
bcd=4%9-333

通过已生成的可执行程序，进行文件解析。

[root@localhost liweitest]# ./parser < file.txt
Var     : title
Var     : i
Unknown : =
Int     : 1
Op      : +
Float   : 3.9
Unknown : ;
Var     : a3
Unknown : =
Int     : 909
Op      : /
Int     : 6
Var     : bcd
Unknown : =
Int     : 4
Op      : %
Int     : 9
Op      : -
Int     : 333

到此Lex用法会有个直观的了解：

1.定义Lex描述文件
2.通过lex，flex工具解析成lex.yy.c文件
3.使用cc编译lex.yy.c生成可执行程序

再来看一个比较完整的Lex描述文件  exsec.l  ：

%{
#include "stdio.h"
int linenum;
%}
%%
title                 showtitle();
[/n]                  linenum++;
[0-9]+                printf("Int     : %s/n",yytext);
[0-9]*/.[0-9]+        printf("Float   : %s/n",yytext);
[a-zA-Z][a-zA-Z0-9]*  printf("Var     : %s/n",yytext);
[/+/-/*///%]          printf("Op      : %s/n",yytext);
.                     printf("Unknown : %c/n",yytext[0]);
%%
showtitle()
{
printf("----- Lex Example -----/n");
}

int main()
{
  linenum=0;
  yylex(); /* 进行分析 */
  printf("/nLine Count: %d/n",linenum);
  return 0;
}
int yywrap()
{
return 1;
}

进行解析编译：
[root@localhost liweitest]flex exsec.l
[root@localhost liweitest]cc -o parser lex.yy.c
[root@localhost liweitest]./parser < file.txt

----- Lex Example -----
Var     : i
Unknown : =
Int     : 1
Op      : +
Float   : 3.9
Unknown : ;
Var     : a3
Unknown : =
Int     : 909
Op      : /
Int     : 6
Var     : bcd
Unknown : =
Int     : 4
Op      : %
Int     : 9
Op      : -
Int     : 333

Line Count: 4

这里就没有加-ll选项，但是可以编译通过。下面开始着重整理下Lex描述文件.l。

二.Lex(Lexical Analyzar) 描述文件的结构介绍

Lex工具是一种词法分析程序生成器，它可以根据词法规则说明书的要求来生成单词识
别程序，由该程序识别出输入文本中的各个单词。 一般可以分为<定义部分><规则部
分><用户子程序部分>。其中规则部分是必须的，定义和用户子程序部分是任选的。 

(1)定义部分 
定义部分起始于 %{ 符号，终止于 %} 符号，其间可以是包括include语句、声明语句
在内的C语句。这部分跟普通C程序开头没什么区别。
%{ 
#include "stdio.h"
int linenum;
%}

(2) 规则部分 
规则部分起始于"%%"符号，终止于"%%"符号，其间则是词法规则。词法规则由模式和
动作两部分组成。模式部分可以由任意的正则表达式组成，动作部分是由C语言语句组
成，这些语句用来对所匹配的模式进行相应处理。需要注意的是，lex将识别出来的单
词存放在yytext[]字符数据中，因此该数组的内容就代表了所识别出来的单词的内容。
类似yytext这些预定义的变量函数会随着后面内容展开一一介绍。动作部分如果有多
行执行语句，也可以用{}括起来。

%%
title                 showtitle();
[/n]                  linenum++;
[0-9]+                printf("Int     : %s/n",yytext);
[0-9]*/.[0-9]+        printf("Float   : %s/n",yytext);
[a-zA-Z][a-zA-Z0-9]*  printf("Var     : %s/n",yytext);
[/+/-/*///%]          printf("Op      : %s/n",yytext);
.                     printf("Unknown : %c/n",yytext[0]);
%%

A.规则部分的正则表达式

规则部分是Lex描述文件中最为复杂的一部分，下面列出一些模式部分的正则表达式字
符含义：

A-Z, 0-9, a-z         构成模式部分的字符和数字。

-                     指定范围。例如：a-z 指从 a 到 z 之间的所有字符。

/                     转义元字符。用来覆盖字符在此表达式中定义的特殊意义，
                      只取字符的本身。
                      
[]                    表示一个字符集合。匹配括号内的任意字符。如果第一个字
                      符是^那么它表示否定模式。例如: [abC] 匹配 a, b, 和C
                      的任何一个。
                      
^                     表示否定。

*                     匹配0个或者多个上述模式。
+                     匹配1个或者多个上述模式。
?                     匹配0个或1个上述模式。

$                     作为模式的最后一个字符时匹配一行的结尾。

{ }                   表示一个模式可能出现的次数。 例如: A{1,3} 表示 A 可
                     能出现1次或3次。[a-z]{5} 表示长度为5的，由a-z组成的
                     字符。此外，还可以表示预定义的变量。
                     
.                     匹配任意字符，除了 /n。

( )                   将一系列常规表达式分组。如：{Letter}({Letter}|{Digit})* 
|                     表达式间的逻辑或。

"一些符号"            字符的字面含义。元字符具有。如："*" 相当于 [/*]。

/                     向前匹配。如果在匹配的模式中的"/"后跟有后续表达式，
                      只匹配模版中"/"前面的部分。如：模式为 ABC/D 输入 ABCD，
                      时ABC会匹配ABC/D，而D会匹配相应的模式。输入ABCE的话，
                      ABCE就不会去匹配ABC/D。

B.规则部分的优先级

规则部分具有优先级的概念，先举个简单的例子：

%{
#include "stdio.h"
%}
%%
[/n]                  ;
A                     {printf("ONE/n");};
AA                    {printf("TWO/n");};
AAAA                  {printf("THREE/n");};
%%

此时，如果输入内容：

[root@localhost liweitest]# cat file1.txt
AAAAAAA

[root@localhost liweitest]# ./parser < file1.txt
THREE
TWO
ONE

Lex分析词法时，是逐个字符进行读取，自上而下进行规则匹配的，读取到第一个A字符
时，遍历后发现三个规则皆匹配成功，Lex会继续分析下去，读至第五个字符时，发现
"AAAA"只有一个规则可用，即按行为进行处理，以此类推。可见Lex会选择最长的字符
匹配规则。

如果将规则
AAAA                  {printf("THREE/n");};
改为
AAAAA                 {printf("THREE/n");};

 ./parser < file1.txt 输出结果为：
THREE
TWO

再来一个特殊的例子：

%%
title                 showtitle();
[a-zA-Z][a-zA-Z0-9]*  printf("Var     : %s/n",yytext);
%%

并输入title，Lex解析完后发现，仍然存在两个规则，这时Lex只会选择第一个规则，下面
的则被忽略的。这里就体现了Lex的顺序优先级。把这个例子稍微改一下：

%%
[a-zA-Z][a-zA-Z0-9]*  printf("Var     : %s/n",yytext);
title                 showtitle();
%%

Lex编译时会提示：warning, rule cannot be matched.这时处理title字符时，匹配
到第一个规则后，第二个规则就无效了。

再把刚才第一个例子修改下，加深下印象！

%{
#include "stdio.h"
%}
%%
[/n]                  ;
A                     {printf("ONE/n");};
AA                    {printf("TWO/n");};
AAAA                  {printf("THREE/n");};
AAAA                  {printf("Cannot be executed!");};

./parser < file1.txt 显示效果是一样的，最后一项规则肯定是会忽略掉的。

 

C.规则部分的使用变量

且看下面示例：

%{
#include "stdio.h"
int linenum;
%}
int                   [0-9]+
float                 [0-9]*/.[0-9]+
%%
{int}                 printf("Int     : %s/n",yytext);
{float}               printf("Float   : %s/n",yytext);
.                     printf("Unknown : %c/n",yytext[0]);
%%

在%}和%%之间，加入了一些类似变量的东西，注意是没有;的，这表示int，float分
别代指特定的含义，在两个%%之间，可以通过{int}{float}进行直接引用，简化模
式定义。

(3) 用户子程序部分

最后一个%%后面的内容是用户子程序部分，可以包含用C语言编写的子程序，而这些子
程序可以用在前面的动作中，这样就可以达到简化编程的目的。这里需要注意的是，
当编译时不带-ll选项时，是必须加入main函数和yywrap(yywrap将下后面说明)。如：

...
%%
showtitle()
{
printf("----- Lex Example -----/n");
}

int main()
{
  linenum=0;
  yylex(); /* 进行Lex分析 */
  printf("/nLine Count: %d/n",linenum);
  return 0;
}
int yywrap()
{
return 1;
}

三.Lex(Lexical Analyzar) 一些的内部变量和函数

内部预定义变量：

yytext   char *  当前匹配的字符串
yyleng   int     当前匹配的字符串长度
yyin     FILE *  lex当前的解析文件，默认为标准输出
yyout    FILE *  lex解析后的输出文件，默认为标准输入
yylineno int     当前的行数信息

内部预定义宏：

ECHO     #define ECHO fwrite(yytext, yyleng, 1, yyout)  也是未匹配字符的
         默认动作
        

内部预定义的函数：

int yylex(void)    调用Lex进行词法分析
int yywrap(void)   在文件(或输入)的末尾调用。如果函数的返回值是1，就停止解
                   析。 因此它可以用来解析多个文件。代码可以写在第三段，这
                   样可以解析多个文件。 方法是使用 yyin 文件指针指向不同的
                   文件，直到所有的文件都被解析。最后，yywrap() 可以返回1
                   来表示解析的结束。
            
            
lex和flex都是解析Lex文件的工具，用法相近，flex意为fast lexical analyzer generator。
可以看成lex的升级版本。

相关更多内容就需要参考flex的man手册了，十分详尽。

 

四.关于Lex的一些综述

Lex其实就是词法分析器，通过配置文件*.l，依据正则表达式逐字符去顺序解析文件，
并动态更新内存的数据解析状态。不过Lex只有状态和状态转换能力。因为它没有堆栈，
它不适合用于剖析外壳结构。而yacc增加了一个堆栈，并且能够轻易处理像括号这样的
结构。Lex善长于模式匹配，如果有更多的运算要求就需要yacc了。

Bison是一个通用的语法解析器生成器，与YACC兼容，它能够将一个LALR(1)的上下文无关文法描述规则转化一个解析该语法的C程序。LALR(1)指的是"向前看一个符号的自底向上文法分析技术"，简单来说就一种通过向前看一个字符就解析该符号片段的上下文无关文法。关于上下文无关文法的概念，符号，开始符号，终结符，非终结符等不再多做介绍。

Bison接受一个用户定义的文法文件，文法规则通常使用机器可读的BNF表示，产生一个能够解析该文法的语法解析器。

一、使用Bison通常包含以下几个步骤：

1.以Bison可识别的形式正规定义一个文法。对于每一条文法规则，定义其对应的动作。

2.编写一个词法分析器，能够将输入的源文件转化为词法符号，并将符号传递给文法解析器。词法解析器可以手写，也可以使用flex生成。

3.写一个控制函数来调用Bison生成的文法解析器。

4.编写错误报告和处理函数。

二、Bison输入的文法文件的格式

%{

C的声明

%}

Bison 的一些声明

%%

文法规则

%%

附加的C代码

1.符号：终结符和非终结符

终结符：表示具有等价语法的符号。yylex返回的是表示终结符类型的符号类型码。终结符有三种，分别是命名符号类型，字面字符类型和字面字符串类型。

非终结符：表示具有等价语法的组合。

2.规则：

递归规则中应该使用左递归而非右递归，因为左递归总能够使用有限的栈空间解析出一个字符序列。

3.语义定义

Bison中默认将所有的语义值都定义为int类型，可以通过定义宏YYSTYPE来改变值的类型。如果有多个值类型，则需要通过在Bison声明中使用%union列举出所有的类型，然后为每个符号定义相对的类型，终结符使用%token，非终结符使用%type来定义。

在动作(Action)中，$i表示第i个符号的值，其类型与Bison声明中的类型一致，或者可以通过$<type>i来指定值类型。

4.Bison声明

(1)%token NUM 

(2)%token NUM 300 //指定符号类型的编码数字，不建议使用

(3)%union{

    double *doublepval;

    int    *int_val;

  }

  %token <int_val> NUM

(4)将一个字符串与一个符号类型关联起来  %token OR "||"

(5)操作符优先级定义

   %left ADD  //左结合

   %right NEG  //右结合 

   %nonassoc OP  //无结合，如果出现x op y则是语法错误

   定义在后面的符号比定义在前面的符号具有更好的优先级

(6)非终结符 %type <double_value> exp  

(7)消除警告。使用%expect n 表示用户已知有N个shift/reduce冲突，不需要语法解析器发出警告。

(8)开始符号。默认认为语法规则中出现的第一个非终结符是开始符号，也可以通过%start symbol来明确指定。

(9)可重入的语法解析器。Bison解析通常不是一个可重入的程序，因为它使用静态分配的变量(yylval yylloc)与yylex进行通信。可以通过 %pure_parser  来指定希望解析器是可重入的。

三、Bison的C语言接口

1.yyparse();  成功返回0，失败返回1，可以通过使用宏 YYACCEPT YYABORT来立即返回结果。

2.yylex()

3.符号的语义值存储在全局变量yylval中

4.如果使用了"@n"特征，则文本的当前位置会存储在全局变量yylloc中，yylloc的类型为YYLTYPE。

5.可重入语法解析器的调用规则。

6.错误报告函数yyerror()。如果定义了宏YYERROR_VERBOSE则会显示相对完整的错误信息。 yyerrok是一个错误恢复的宏定义，yynerrs记录错误的数目。

 

举一个例子：

flex 源文件：one.l

%option noyywrap 

%{

    #include "one.tab.h"

    int trace = 0 ; 

%}

%%

[0-9]   {if(trace)ECHO;

            yylval=atof(yytext);

            printf("yylval=%f\n",yylval);

            return NUM;

        }   

"+"     {if(trace)ECHO;return '+';}

"-"     {if(trace)ECHO;return '-';}

"*"     {if(trace)ECHO;return '*';}

"/"     {if(trace)ECHO;return '/';}

"^"     {if(trace)ECHO;return '^';}

"n"     {if(trace)ECHO;return 'n';}

"("     {if(trace)ECHO;return '(';}

")"     {if(trace)ECHO;return ')';}

"\n"    {if(trace)ECHO;return '\n';}

.       {if(trace)ECHO;}

%%

Bison源文件 one.y:

%{

    #define YYSTYPE double

    #define YYERROR_VERBOSE 1

    #include<math.h>

    #include<stdio.h>

    int yylex(void);

    void yyerror(const char*);

%}

%token NUM 

%left '-' '+' 

%left '*' '/' 

%left NEG 

%right '^' 

%%

input:  /*empty*/

        | input line

        ;

line:   '\n'

        | exp '\n'  {printf("value=%f\n",$1);}

        | error '\n'    {yyerrok;}

        ;

exp:    NUM {$$=$1;}

        |exp '+' exp        {printf("%f + %f\n",$1,$3);$$=$1+$3;}

        |exp '-' exp        {$$=$1-$3;}

        |exp '*' exp        {$$=$1*$3;}

        |exp '/' exp        {$$=$1/$3;}

        |'-' exp %prec NEG  {$$=-$2;}

        |exp '^' exp        {$$=pow($1,$3);}

        |'(' exp ')'        {$$=$2;}

        ;

%%

int main(void)

{

    return yyparse();

}

void yyerror(char const *s) 

{

    fprintf(stderr,"%s\n",s);

}

编译过程：

flex one.l  生成 lex.yy.c

bison one.y -d  生成one.tab.h one.tab.c

修改one.tab.h中的 typedef int YYSTYPE  改为 typedef double YYSTYPE 

gcc -o one one.tab.c lex.yy.c -lm

生成了可执行文件one

原文地址：http://blog.csdn.net/liwei_cmg/article/details/1530492