我们知道C/C++中存在两种形式的包含文件，一种是用“<>”包含的头文件，一种是“""”包含的头文件，这两种不同的形式表达了头文件的不同的搜索方式。另外还需要注意的是：这两种方式包含的都是磁盘上存在的文件名。也就是说，只要是磁盘上存在的文件名都可以包含的，都是合法的，因而C/C++里面存在的有扩展名的头文件和没有扩展名的头文件都是合法的。并且还需要注意的是C/C++包含的头 文件是可以续行的。

因而总结起来需要做到如下的几件事情：

%{
#include "main.hpp"// 在其中保存了记录头文件所需要的所有数据结构
#include "frame.tab.h"// 由Yacc自动生成的所有标记声明，实际上都是C宏
extern "C"{
int yywrap(void);
int yylex(void);
}
%}
%x _INCLUDE_
%x _INCLUDE_FILE_
%%
"#"[ \t]*"include"      {
                                BEGIN _INCLUDE_;// 进入_INCLUDE_状态
                                yylval.clear();// 需要将所有的Include值初始化
                                return INCLUDE;// 返回INCLUDE标记
                        }
<_INCLUDE_>[\"|<]       {
                                BEGIN _INCLUDE_FILE_;// 进入_INCLUDE_FILE_状态
                                return *yytext; // 返回引号或者尖括号
                        }
<_INCLUDE_FILE_>[^\">]* {
                                yylval.headerfile+=yytext;// 记录头文件字符串
                                return HEADERFILE;// 返回头文件标记
                        }
<_INCLUDE_FILE_>[\"|>]  {
                                BEGIN INITIAL;// 恢复到初始状态，默认状态
                                return *yytext;// 返回引号或者尖括号
                        }
[ \t\n]                 ;// 对于额外的空白都不处理直接扔掉
%%
int yywrap(void)
{
        return 1;// 只处理一个输入文件
}

%{
#include <iostream>
#include "main.hpp"
#define YYDEBUG 0 // 将这个变量设置为1则表示启动Yacc的调试功能
extern "C"{
void yyerror(const char *s);
extern int yylex(void);
}
std::vector<Include> g_Includes;// 用来记录所有的包含声明
Include             *g_pInclude;// 用来保存新增的包含声明信息的指针
%}
%token INCLUDE
%token HEADERFILE
%%
program:/* empty */
        | program include_preprocess // 用这种递归的方式从有限的标记表达出无限的内容
        ;
include_preprocess:
          INCLUDE '<'  HEADERFILE '>'
        {
                // 注意这里的$3，实际上就是上面的标记的第三个的意思
              // 因为yylval被声明为Include结构，参见main.hpp文件
              // 因而每个标记都是Include结构类型。
              g_Includes.push_back(Include());
              g_pInclude = &g_Includes.back();
              g_pInclude->clear();// 初始化
              g_pInclude->headerfile   = $3.headerfile;// 可以证明$3的类型就是Include类型
              g_pInclude->is_angle     = true;// 是尖括号
              g_pInclude->is_quotation = false;// 不是双引号
        }
        | INCLUDE '\"' HEADERFILE '\"'
        {
                // 值得说明的是：上面的include_preprocess用$表示，
              // 而不是用$0表示。从左向右依次为：
              // include_preprocess        $
              // INCLUDE                   $1
              // '\"'                      $2
              // HEADERFILE                $3
              // '\"'                      $4
              g_Includes.push_back(Include());
              g_pInclude = &g_Includes.back();
              g_pInclude->clear();// 初始化
              g_pInclude->headerfile   = $3.headerfile;
              g_pInclude->is_angle     = false;// 不是尖括号
              g_pInclude->is_quotation = true;// 是双引号
        }
        ;
