最近由于项目需要，看了点关于编译原理和编译器等方面的资料，特别是词法分析和语法分析部分，现做一下小结。

      一、编译器及其工作流程

       编 译器，是将便于人编写，阅读，维护的高级计算机语言翻译为计算机能识别，运行的低级机器语言的程序。编译器将源程序（Source program）作为输入，翻译产生使用目标语言（Target language）的等价程序。源程序一般为高级语言（High-level language），如Pascal，C++等，而目标语言则是汇编语言或目标机器的目标代码（Object code），有时也称作机器代码（Machine code）。

       一个现代编译器的主要工作流程如下：
       源程序（source code）→预处理器（preprocessor）→编译器（compiler）→汇编程序（assembler）→目标程序（object code）→连接器（链接器，Linker）→可执行程序（executables）

       而编译器各阶段的主要工作包括：  

      1. 词法分析

       词法分析器根据词法规则识别出源程序中的各个记号（token），每个记号代表一类单词（lexeme）。源程序中常见的记号可以归为几大类：关键字、标识符、字面量和特殊符号。词法分析器的输入是源程序，输出是识别的记号流。词法分析器的任务是把源文件的字符流转换成记号流。本质上它查看连续的字符然后把它们识别为“单词”。

       2. 语法分析

       语法分析器根据语法规则识别出记号流中的结构（短语、句子），并构造一棵能够正确反映该结构的语法树。

       3. 语义分析

       语义分析器根据语义规则对语法树中的语法单元进行静态语义检查，如果类型检查和转换等，其目的在于保证语法正确的结构在语义上也是合法的。

       4. 中间代码生成

      中间代码生成器根据语义分析器的输出生成中间代码。中间代码可以有若干种形式，它们的共同特征是与具体机器无关。最常用的一种中间代码是三地址码，它的一种实现方式是四元式。三地址码的优点是便于阅读、便于优化。

        5. 中间代码优化

      优化是编译器的一个重要组成部分，由于编译器将源程序翻译成中间代码的工作是机械的、按固定模式进行的，因此，生成的中间代码往往在时间和空间上有很大浪费。当需要生成高效目标代码时，就必须进行优化。

       6. 目标代码生成

      目标代码生成是编译器的最后一个阶段。在生成目标代码时要考虑以下几个问题：计算机的系统结构、指令系统、寄存器的分配以及内存的组织等。编译器生成的目标程序代码可以有多种形式：汇编语言、可重定位二进制代码、内存形式。

       7 符号表管理

      符号表的作用是记录源程序中符号的必要信息，并加以合理组织，从而在编译器的各个阶段能对它们进行快速、准确的查找和操作。符号表中的某些内容甚至要保留到程序的运行阶段。

      8 出错处理

      用 户编写的源程序中往往会有一些错误，可分为静态错误和动态错误两类。所谓动态错误，是指源程序中的逻辑错误，它们发生在程序运行的时候，也被称作动态语义 错误，如变量取值为零时作为除数，数组元素引用时下标出界等。静态错误又可分为语法错误和静态语义错误。语法错误是指有关语言结构上的错误，如单词拼写 错、表达式中缺少操作数、begin和end不匹配等。静态语义错误是指分析源程序时可以发现的语言意义上的错误，如加法的两个操作数中一个是整型变量名，而另一个是数组名等。

       二、 lex 和 yacc 简单入门

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

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

1.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/http://www.cnblogs.com/../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。

2.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;
}

3.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手册了，十分详尽。

4.Lex理论

Lex使用正则表达式从输入代码中扫描和匹配字符串。每一个字符串会对应一个动作。
通常动作返回一个标记给后面的剖析器使用，代表被匹配的字符串。每一个正则表达
式代表一个有限状态自动机(FSA)。我们可以用状态和状态间的转换来代表一个(FSA)。
其中包括一个开始状态以及一个或多个结束状态或接受状态。

我们以上文《Lex和Yacc应用方法(一).初识Lex》第一个例子详细说明：

exfirst.l

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

这里使用一相对简单的输入文件 file.txt

i=1.344+39;
bcd=4%9-333

我们假定，
Lex 系统创建一动态列表：内容+规则+状态
Lex 状态：1 接受 2 结束

