使用lex&yacc实现一个xml解析器

在开始编写xml解析器之前我们先来简单介绍一下lex ，yacc。

 

Lex:

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]);
%%


lex规则部分具有优先级的概念:
1  Lex会选择最长的字符匹配规则。
2  当存在多个规则同事满足时，这时Lex只会选择第一个规则


(3) 用户子程序部分
最后一个%%后面的内容是用户子程序部分，可以包含用C语言编写的子程序，而这些子
程序可以用在前面的动作中，这样就可以达到简化编程的目的。


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，就停止解析。因此它可以用来解析多个文件。


注意lex库提供一些默认的函数，例如main，yywrap函数等。 当编译时不带-ll选项时，必须自行实现main函数和yywrap等函数。


在linux中假设现在有lex规则文件a.l。运行lex a.l  便自动生成lex.yy.c
 cc -o test lex.yy.c -ll 便生成了可执行程序。注意当编译时不带-ll选项时，必须自行实现main函数和yywrap等函数。

 

Yacc

如同 Lex 一样, 一个 Yacc 程序也用双百分号分为三段。 它们是：声明、语法规则和 C 代码
用 Yacc 来创建一个编译器包括四个步骤：


1 编写一个 .y 的语法文件（同时说明 C 在这里要进行的动作）。
2 编写一个词法分析器来处理输入并将标记传递给解析器。 这可以使用 Lex 来完成。
3 编写一个函数，通过调用 yyparse() 来开始解析。
4 编写错误处理例程（如 yyerror()）。
5 通过yacc工具对.y生代码并编译它。


yacc 必须与lex一起使用，而lex可以单独使用。因为yacc需要使用lex来返回标记。

在linux中假设现在有lex规则文件a.l, a.y。

运行lex a.l  便自动生成lex.yy.c

运行 yacc -d a.y  便自动生成了y.tab.c  y.tab.h   -d表示生成头文件
 cc -o test lex.yy.c y.tab.c -ll -ld 便生成了可执行程序 

同样 yacc库也提供了一些默认的函数 例如main，yyerror等，如果不连接yacc库，需要自行实现这些函数。

 

 

yacc的一些细节 

1、嵌入式动作在规则内变成一个符号，所以它的值（$$）像任何其他的符号一样对于规则末端的动作都是可以用的。

如：

thing: A {$$=17;} B C

{printf(%d"",$2);}

在使用嵌入式动作时，如果正在使用“%union”和有类型的符号值，则在引用动作值时就得将值放入尖括号内，例如将它放入嵌入式动作时的$<type>$,以及在规则末端动作中引用它的$<type>3。

2、明确的符号类型

通过在￥和符号数字之间使用或在2个$之间的尖括号内插入类型名，如$<xxx>3或$<xxx>$，YACC允许为符号值引用声明一个明确的类型。3、标记值

YACC语法分析程序中每个符号都有一个相关的值。在语法分析程序中，一定要声明所有具有值的标记的值类型。

%union声明标识符号值的所有可能的C类型。将拷贝到输出文件的YYSTYPE类型的C联合类型声明中。

4、yyerror()提供错误报告例程

5、YYABORT使得语法分析例程yyparse()以一个非零值立即返回，显示失败

6、YYACCEPT：yyparse()以一个零值返回，显示成功。

7、yyparse()语法分析程序的入口点，成功返回零，失败返回非零

8、YACC的冲突，YACC只能向前看一个标记。如下的没有冲突:tgt

start:x B

|y C;

x: A;

y:A;

9、移进/归约冲突

stmt:if '(' cond')' stmt

|if '(' cond ')' stmt ELSE stmt

if (cond) if (cond) stmt ELSE stmt如何理解

1)if (cond){if (cond) stmt ELSE stmt}

2)if (cond){if (cond) stmt }ELSE stmt

设置明显的优先级阻止YACC发布警告

%nonassoc LOWER_THEN_ELSE或%nonassoc THEN

%nonassoc ELSE

ELSE优先级比LOWER_THEN_ELSE高，因为移进优先级必须高于归约优先级

1、继承的属性

属性以标记值开始，即从语法分析树的叶子开始。每次规则被归约时，信息概念性地在语法分析树中上移。并且它的动作根据规则右侧符号值勤合成符号($$)的值。

例如：

declaration:class type namelist;

class: GLOBAL {$$=1;}

|LOCAL {$$=2;}

;

type:REAL {$$=1;}

|INTEGER {$$=2;}

;

namelist:NAME {mksymbol($0,$-1,$1);}

|namelist NAME {mksymbol($0,$-1,$2);}

yacc允许访问它的左侧的内部堆栈上的符号($0,$-1,$-2....),上例中$0指在namelist产生式的符号之前被堆栈的type的值。$0指class。

继承的符号类型必须在动作代码中采用明确的类型提供类型名。

2、文字块

%{

.....

%}