%%
void yyerror(const char *s)
{
        std::cerr<< s << std::endl;
}
int main()
{
#if YYDEBUG
        yydebug = 1;
#endif//YYDEBUG
        yyparse();// 进行语法分析，这个函数是Yacc自动生成的
        // 下面的这行代码仅仅使用了STL的输出算法到标准输出
        std::copy(g_Includes.begin(),g_Includes.end(),std::ostream_iterator<Include>(std::cout,"\n"));
        return 0;
} 

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <iterator>
// 对于每一个项目最好都用一个独立的数据结构来保存相应的信息
struct Include
{
        void clear();// 设置Include的初始值
        std::string headerfile;// 记录头文件全名（包括路径）
        bool is_quotation;// 是否是双引号""括起来的头文件
        bool is_angle;// 是否是尖括号<>括起来的头文件
        // 下面的这个函数仅仅是用来输出到C++流而准备的
        friend std::ostream&operator<<(std::ostream&s,const Include&I);
};
std::ostream&operator<<(std::ostream&s,const Include&I);
// 下面的这个宏定义用来取消Lex和Yacc默认的YYSTYPE定义，因为默认的YYSTYPE定义
// 仅仅只能够记录整数信息，因此要保存额外的信息必须这样定义宏，可以参见Yacc
// 自动生成的标记头文件frame.tab.h。
#define YYSTYPE Include  

#include "main.hpp"
// 初始化所有的Include信息，避免前后关联
void Include::clear()
{
        headerfile.clear();
        is_quotation = false;
        is_angle = false;
}
// 为了能够方便输出，在这里直接准备好了一个流输出函数
std::ostream&operator<<(std::ostream&s,const Include&I)
{
        if(I.is_angle)
                s << "采用尖括号的" ;
        if(I.is_quotation)
                s << "采用双引号的" ;
        s << "头文件：[" << I.headerfile << "]" ;
        return s;
}

LEX=flex
YACC=bison
CC=g++
a.exe:lex.yy.o frame.tab.o main.o
        $(CC) lex.yy.o frame.tab.o main.o -o a.exe
lex.yy.o:lex.yy.c frame.tab.h main.hpp
        $(CC) -c lex.yy.c
frame.tab.o:frame.tab.c main.hpp
        $(CC) -c frame.tab.c
main.o:main.hpp main.cpp
        $(CC) -c main.cpp
frame.tab.c frame.tab.h:frame.y
        $(YACC) -d frame.y
lex.yy.c:frame.l
        $(LEX) frame.l
clean:
        rm -f *.o *.c *.h 

#include <iostream>
#include <string>
#include <ffmpeg/avformat.h>
#include <ffmpeg/avcodec.h>
#include <ffmpeg/avutils.h>
#include <stdio.h>
#include <stdlib.h>
#include "hello.h"
#include "../hello.h"
#        include "space.h" 

pandaxcl@PANDAXCL-F78E7D /d/work/lex_yacc/chapter06
$ make
flex frame.l
bison -d frame.y
g++ -c lex.yy.c
g++ -c frame.tab.c
g++ -c main.cpp
g++ lex.yy.o frame.tab.o main.o -o a.exe

pandaxcl@PANDAXCL-F78E7D /d/work/lex_yacc/chapter06
$ ./a.exe < sample.cpp
          采用尖括号的头文件：[iostream]
采用尖括号的头文件：[string]
采用尖括号的头文件：[ffmpeg/avformat.h]
采用尖括号的头文件：[ffmpeg/avcodec.h]
采用尖括号的头文件：[ffmpeg/avutils.h]
采用尖括号的头文件：[stdio.h]
采用尖括号的头文件：[stdlib.h]
采用双引号的头文件：[hello.h]
采用双引号的头文件：[../hello.h]
采用双引号的头文件：[space.h]

pandaxcl@PANDAXCL-F78E7D /d/work/lex_yacc/chapter06
$

总的来说，上面的解析C/C++包含预处理信息的时候需要了解如下的概念：

好了，本章中还残留有一些问题故意没有解决，例如：包含文件的续行问题！留个 读者自己思考，可以在本文所讨论的基础上稍微改动一下就可以了。后续的文档正 在努力写出，敬请关注;)