ser Generator使用说明

Parser Generator的使用说明

最近1个星期,大致学习了一下lex,虽然在windows系统上它并没有我所期望的强大,在调试和编写代码都遇到了不少困难,但是总体来说Parser Generator还是让我体会到了lex编程的快捷, 为了自己加深印象把一些参考资料和认识总结了一下.

<!--[if !supportLists]-->1.     <!--[endif]-->parser generator是什么?

它是一款在windows下编写lex/yacc程序的工具.可以到

http://www.bumblebeesoftware.com/downloads.htm

下载

<!--[if !supportLists]-->2.     <!--[endif]-->parser generator的使用方法

这里只以vc6.0为例,首先打开parser generator编辑器,选择Project->LibBuilder

在LibBuilder对话框中选中Visual C++(32-bit),按属性键Properties后确以下设置

Script file name                        ./Cpp/Script/msvc32.lbs

Name                                    Visual C++(32-bit)

Directory                               msvc32

Compiler Version                         Version 6

Unicode                                  True

Treat wchar_t as Built-in Type            False

Compiler Bin Directory             安装路径/Microsoft Visual Studio/Vc98/bin

Compiler Bin Directory(2) 安装路径/Microsoft Visual Studio/Common/MSDev98/bin

Compiler Include Directory      安装路径/Microsoft Visual Studio/Vc98/include

Compiler Include Directory(2)               无

Compiler Library Directory          安装路径/Microsoft Visual Studio/Vc98/lib

Compiler Library Directory(2)               无

Libraries下的库文件全部选中后ok

LibBuilder对话框->Build(编译过程可能几分钟)

编译完成后我们就可以使用parser generator编写lex或是yacc程序了

Project->ParserWizard

Step1 工程设定(一点需要注意语言可以选择c或是c++或java)

Step2 工程设定(默认创建带main函数的yacc文件和lex文件)

Step3 yacc文件设定

Step4 lex文件设定

Lex和yacc的语法参考http://www.ibm.com/developerworks/cn/linux/sdk/lex/

编辑好代码后Project->RebBuild All在你创建好的工程下自动生成Step1选定语言的文件(.h/..c/.cpp/.java)

之后在vc6.0加入如下设置

Tool->Option-> directory

Bin file :

安装目录/PARSER GENERATOR 2/BIN

Include file:

安装目录/PARSER GENERATOR 2/CPP/INCLUDE

Library file

安装目录/PARSER GENERATOR 2/CPP/LIB/MSVC32

Soure file

安装目录/PARSER GENERATOR 2/CPP/SOURCE

创建vc6.0工程

将生成文件复制到vc6.0创建工程下

Source files和Header Files中加入生成文件(.h/.c/.cpp)

在工程设定中Project->Settings For box选中win32 debug

c/c++ ->Category选中General ->Preprocessor Definitions加入YYDEBUG

在工程Project设定Project->Settings For box中选中all

link -> Category选中General->Object/Library Modules中加入yld.lib

这里需要注意的是yld.lib为parser generator的DUBUG单线程版本,对于vc的控制台程序是可以的,如果使用了MFC或是Windows applications程序则需要对应下表追加

如果使用了动态库版本需要在程序运行环境中追加DLL的地址

安装目录/PARSER GENERATOR 2/CPP/LIB/MSVC32

如果需要链接yacc或是lex的dll.在Preprocessor Definitions下加入YYDLL.

这样就可以使用vc6.0对lex生成文件进行编译了

3、PG2的默认输入为FILE *，怎样转化为char *?
PG2提供了两种方法，一是重定义yyinput，二是重定义yygetchar。实际使用中后者较方便，因为yyinput除了调用yygetchar之外还需要负责lineno变量的增加。
yygetchar通常这样定义
int yygetchar(void)
{
     if (* inputstring=='/0')
     {
           return -1;
     }
     return (unsigned char) * inputstring++;
}
唯一要注意的就是读到char *的末尾时要返回一个-1代表EOF，使得yyinput停止。（感谢luocong的提醒）。