接受表示该元素可以做为模式匹配
结束表示该元素已完成模式匹配

读入“i”
   [查找元素]查找相邻且状态为1的元素，无元素，
       [匹配规则]D，
       [新增列表<元素1>并置数据](存在则覆盖)状态为1，规则为D，内容为"i"。
       [操作顺序符] 1
读入“=”
   [查找元素]查找相邻且状态为1的元素，“i=”寻找匹配规则，无规则
       [置上一元素]<元素1>状态为2
       [匹配规则]F，
       [新增列表<元素2>并置数据](存在则覆盖)状态为1，规则为F，内容为"="
       [操作顺序符] 2
读入“1”，
   [查找元素]查找相邻且状态为1的元素，“=1”寻找匹配规则，无规则
       [置上一元素]<元素2>状态为2
       [匹配规则]B,
       [新增列表<元素3>并置数据](存在则覆盖)状态为1，规则为B，内容为"1"
       [操作顺序符] 3
读入“.”
   [查找元素]查找相邻且状态为1的元素，“1.”寻找匹配规则，无规则，但有潜在规则C
       [匹配规则]F,
       [新增列表<元素4>并置数据](存在则覆盖)状态为1，规则为F，内容为"."
       [置上一元素]<元素3>状态为1
       [操作顺序符] 4
读入“3”
   [查找元素]查找相邻且状态为1的元素，“1.3”寻找匹配规则，有规则       
       [置起始元素]状态为1，规则为C，内容为"1.3"
       [操作顺序符] 3 组合元素的起始操作符
读入“4”         
   [查找元素]查找相邻且状态为1的元素，“1.34”寻找匹配规则，有规则
       [置起始元素]状态为1，规则为C，内容为"1.34"
       [操作顺序符] 3 组合元素的起始操作符
读入“4”         
   [查找元素]查找相邻且状态为1的元素，“1.344”寻找匹配规则，有规则
       [置起始元素]状态为1，规则为C，内容为"1.344"
       [操作顺序符] 3 组合元素的起始操作符
读入“+”         
   [查找元素]查找相邻且状态为1的元素，“1.344+”寻找匹配规则，无规则
      [匹配规则]E,
      [新增列表<元素4>并置数据](存在则覆盖)状态为1，规则为E，内容为"+"
      [置上一元素]<元素3>状态为2
      [操作顺序符] 4

...

最后解析结果为
           内容    规则    状态
<元素1>    i       D       2
<元素2>    =       F       2
<元素3>    1.344   C       2
<元素4>    +       E       2
...

上面列出的算法是仅属于个人的分析，是相对直观且便于理解的，也可以参照这个算法
用C语言模拟出lex的效果。不过真正的Lex算法肯定是更为复杂的理论体系，这个没有
接触过，有兴趣可以参看相关资料。

5.关于Lex的一些综述

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

6、yacc的BNF文件

    个人认为lex理论比较容易理解的，yacc要复杂一些。
    我们先从yacc的文法说起。yacc文法采用BNF(Backus-Naur Form)的变量规则描
述。BNF文法最初由John Backus和Peter Naur发明，并且用于描述Algol60语言。BNF
能够用于表达上下文无关的语言。现代程序语言大多数结构能够用BNF来描述。
   
    举个加减乘除例子来说明：
   
    1+2/3+4*6-3
   
    BNF文法：
                          优先级
                         
    E = num      规约a    0
    E = E / E    规约b    1
    E = E * E    规约c    1
    E = E + E    规约d    2
    E = E - E    规约e    2
   
    这里像（E表达式）这样出现在左边的结构叫做非终结符(nonterminal)。像（num