内容被原封不动地拷贝到生成的C源文件中靠近开头的部分。

3、优先级和结合性

结合性：%left左结合,%right右结合,%nonassoc非结合操作

通过声明结合性的顺序决定优先级，声明在后的优先级高

4、左、右递归，左递归更适合于YACC处理

exprlist:exprlist ','expr;

exprlist:expr ','exprlist;

5、规则尾端有明确的优先级：

expr:expr '*' expr

|expr '-' expr

|'-'expr %prec UMINUS;

6、符号类型

YACC在内部将每个值做为包括所有类型的C联合类型来声明。在%union声明中列出所有的类型，YACC将其转变为称为YYSTYPE的联合类型的类型定义。对于值已在动作代码中设置和使用的符号，必须声明它的类型。对非终结符使用%type(如%type<dval> expression)，对标记即终结符使用%token,%left,%right,%nonassoc，(如:%token<dval>REAL)。在使用$$、$1等引用值，YACC会自动使用联合的适当字段。

 

使用lex&yacc实现一个xml解析器

lex & yacc  可以使用的地方特别多，例如语法解析， 设计自定义的编程语言，解析配置文件等等。下面就给出一个简单例子的范例。

假设我们有一套成熟的游戏系统，这套系统服务端跟客户端都通过c编写，通信方式直接采用c  struct + socket 方式。

有一天我们的游戏系统需要扩展给第3方公司使用，而第3方公司采用flash开发客户端，他们要求我们提供给他们的接口都采用标准的xml格式协议。

这时我们就自然会想到要编写一个xml 与c struct相互转换的接口程序。

例如我们有一个接口的c struct定义是这样的：

struct request

{

   int delay;

   int pid;

   int threadid;

  char ip [20];

  int usetime;

}

而我们接收第3方公司开发的协议格式要求如下：

<?xml version="1.0"?>
<request >
 <delay>5</delay>
 <serviceinfo pid="667" threadid="554" ip="192.168.5.55" usetime="77"/>
</request>

这时我们需要将xml 与c stuct进行相互转换，怎么转换呢，我们可以采用配置文件的方式，

配置好每一个要转换的c struct的转换成xml的格式，或xml转换回struct的格式，我们可以设计上面例子要转换的配置文件如下：

<?xml version="1.0"?>
<request >
 <delay>int</delay>
 <serviceinfo pid="int" threadid="int" ip="string" usetime="int"/>
</request>

 

当我们收到一串xml协议时，我们就可以根据我们配置的格式进行每个字段的解析，并按照格式要求转换为c struct。

 

这时我们在编写程序之前就得先自行解析我们每一个xml的结构,为了方便阐述，xml里面的数据类型只支持 int ，string，double

我们采用lex & yacc 来解析xml方式配置的的结构,具体步骤如下：

 

1 先编写好需要的数据结构文件： xmlstruct.h

struct XMLNODEATTR
{
 char * attr_name;           // 属性名字
 char * attr_value;           // 属性的数据类型

 struct XMLNODEATTR* next; //指向下一个属性
} ;
struct XMLNODE
{
 struct XMLNODE* parent;  //指向父节点
 struct XMLNODE* child;   //指向第1个孩子节点
 struct XMLNODE* next;   //指向下一个兄弟节点

 struct XMLNODEATTR* attrs; //指向节点属性
 short isbasenode;  //是否叶子节点 0/否,1/是
 
 char * value_type;  //节点的数据类型，当不是叶子节点时，此字段忽略
 char * node_name; // 节点名
};

2  编写词法分析文件 parsexml.l

%{
#include "y.tab.h"
#include "xmlstruct.h"

%}

%%
"<?xml version=\"1.0\"?>" {
       return XMLHEADER;
        }

"int" |
"string" |
"double" { yylval.szname=strdup(yytext); return TYPE; }

[A-Za-z][A-Za-z0-9]* { yylval.szname=strdup(yytext); return NAME;}

"</"  |
"/>"  {  yylval.szname=strdup(yytext); return NODEENDTAG; }

"=" |
"<" |
">"    { return yytext[0]; }

[ \t] ;  /* ignore white space */
\n     ;
\"      ;
. { yyerror("unknown char"); return 0; }
%%

 

2  编写语法分析文件 parsexml.y

 

%{
#include "xmlstruct.h"
#include "stdio.h"

struct XMLNODE *pCurNode=NULL;
void printXml(struct XMLNODE *pCurrentXml);

%}

%union {
 char * szname;
 struct XMLNODEATTR * node_attr;
 struct XMLNODE * xml_node;
}

%token <szname> NAME
%token <szname> TYPE
%token <szname> NODEENDTAG
%token XMLHEADER

%type <node_attr> attr
%type <node_attr> attr_list
%type <xml_node> node_begin
%type <szname> node_end
%type <xml_node> node_novalue
%type <xml_node> node
%type <xml_node> node_list