4、同理，yyoutput怎样从FILE *转化为char *？
直接对yytext操作既可，yytext就是char[]。

3,4说明转自

http://blog.csdn.net/tankaiha/archive/2005/12/13/551457.aspx

总体来说lex/yacc比起自己编写分析程序要快的多,但是不足点就是错误的调试会非常困难,需要把.lex/.l和.yacc/.y文件加入工程调试,每次变更都需要重新编译parser generator工程,然后再次粘贴,lex的语法熟练度可能决定了效率,新手基于模型为基础进行研究逐步认识parser generator是最佳的学习方法,

Lex的自带例程在/Parser Generator 2/Cpp/Examples 下,在这对其中的class(四则计算器)做下简单说明

lexer.l文件

%{              //%{ %}中的c代码将被复制到.cpp文件中

#include <stdlib.h>

#include <math.h>

#include <assert.h>

#include "parser.h"//自动生成头文件必须包含

%}

// include file

%include {              //%include 将{}里的代码复制到对应的.h文件中,这里声明calc_parser和

class calc_parser;   // symboltable是为在下面calc_lexer::create函数能够找到使用类型的提前

class symboltable;  //声明

}

// lexical analyser name

%name calc_lexer         //%name指定继承自lexer的类名{}中为类成员声明,类的声明将被解//释到.h文件中

// class definition

{

// Attributes

protected:

        symboltable* m_symboltable;             // the symbol table

// Operations

public:

        int create(calc_parser* parser, symboltable* symboltable);

        // attribute commands

        double number() const;

        symbol* id() const;

}

// constructor

{

        // do nothing

}

// macros

exponent        ([Ee][+-]?[0-9]+)  //科学计算方定义为exponent

%%

%{

// extract yylval for use later on in actions

YYSTYPE& yylval = *(YYSTYPE*)yyparserptr->yylvalptr;//指定yylval值的类型

%}

// 对于数字的规则处理 |表示或,指|下一个算式使用的规则与第一个相同{}中是规则执行代码

[0-9]+"."[0-9]*{exponent}?      |

"."[0-9]+{exponent}?            |

[0-9]+{exponent}?                       { yylval.value = number(); return NUMBER; }

//对于3角函数的规则处理

"sin"                                           { return SIN; }

"cos"                                           { return COS; }

"tan"                                           { return TAN; }

// 对于变量的规则处理

[a-zA-Z_][a-zA-Z0-9_]*          { yylval.symbol = id(); return ID; }

//对于符号的规则处理

"="                                                     { return '='; }

"+"                                                     { return '+'; }

"-"                                                     { return '-'; }

"*"                                                     { return '*'; }

"/"                                                     { return '/'; }

"("                                                     { return '('; }

")"                                                     { return ')'; }

// 对于特殊符号的处理

[ /t]                                           { /* do nothing */ }

/n                                                      { return '/n'; }

.                                                       { printf("invalid character '0x%02x'/n", (unsigned int)yytext[0]); }

%%

/

// 以下都是对成员函数的实现,将被复制到.cpp文件中

int calc_lexer::create(calc_parser* parser, symboltable* symboltable)

{

        assert(parser != NULL);

        assert(symboltable != NULL);

        m_symboltable = symboltable;

        return yycreate(parser);

}

/

// calc_lexer attribute commands

double calc_lexer::number() const

{

        errno = 0;              // clear error flag

        char* endp;

        double d = strtod(yytext, &endp);

        if ((d == +HUGE_VAL || d == -HUGE_VAL) && errno == ERANGE) {

                printf("number too big/n");

        }

        return d;

}

symbol* calc_lexer::id() const

{

        symbol* p = m_symboltable->install(yytext);

        return p;

}//lexer.l end

parser.y文件

%{                      //%{ %}中的c代码将被复制到.cpp文件中

#include <math.h>

%}

// include file