标识符）这样的结构叫终结符（terminal，读了后面内容就会发现，其实是由lex返回
的标记），它们只出现在右边。
   

    我们将 “1+2/3+4*6-3-2”逐个字符移进堆栈，如下所示：
   
           .1+2/3+4*6-3    
    1      1.+2/3+4*6-3     移进
    2      E.+2/3+4*6-3     规约a
    3      E+.2/3+4*6-3     移进
    4      E+2./3+4*6-3     移进
    5      E+E./3+4*6-3     规约a
    6      E+E/.3+4*6-3     移进
    7      E+E/3.+4*6-3     移进
    8      E+E/E.+4*6-3     规约a
    9      E+E/E+.4*6-3     移进
    10     E+E/E+4.*6-3     移进
    11     E+E/E+E.*6-3     规约a
    12     E+E/E+E*.6-3     移进
    13     E+E/E+E*6.-3     移进
    14     E+E/E+E*E.-3     规约a
    15     E+E/E+E*E-.3     移进
    16     E+E/E+E*E-3.     移进
    17     E+E/E+E*E-E.     规约a
   
    18     E+E+E*E-E.       规约b
    19     E+E+E-E.         规约c
    20     E+E-E.           规约d
    21     E-E.             规约d
    22     E.               规约e
   
    我们在实际运算操作中是把一个表达式逐步简化成一个非终结符。称之为“自底
向上”或者“移进归约”的分析法。
    点左面的结构在堆栈中，而点右面的是剩余的输入信息。我们以把标记移入堆栈开
始。当堆栈顶部和右式要求的记号匹配时，我们就用左式取代所匹配的标记。概念上，
匹配右式的标记被弹出堆栈，而左式被压入堆栈。我们把所匹配的标记认为是一个句柄，
而我们所做的就是把句柄向左式归约。这个过程一直持续到把所有输入都压入堆栈中，
而最终堆栈中只剩下最初的非终结符。
    在第1步中我们把1压入堆栈中。第2步对应规则a，把1转换成E。然后继续压入和归
约，直到第5步。此时堆栈中剩下E+E，按照规则d，可以进行E=E+E的合并，然而输入信
息并没有结束，这就产生了“移进-归约”冲突(shift-reduce conflict)。在yacc中产
生这种冲突时，会继续移进。
    在第17步，E+E/E，即可以采用E+E规则d，也可以采用E/E规则b，如果使用E=E+E
规约，显然从算法角度是错误的，这就有了运算符的优先级概念。这种情况称为“归约
-归约”冲突(reduce-reduce conflict)。此时yacc会采用第一条规则，即E=E/E。这
个内容会在后面的实例做进一步深化。

7、十分典型的利用lex和yacc模拟的简单+-*/计算器。

    A.示例

   最有效的方法是示例学习，这样首先给出全部示例文件。
   lex文件：lexya_a.l
  
   %{
   #include <stdlib.h>
   void yyerror(char *);
   #include "lexya_a.tab.h"
   %}
   %%
   [0-9]+       { yylval = atoi(yytext); return INTEGER; }
   [-+*/\n]     return *yytext;
   [\t]         ;/* 去除空格 */
   .            yyerror("无效字符");
   %%
   int yywrap(void) {
   return 1;
   }
  
   yacc文件：lexya_a.y
  
   %{
   #include <stdlib.h>
   int yylex(void);
   void yyerror(char *);
   %}
   %token INTEGER
   %left '+' '-'
   %left '*' '/'
   %%
   program:
   program expr '\n' { printf("%d\n", $2); }
   |
   ;
   expr:
   INTEGER { $$ = $1; }
   | expr '*' expr { $$ = $1 * $3; }
   | expr '/' expr { $$ = $1 / $3; }
   | expr '+' expr { $$ = $1 + $3; }
   | expr '-' expr { $$ = $1 - $3; }
   ;
   %%
   void yyerror(char *s) {
   printf("%s\n", s);
   }
   int main(void) {
   yyparse();
   return 0;
   }
   进行编译：
   bison -d lexya_a.y
   lex lexya_a.l
   cc -o parser  lex. yy.c   lexya_a.tab.c  -ll
   运行：
   ./parser
   输入计算式，回车会显示运算结果
  
   如：
   1+2*5+10/5
   13
   9+8/3
   11
   10+2-2/2-2*5
   1
  
   这里有两个文件lexya_a.y和lexya_a.l。lexya_a.y是yacc文件，bison -d lexya_a.y
