使用flex

Flex如何处理二义性模式：

1、词法分析器匹配输入时匹配尽可能多的字符串

2、如果两个模式都可以匹配的话，匹配在程序中更早出现的模式

上下文相关的记号

flex提供起始状态(start state)的概念，可以动态地开启和关闭针对特定模式的识别，对于处理上述上下文相关的情况比较有用。

Flex词法分析器中的文件IO操作

除非另行制定，否则flex词法分析器总是读取标准输入。

词法分析器总是通过名为yyin的文件句柄读取输入。

[root@typhoeus79 flex2]# more fb2-1.l
%option noyywrap

%{
    #include <string.h>
    int chars = 0;
    int lines = 0;
    int words = 0;
%}
%%
[a-zA-Z]+   { words++; chars += strlen(yytext); }
\n          { lines++; chars++; }
[ \t]       {}
.           { chars++; }

%%

int main(int argc, char**argv)
{
    if(argc>1)
    {
        yyin=fopen(argv[1],"r");

        if(yyin == NULL)
        {
            perror(argv[1]);
            return 1;
        }
    }

    yylex();

    printf("chars=%d,words=%d,lines=%d\n",chars,words,lines);

    return 0;
}

对应的Makefile：
[root@typhoeus79 flex2]# more Makefile
fb2-1:lex.yy.o
        gcc -o fb2-1 lex.yy.o -lfl

lex.yy.o:fb2-1.l
        flex fb2-1.l
        gcc -Wall -c -g lex.yy.c

clean:
        rm -rf lex.yy.* fb2-1

读取多个文件

flex提供yyrestart(f)例程，它使词法分析器读取标准输入输出文件f。

%option noyywrap
%{
#include <string.h>
int totchars = 0;
int totlines = 0;
int totwords = 0;

int chars = 0;
int lines = 0;
int words = 0;

%}
%%

[a-zA-Z]+  { chars += strlen(yytext); words++; }
[ \t]      { }
\n         { lines++; }
.          { chars++; }

%%
int main(int argc, char ** argv)
{
    if(argc<2)
    {
        yylex();
        printf("chars=%d,words=%d,lines=%d\n",chars,words,lines);
        return 0;
    }   

    int i;
    for(i=1; i<argc; i++)
    {
        FILE* f = fopen(argv[i],"r");

        if(f == NULL)
        {
            perror(argv[i]);
            return 1;
        }   

        yyrestart(f);

        yylex();

        totchars += chars;
        totlines += lines;
        totwords += words;

    }   

    printf("totchars=%d,totwords=%d,totlines=%d\n",totchars,totwords,totlines);

    return 0;
}

这个例子打开每个文件，使用yyrestart()把打开的文件作为词法分析器的输入，然后调用yylex()进行词法分析。

Flex词法分析器的IO结构

flex提供三层输入系统

从文件读取和从终端读取存在差异——预读机制

1、从文件读取，可以通过大段的读操作来提高工作效率

2、从终端读取，用户可能一次只输入一行，并且期望每行

flex词法分析器会检查当前其输入是否来自终端并决定使用哪一种读取方式。

flex词法分析器使用YY_BUFFER_STATE的数据结构处理输入，包含一个字符串缓冲区以及一些变量和标记。

可以指向所读取的文件的FILE*，也可以创建一个与文件无关的YY_BUFFER_STATE来分析已经在内存中的字符串。

默认的flex词法分析器的输入行为如下：

YY_BUFFER_STATE  bp;
extern FILE* yyin;

......任何第一次调用词法分析器之前所需要做的事情

if(!yyin) yyin = stdin; 默认输入设备是stdin

bp = yy_create_buffer(yyin, YY_BUF_SIZE); // YY_BUF_SIZE由flex定义，大小通常为16K

yy_switch_to_buffer()
yylex();或者yyparse()或者其他对词法分析器的调用

　　

1、如果yyin没有设置，就把stdin设置给它

2、使用yy_create_buffer创建一个读取yyin的新缓冲区

3、使用yy_switch_to_buffer来让词法分析器从缓冲区读入，接着开始分析

4、当需要读取多个文件时，每打开一个文件就调用yyrestart(fp)，把词法分析器的输入切换到标准输入输出文件fp

其他函数也可以用来创建分析区，包括yy_scan_string(“string”)——分析以空字符串结尾的字符串

和yy_scan_buffer(char *base,size)分析长度确定的数据流

出于最大灵活性的考虑，可以重新定义flex用于读取输入到当前缓冲区的宏：

#define  YY_INPUT(buf,result,max_size)