%include {              //%include 将{}里的代码复制到对应的.h文件中,这里声明symbol

 // 是为在下面calc_parser:: assign函数能够找到使用类型的提前

 //声明

// forward references

class symbol;

}

//%union表示使用联合体声明yytest的类型可能有2种,也就是lex返回的标记的值的类型(每//一个标记都会有一个值)

%union {

        symbol* symbol;

        double value;

}

// nonterminals

%type <value> expr  //%type是声明变量expr为double类型,这里要注意的是<>声明的类型必//须是在%union中定义的变量

//这里要注意下越是后声明的优先级越高

%right '='          //%right声明=为右结合

%left '+', '-'  //%left 声明+ -为左结合

%left '*', '/'        //%left 声明* /为左结合

%right UMINUS     //%right声明UMINUS为右结合,此优先级最高

%token <value> NUMBER //%token声明标记NUMBER和其类型,与%type注意点一样

%token <symbol> ID     //声明标记ID的类型,与%type注意点一样

// keywords

%token SIN           //声明标记SIN,因为本身的值没有用途所以不对其类型特殊声明

%token COS           //声明标记COS,因为本身的值没有用途所以不对其类型特殊声明

%token TAN           //声明标记TAN,因为本身的值没有用途所以不对其类型特殊声明

// include file

%include {

#include "symbol.h"  //%{ %}中的c代码将被复制到.h文件中

#include "lexer.h"

}

// parser name

%name calc_parser   //%name指定继承自lexer的类名{}中为类成员声明,类的声明将被解

//释到.h文件中

// class definition

{

// 类成员声明

protected:

        symboltable m_symboltable;              // the symbol table

        calc_lexer m_lexer;                             // the lexical analyser

// Operations

public:

        int create();

        // attribute commands

        double assign(symbol* id, double value);

        double divide(double dividend, double divisor);

}

// constructor

{

        // do nothing

}

%%

lines

        : lines line

        | /* empty */

        ;

line

        : expr '/n'                                     { printf("%g/n", (double)$1); }

        | error '/n'                            { yyerrok(); }

        ;

//这里只对expr进行说明$$是冒号左边表达式的值   $1为右边第一个表达式的值

$2为右边第二个表达式的值  $3为右边第三个表达式的值,以此类推.

expr

        : ID '=' expr                           { $$ = assign($1, $3); }//变量保存

        | expr '+' expr                         { $$ = $1 + $3; }

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

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

        | expr '/' expr                         { $$ = divide($1, $3); }//除法判断

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

        | '-' expr %prec UMINUS         { $$ = -$2; }

// %prec说明'-' expr表达式的优先级和UMINUS一样.

        | NUMBER                                        { $$ = $1; }

        | ID                                            { $$ = $1->m_value; }

        | SIN '(' expr ')'                      { $$ = sin($3); }

        | COS '(' expr ')'                      { $$ = cos($3); }

        | TAN '(' expr ')'                      { $$ = tan($3); }

        ;

%%

/

//以下都是对成员函数的实现,将被复制到.cpp文件中

int main(void)

{

        int n = YYEXIT_FAILURE;

        calc_parser parser;

        if (parser.create()) {

                n = parser.yyparse();

        }

        return n;

}

/

// calc_parser commands

int calc_parser::create()

{

        if (!yycreate(&m_lexer)) {

                return 0;

        }

        if (!m_lexer.create(this, &m_symboltable)) {

                return 0;

        }

        return 1;       // success

}

/

// calc_parser attribute commands

double calc_parser::assign(symbol* id, double value)

{

        assert(id != NULL);

        id->m_value = value;

        return id->m_value;

}

double calc_parser::divide(double a, double b)

{

        if (b == 0) {

                printf("division by zero/n");

                yythrowerror();         // causes a syntax error

                return 0;

        }

        else {

                return a / b;

        }

}

更多详细参考可以查看Parser Generator Help帮助文档

以上都是作者的辛苦劳动,转载请注明出处.