编译后会产生 lexya_a.tab.c lexya_a.tab.h。lex文件lexya_a.l中头声明已包括了
lexya_a.tab.h。这两个文件是典型的互相协作的示例。
   
   
    B.分析
   
    (1)定义段和预定义标记部分
   
    yacc文件定义与lex十分相似，分别以%{ }% %% %%分界。
   
   %{
   #include <stdlib.h>
   int yylex(void);
   void yyerror(char *);
   %}
  
   这一段十分容易理解，只是头文件一些引用说明。称为“定义”段。  
  
   %}
   %token INTEGER
   %left '+' '-'
   %left '*' '/'
   %%
  
   %}和%%这一段可以看作预定义标记部分。%token INTEGER 定义声明了一个标记。
当我们编译后，它会在lexya_a.tab.c中生成一个剖析器，同时会在lexya_a.tab.h
产生包含信息：
    # define INTEGER 257
    其中0-255的之间的标记值约定为字符值，是系统保留的后定义的token。
   
    lexya_a.tab.h其它部分是默认生成的，与token INTEGER无关。
    # ifndef YYSTYPE
    # define YYSTYPE int
    # define YYSTYPE_IS_TRIVIAL 1
    # endif
   
    extern YYSTYPE yylval;
   
    lex文件需要包含这个头文件，并且使用其中对标记值的定义。为了获得标记，yacc
会调用yylex。yylex的返回值类型是整型，可以用于返回标记。而在yylval变量中保
存着与返回的标记相对应的值。

    yacc在内部维护着两个堆栈，一个分析栈和一个内容栈。分析栈中保存着终结符和
非终结符，并且记录了当前剖析状态。而内容栈是一个YYSTYPE类型的元素数组，对于分
析栈中的每一个元素都保存着一个对应的值。例如，当yylex返回一个INTEGER标记时，
把这个标记移入分析栈。同时，相应的yacc值将会被移入内容栈中。分析栈和内容栈的
内容总是同步的，因此从栈中找到对应的标记值是很容易的。
   
    比如lex文件中下面这一段：
   [0-9]+       { yylval = atoi(yytext); return INTEGER; }
  
    这是将把整数的值保存在yylval中，同时向yacc返回标记INTEGER。即内容栈存在
了整数的值，对应的分析栈就为INTEGER标记了。yylval类型由YYSTYPE决定，由于它的
默认类型是整型，所以在这个例子中程序运行正常。

    lex文件还有一段：
    [-+*/\n]     return *yytext;
    这里显然只是向yacc的分析栈返回运算符标记，系统保留的0-255此时便有了作用，
内容栈为空。把“-”放在第一位是防止正则表达式发现类似a-z的歧义。
   
    再看下面的：
   
    %left '+' '-'
    %left '*' '/'

    %left 表示左结合，%right 表示右结合。最后列出的定义拥有最高的优先权。因
此乘法和除法拥有比加法和减法更高的优先权。+ - * / 所有这四个算术符都是左结合
的。运用这个简单的技术，我们可以消除文法的歧义。

    注：关于结合性，各运算符的结合性分为两种，即左结合性(自左至右)和右结合性
(自右至左)。例如算术运算符的结合性是自左至右，即先左后右。如有表达式x-y+z则y
应先与“-”号结合， 执行x-y运算，然后再执行+z的运算。这种自左至右的结合方向
就称为“左结合性”。而自右至左的结合方向称为“右结合性”。 最典型的右结合性运
算符是赋值运算符。如x=y=z,由于“=”的右结合性，应先执行y=z再执行x=(y=z)运算。
   
    (2)规则部分
   
   %%
   program:
   program expr '\n' { printf("%d\n", $2); }
   |
   ;
    expr:
   INTEGER { $$ = $1; }
   | expr '*' expr { $$ = $1 * $3; }
   | expr '/' expr { $$ = $1 / $3; }
   | expr '+' expr { $$ = $1 + $3; }
   | expr '-' expr { $$ = $1 - $3; }
   ;
   %%
  
   这个规则乍看起来的确有点晕，关键一点就是要理解yacc的递归解析方式。
  
   program和expr是规则标记，但是作为一个整体描述表达式。
  
   先看expr，可以由单个INTEGER值组成，也可以有多个INTERGER和运算符组合组
成。
    以表达式“1+4/2*3-0”为例，1 4 2 3 都是expr，就是expr+expr/expr*expr-expr