%%

xml: xmlhead node   { printf("xml\n");  printXml($2); }
 ;

xmlhead: XMLHEADER    { printf("xmlheader\n"); }
 ;

node_list: node          { $$=$1  ;   printf("node_list\n"); }
 |  node  node_list  { $1->next=$2;  $$=$1; printf("node_list1\n"); }
 ;

node : node_begin TYPE node_end             {   $$=$1  ;
            $$->isbasenode=1;
            $$->value_type=strdup($2);
            printf("node1 type=%s\n", $2);
           }

 |      node_novalue      { $$=$1  ;   printf("node2\n"); }

 |      node_begin node_list node_end  { $$=$1  ; $$->child=$2;
            pCurNode=$2;  while(pCurNode) {pCurNode->parent=$1;pCurNode=pCurNode->next;}
            printf("node3\n");
           }
 ;

node_novalue: '<' NAME attr_list NODEENDTAG {
            $$=(struct XMLNODE *) malloc(sizeof(struct XMLNODE)) ;
            $$->parent=NULL;$$->child=NULL;$$->next=NULL;$$->attrs=NULL;$$->isbasenode=0;$$->value_type=NULL;
            $$->node_name=strdup($2) ;
            $$->attrs=$3 ;
            $$->isbasenode=1;
            $$->value_type=NULL;
            printf("node_novalue nodename=%s\n", $2);
           }
 ;

node_begin: '<' NAME attr_list '>'  {   $$=(struct XMLNODE *) malloc(sizeof(struct XMLNODE)) ;
          $$->parent=NULL;$$->child=NULL;$$->next=NULL;$$->attrs=NULL;$$->isbasenode=0;$$->value_type=NULL;
          $$->node_name=strdup($2) ;
          $$->attrs=$3 ;
          printf("node begin1=%s\n", $2);
         }

 |       '<' NAME '>'   {
          $$=(struct XMLNODE *) malloc(sizeof(struct XMLNODE)) ;
          $$->parent=NULL;$$->child=NULL;$$->next=NULL;$$->attrs=NULL;$$->isbasenode=0;$$->value_type=NULL;
          $$->node_name=strdup($2) ;
          printf("node begin2=%s\n", $2);
         }
 ;

node_end:  NODEENDTAG NAME '>'    { $$=strdup($2);  printf("node end=%s\n", $2); }
 ;

attr_list: attr          { $$=$1  ;  printf("attr name=%s,type=%s\n",$1->attr_name,$1->attr_value); }
 |  attr attr_list   { $1->next=$2;  $$=$1;  printf("attr1\n"); }
 ;

attr: NAME '=' TYPE  { $$=(struct XMLNODEATTR *) malloc(sizeof(struct XMLNODEATTR));  $$->next=NULL;
       $$->attr_name=strdup($1); $$->attr_value=strdup($3);
       printf("%s = %s\n", $1,$3);
       }
 ;

%%

void printXml(struct XMLNODE *pCurrentXml)
{
 if(NULL==pCurrentXml)
 {
  printf("NULL XML! \n");
  return ;
 }

 printf("Node:%p, name=%s,isbasenode=%d ",pCurrentXml,
         pCurrentXml->node_name,pCurrentXml->isbasenode );
 if(pCurrentXml->value_type !=NULL)
 {
  printf("type=%s",pCurrentXml->value_type);
 }
 printf("\n");

 if(pCurrentXml->attrs !=NULL)
 {
  struct XMLNODEATTR* pAttrNext=pCurrentXml->attrs; 
  printf("Node:name=%s,Attr:",pCurrentXml->node_name);   
  while( pAttrNext !=NULL )
  {
   printf("%s=%s,",pAttrNext->attr_name,pAttrNext->attr_value);
   pAttrNext=pAttrNext->next;
  }
  printf("\n");
 }
 
 if(pCurrentXml->child !=NULL)
 {
  struct XMLNODE *pNode=pCurrentXml->child;
  while( pNode !=NULL )
  {
   printXml(pNode);
   pNode=pNode->next;
  }
 }

}

3 编写main ： main.c

#include <stdio.h>
extern int yyparse();
extern FILE *yyin;

int nCount=1;
int yywrap()
{
 return 1;
}
void yyerror(char *s)
{
  fprintf(stderr, "%s\n", s);
}
int main()
{

 yyin = fopen("test.xml", "r");
 if (yyin == NULL)
 {
  printf("open file error!\n");
 }
 else
 {
  yyparse();
 }
 return 0;
}

 

lex  parsexml.l  生成 lex.yy.c

yacc -d parsexml.y 生成 y.tab.h y.tab.c

cc -o test lex.yy.c y.tab.c main.c  

找一个xml结构体放入test.xml    

运行test  无论xml多么复杂，嵌套还非嵌套都会将xml的每一个节点，节点的属性名，属性类型，节点的类型 等结构准确无误地打印输出。