每当词法分析器的输入缓冲区为空时，调用YY_INPUT，buf是缓冲区，maxsize是缓冲区大小，而result则迎来放置实际读取的长度，如果位于EOF，则result等于0.

flex提供两个在动作代码中比较有用的宏：input()和 unput()

每次input()的调用将返回输入流的下一个字符，可以帮助读取一小段输入而不用定义相应的模式

每次对unput(c)的调用把字符c推回到输入流。

输入管理的三个层次是：

1、设置yyin来读取所需文件

2、创建并使用YY_BUFFER_STATE输入缓冲区

3、重定义YY_INPUT

Flex词法分析器的输出

默认的规则：所有没有被匹配的输入都拷贝到yyout

flex允许在添加%option nodefault，使它不要添加默认的规则

这样输入无法被给定的规则完全匹配时，词法分析器可以报告一个错误。

建议总是使用。

起始状态和嵌套输入文件

例子需求：

处理嵌套的包含文件并且打印它们，在打印的时候每行前加上行号。

这个程序需要维护一个包含嵌套输入文件和行号的堆栈，在每次遇到一个#include时压入当前文件和行号信息，在处理完包含文件后再把它们从堆栈弹出。

起始状态，允许指定在特定时刻哪些模式可以被来用匹配。

在靠近文件顶端的%x 行把IFILE定义为起始状态

可以定义任意多的起始状态

%option noyywrap
%option yylineno
%option nodefault

%x IFILE

%{
    struct bufstack{
        struct bufstack* prev; /*上一个文件信息*/
        YY_BUFFER_STATE bs; /*保持的缓冲区*/

        int lineno; /*保持的行号*/
        char* filename; /*文件名*/
        FILE* f; /*当前的文件句柄*/
    }* curbs = 0;

    char* curfilename;

    int newfile(char *fn);
    int popfile(void);
%}

%%

^"#"[ \t]*include[ \t]*[\"<]    { BEGIN IFILE; }/*第一个模式匹配#include语句,知道遇到文件名之前的双引号或者<号,得到匹配后，词法分析器会切换到IFILE状态*/

<IFILE>[^ \t\n \">]+             {
                                  //匹配文件名，直到遇到引号、空白字符或者行结束符，文件名传递给newfile
                                  //基于函数input读取include后面剩余的部分,当词法分析器从包含文件返回时，
                                  //可以直接从下一行读取
                                  int c; while((c=input()) && c!='\n');

                                  yylineno++;

                                  if(!newfile(yytext))
                                      yyterminate();

                                  BEGIN INITIAL;
                                }               

<IFILE>.|\n                      { //匹配不规范的情况
                                    fprintf(stderr,"%4d bad include file",yylineno);}

<<EOF>>                         {
                                    //特殊匹配模式，匹配输入文件的结束
                                    if(!popfile())
                                       yyterminate();

                                }
^.                              { fprintf(stdout,"%4d %s",yylineno,yytext);}
^\n                             { fprintf(stdout,"%4d %s",yylineno++,yytext);}
\n                              { ECHO; yylineno++; }
.                               { ECHO; }

%%

int main(int argc, char**argv)
{
    if(argc<2)
        fprintf(stderr,"need file name\n.");

    if(newfile(argv[1]))
        yylex();

    return 0;

}

/*
*维护一个bufstack结构的链表,每个bufstack都有一个例程指向前一个bufstack的指针
*/
int newfile(char *fn)
{

    FILE*f = fopen(fn,"r");
    struct bufstack * bs =(struct bufstack*)malloc(sizeof(struct bufstack));

    if(!f)  { perror(fn);return 0;}
    if(!bs) { perror("malloca");exit(1);}

    /*记住当前状态*/
    if(curbs) curbs->lineno = yylineno;
    bs->prev = curbs;

    /*建立当前文件信息*/

    bs->bs = yy_create_buffer(f,YY_BUF_SIZE);
    bs->f = f;
    bs->filename = fn;
    //恢复到前一个缓冲区
    yy_switch_to_buffer(bs->bs);
    curbs = bs;
    yylineno = 1;
    curfilename = fn;
    return 1;
}

int popfile(void)
{
    struct bufstack *bs = curbs;
    struct bufstack *prevbs;

    if(!bs) return 0;

    /*删除当前文件信息*/
    fclose(bs->f);
    yy_delete_buffer(bs->bs);

    /*切回上一个文件*/
    prevbs = bs->prev;
    free(bs);

    if(!prevbs) return 0;

    yy_switch_to_buffer(prevbs->bs);
    curbs = prevbs;
    yylineno = curbs->lineno;
    curfilename = curbs->filename;
    return 1;
}