说到底最后还是个expr。递归思想正好与之相反，逆推下去会发现expr这个规则标记
能表示所有的数值运算表达式。

    了解了expr后，再看program，首先program可以为空，也可以用单单的expr加下
“\n”回车符组成，结合起来看program定义的就是多个表达式组成的文件内容。
   
    回过头，创建如下文件input：
   
   [root@localhost yacc]# cat input
   1+5/5+4*5
   3+9+2*10-9
   2/2
   3-9
  
   运行则结果如下：
   [root@localhost yacc]# ./parser < input
   22
   23
   1
   -6
  
   粗略有了概念之后，再看lex如何执行相应的行为。
  
    以 expr: expr '+' expr { $$ = $1 + $3; }为例：
    在分析栈中我们其实用左式替代了右式。在本例中，我们弹出“ expr '+' expr ”
然后压入“expr”。我们通过弹出三个成员，压入一个成员来缩小堆栈。在我们的代码中
可以看到用相对地址访问内容栈中的值。如$1，$2，这样都是yacc预定义可以直接使用的
标记。“$1”代表右式中的第一个成员，“$2”代表第二个，后面的以此类推。“$$”
表示缩小后的堆栈顶部。在上面的动作中，把对应两个表达式的值相加，弹出内容栈中的三
个成员，然后把得到的和压入堆栈中。这样，保持分析栈和内容栈中的内容依然同步。

三、 使用Lex 和 Yacc 开发C编译器

(1) 从网站： 下载C语言的语法文件：
 最新 The ANSI C grammar (Yacc and Lex) 
 http://www.quut.com/c/ANSI-C-grammar-l-1998.html
 http://www.quut.com/c/ANSI-C-grammar-y-1998.html

(2) 编译词法文件：> lex c.l

(3) 编译语法文件：> yacc -dv c.y说明：-d：产生头文件y.tab.h，-v：产生分析表y.output。针对else产生的移进规约冲突，采用了yacc的默认动作“移进”解决。

(4) 编译语法分析器：

 > cc lex.yy.c y.tab.c -ll

(5) 测试：编写测试程序test.c

#include "stdio.h"

int main(){
    int a = 0;
}

运行：> ./a.out < test.c结果如下：

include "stdio.h"

 没看到预期到效果。

 存在一个移进/规约冲突。以bison的"-v"选项生成状态机描述文件（《Lex与Yacc》很好地描述了如何理解此文件）。
[kenny@kenny ser-0.9.4]$ bison -v c.y
cfg.y: conflicts: 1 shift/reduce
查看状态机描述文件c.output可知如下文法片段存在典型的“if-then-else”冲突：
stm:        cmd
        |    if_cmd
        |    LBRACE actions RBRACE
    ;
if_cmd:        IF exp stm
        |    IF exp stm ELSE stm
    ;

进来解决这些冲突, 除非有其它的操作符优先级的指导。冲突存在的原因是由于语法本身有歧义: 任一种简单的if语句嵌套的分析都是合法的. 已经建立的惯例是通过将else从句依附到最里面的if语句来解决歧义; 这就是Bison为什么选择移进而不是归约的原因。”

“Bison被设计成选择移以下这段话摘自Bison info手册：

“移进/规约”冲突问题解决方法：

 有以下几个解决此冲突的办法（参考Bison info手册以及《Lex与Yacc》）：
(1)改写if语句语法，优点是彻底，缺点是导致语法复杂化。
(2)为冲突的两规则指定优先级以隐藏这个你知道并理解的冲突，但是特别要注意不要隐藏其他任何冲突。
我按照办法2这样做：
在c.y序幕部分加如下两个的操作符：
%nonassoc LOWER_THAN_ELSE
%nonassoc ELSE
修改不带else分支的那个规则，使其优先级低于带else分支的那个规则：
selection_statement
    : IF '(' expression ')' statement %prec LOWER_THAN_ELSE
        | IF '(' expression ')' statement ELSE statement
    | SWITCH '(' expression ')' statement
    ;

 五、 参考资料

1.编译器知识拾零

2. 草木瓜 Lex和Yacc应用

3.  使用Lex 和 Yacc 开发 C 语言编译器