Lex Yacc (一) 入门

准备工作

  • 文法分析用Flex(Lex):将数据分隔成一个个的标记token (标示符identifiers，关键字keywords，数字numbers, 中括号brackets, 大括号braces, 等等etc.)
  • 语法分析用Bison(Yacc): 在分析标记的时候生成抽象语法树. Bison 将会做掉几乎所有的这些工作, 我们定义好我们的抽象语法树就OK了.
  • 组装用LLVM: 这里我们将遍历我们的抽象语法树，并未每一个节点生成字节/机器码。 这听起来似乎很疯狂，但是这几乎就是最简单的 一步了.
  • sudo apt-get install flex bison
  • flex -h && bison -h 进行测试
  • cd ~/shellscript/bin
  • gedit lexya
  • 将执行后面每一个例子时一连串的命令放进去
  • chmod u+x lexya 就像下面这样
  • ～/shellscript/bin/lexya 针对草木鱼（四五六七）和汇编版本的一个脚本
#! /bin/bash
name=`basename $0`
# 针对草木鱼（四五六七）和汇编版本
if [ $name = "lexya6" ]
then
    bison -d lexya_e.y
    lex -d lexya_e.l
    gcc -g -o graph lex.yy.c lexya_e.tab.c liwei.c
    ./graph < treeinput
elif [ $name = "lexya5" ]
then
    bison -d lexya_e.y
    lex -d lexya_e.l
    gcc -g -o parser lex.yy.c lexya_e.tab.c parser.c
    ./parser < input
elif [ $name = "lexya4" ]
then
    bison -d lexya_e.y
    lex -d lexya_e.l
    gcc -g -o parser lex.yy.c lexya_e.tab.c parser.c
    ./parser < input
elif [ $name = "lexya7" ]
then
    bison -d tree.y
    lex -d tree.l
    gcc -g -c lex.yy.c tree.tab.c parser.c # 有Waring，忽略之 -c 只编译不链接
    ar -rl compile.a *.o
    # 使用静态库文件编译外部程序：
    gcc -g  -o lw main.c compile.a
    # 运行编译显示结果：
    ./lw < input
elif [ $name = "lexyan" ]
then
    make lex
    make yacc
    make
    ./parser < testfile/test.c > test.asm
    # nasm -f elf64 test.asm
    # ld -s -o test test.o
    as --32 -o test.o test.asm
    ld -s -m elf_i386 -o test test.o
fi
  • ln -s lexya lexyan && ln -s lexya lexya4 && ln -s lexya lexya5 && ln -s lexya lexya6 && ln -s lexya lexya7

一个简单的编译器 flex & bison

  • 目标编译代码
int do_math(int a) {
  int x = a * 5 + 3
}
do_math(10)
  • 看起来很简单。它和C非常相似，但是它没有使用分号做语句的分隔，同时你也会注意到我们的语法中没有return语句。这就是你可以自己实现的部分。
  • 现在我们还没有任何机制来验证结果。我们将通过检查我们编译之后LLVM打印出的字节码验证我们程序的正确性。
  • 编写tokens.l 和 parser.y 去github上下载最新版,可能有错，自己读代码改正
  • bison -d -o parser.cpp parser.y
  • flex -o tokens.cpp tokens.l
  • 如果上面没有错误，你可以编译一个简单的main.cpp
#include <iostream>
#include "node.h"
extern NBlock* programBlock;
extern int yyparse();
int main(int argc, char **argv)
{
    yyparse();
    std::cout << programBlock << endl;
    return 0;
}
  • g++ -o parser parser.cpp tokens.cpp main.cpp
  • 具体参见原博客：使用Flex Bison 和LLVM编写自己的编译器

Lex

  • Lex工具是一种词法分析程序生成器，它可以根据词法规则说明书的要求来生成单词识别程序，由该程序识别出输入文本中的各个单词。 一般可以分为<定义部分><规则部分><用户子程序部分>。其中规则部分是必须的，定义和用户子程序部分是任选的。

简单的处理Lex的例子

  • lex.l
%{
#include "stdio.h"
%}
%%
[\t\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 -o a.c lex.l
  • gcc -o a a.c -ll
  • ./a 或者 ./a file.txt
  • file.txt 如下
title
i=1+3.9;
a3=909/6
bcd=4%9-333
  • 对lex.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;
}
  • flex -o a.c lex.l
  • gcc -o a a.c 这里不加 -ll 也可以编译通过
  • ./a 或者 ./a file.txt

-ll 参数选项

  • 当编译时不带-ll选项时，是必须加入main函数和yywrap(yywrap将下后面说明)。

lex 内部预定义变量和函数

  • 变量
  • ytext char * 当前匹配的字符串
  • yleng int 当前匹配的字符串长度
  • yin FILE * lex当前的解析文件，默认为标准输出
  • yout FILE * lex解析后的输出文件，默认为标准输入
  • ylineno int 当前的行数信息
  • 宏
  • CHO #define ECHO fwrite(yytext, yyleng, 1, yyout) 也是未匹配字符的默认动作
  • 函数
  • nt yylex(void) 调用Lex进行词法分析
  • nt yywrap(void) 在文件(或输入)的末尾调用。如果函数的返回值是1，就停止解析。 因此它可以用来解析多个文件。代码可以写在第三段，这样可以解析多个文件。 方法是使用 yyin 文件指针指向不同的文件，直到所有的文件都被解析。最后，yywrap() 可以返回1来表示解析的结束。

Yacc

  • yacc文法采用BNF(Backus-Naur Form)的变量规则描述。
  • 处理 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
  • 我们将 “1+2/3+4*6-3-2”逐个字符移进堆栈，如下所示：
    0      .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。这个内容会在后面的实例做进一步深化

小计算器 lex && yacc 对应于草木鱼 (二)

我的理解

  • 维护者两个栈，内容栈和分析栈
  • 在.l文件的词法分析时，进行一次压栈，例如：[0-9]+ { yylval = atoi(yytext); return INTEGER; }
  • yylval = atoi(yytext); 是将yylval的值压入内容栈
  • return INTEGER; 是将INTEGER对应的数字压入分析栈
  • .l的结果传给了.y文件，yacc再次进行压栈 但是这次压栈不一定是紧接着.l进行的，因为会有移近-移近冲突和移近-规约冲突
  • 例如：expr: INTEGER { $$ = $1; }
  • expr: INTEGER 是将INTEGER从分析栈弹出，压入expr
  • { $$ = $1; } 是将INTEGER 对应的内容栈中的值弹出，并赋值给expr对应的yyval，同时压入内容栈

lexya_a.l

  • 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;
}

lexya_a.y

  • lexya_a.y
%{
#include <stdlib.h>
#include <stdio.h>
int yylex(void);
void yyerror(char *);
%}
%token INTEGER
%left ‘+‘ ‘-‘
%left ‘*‘ ‘/‘
%%
program:
program expr ‘\n‘ { printf("%d\n", $2); }
|
; /* 先理解expr，再递归理解program。首先program可以为空，也可以用单单的expr加下“/n”回车符组成，结合起来看program定义的就是多个表达式组成的文件内容 */
expr:
INTEGER { $$ = $1; }
| expr ‘*‘ expr { $$ = $1 * $3; }
| expr ‘/‘ expr { $$ = $1 / $3; }
| expr ‘+‘ expr { $$ = $1 + $3; }
| expr ‘-‘ expr { $$ = $1 - $3; }
; /* 可以由单个INTEGER值组成，也可以有多个INTERGER和运算符组合组成。以表达式“1+4/2*3-0”为例，1 4 2 3 都是expr，就是expr+expr/expr*expr-expr说到底最后还是个expr。递归思想正好与之相反，逆推下去会发现expr这个规则标记能表示所有的数值运算表达式 */
%%
void yyerror(char *s) {
  printf("%s\n", s);
}
int main(void) {
  yyparse();
  return 0;
}
  • bison -d lexya_a.y 参数 -d 将头文件和.c文件分离
  • lex lexya_a.l
  • cc -o parser *.c
  • ./parser 输入计算式，回车会显示运行结果
  • bison -d lexya_a.y 编译后会产生 lexya_a.tab.c lexya_a.tab.h
  • lex文件lexya_a.l中头声明已包括了 lexya_a.tab.h。这两个文件是典型的互相协作的示例
  • 详细分析见 草木鱼系列的第二篇

yacc 堆栈原理

%}
%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文件需要包含lexya_a.tab.h这个头文件，并且使用其中对标记值的定义。为了获得标记，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 表示右结合。最后列出的定义拥有最高的优先权。因此乘法和除法拥有比加法和减法更高的优先权。+ - * / 所有这四个算术符都是左结合的。运用这个简单的技术，我们可以消除文法的歧义。
  • 粗略有了概念之后，再看lex如何执行相应的行为。
  • 以expr: expr ‘+’ expr { $$ = $1 + $3; }为例
  • 在分析栈中我们其实用左式替代了右式。在本例中，我们弹出“ expr ‘+’ expr ”然后压入“expr”。我们通过弹出三个成员，压入一个成员来缩小堆栈。在我们的代码中可以看到用相对地址访问内容栈中的值。如1，2，这样都是yacc预定义可以直接使用的标记。“1”代表右式中的第一个成员，“2”代表第二个，后面的以此类推。“$$”表示缩小后的堆栈顶部。在上面的动作中，把对应两个表达式的值相加，弹出内容栈中的三个成员，然后把得到的和压入堆栈中。这样，保持分析栈和内容栈中的内容依然同步。
  • program:
  • program expr ‘\n’ { printf(“%d\n”, $2); }
  • 说明每当一行表达式结束时，打印出第二个栈值，即expr的值，完成字符运算。

计算器升级版 ()运算符 变量保存 lex && yacc 对应于草木鱼 (三)

lexya_b.l

  • lexya_b.l
%{
#include <stdlib.h>
#include "lexya_b.tab.h"
void yyerror(char *);
void add_buff(char *);
extern char sBuff[10][20];
extern int iX;
extern int iY;
%}
%%
[a-z]         { yylval = *yytext; add_buff(yytext); return VAR; }
[0-9]+        { yylval = atoi(yytext); add_buff(yytext); return INT; }
[-+()=*/]     { yylval = *yytext; add_buff(yytext); return *yytext; }
[\n]          { yylval = *yytext; iY=0;iX++; return *yytext; }
[\t]          ;
.             yyerror("无效字符");
%%
void add_buff(char * buff) {
    sBuff[iX][iY]=*buff; iY++;
}
int yywrap(void) {
    return 1;
}

lexya_b.y

  • lexya_b.y
%{
#include <stdlib.h>
int yylex(void);
void yyerror(char *);
void debuginfo(char *, int *, char *);
void printinfo();
int sMem[256];
char sBuff[10][20]={0};
int iX=0;
int iY=0;
%}
%token INT VAR
%left ‘+‘ ‘-‘
%left ‘*‘ ‘/‘
%%
program:
program statement
|
;
statement:
expr { printf("%d\n",$1); }
| VAR ‘=‘ expr { debuginfo("=",yyvsp,"110"); sMem[$1]=$3; }
| statement ‘\n‘ { printf("--------------------------------\n\n"); }
;
expr:
INT { debuginfo("INT",yyvsp,"0"); $$ = $1; }
| VAR { debuginfo("VAR",yyvsp,"1"); $$ = sMem[$1]; }
| expr ‘*‘ expr { debuginfo("*",yyvsp,"010"); $$ = $1 * $3; }
| expr ‘/‘ expr { debuginfo("/",yyvsp,"010"); $$ = $1 / $3; }
| expr ‘+‘ expr { debuginfo("+",yyvsp,"010"); $$ = $1 + $3; }
| expr ‘-‘ expr { debuginfo("-",yyvsp,"010"); $$ = $1 - $3; }
| ‘(‘ expr ‘)‘   { debuginfo("()",yyvsp,"101"); $$ = $2; }
;
%%
void debuginfo(char * info,int * vsp, char * mark) {
    printf("--RULE: %s \n", info);
    int i=0;
    int ilen=strlen(mark);
    for(i=0;i>=1-ilen;i--) {
    if(mark[ilen+i-1]==‘1‘)
        printf("$%d %d %c \n", i+ilen, vsp[i], vsp[i]);
    else
        printf("$%d %d \n", i+ilen, vsp[i]);
    }
    printinfo();
}
void printinfo() {
    int i=0;
    printf("--STATEMENT: \n");

    if(iY==0)
        printf("%s \n",sBuff[iX-1]);
    else
        printf("%s \n",sBuff[iX]);
    printf("\n");
}
void yyerror(char *s) {
    printf("%s\n", s);
}
int main(void) {
    yyparse();
    return 0;
}

input

  • input 编译文本
a=4+2*(3-2-1)+6
b=1-10/(6+4)+8
c=a-b
a
b
c
  • bison -d lexya_b.y
  • lex lexya_b.l
  • gcc -g -o parser lex.yy.c lexya_b.tab.c 参数-g是调试选项
  • ./parser < input

上面的计算器升级版分析

  • 这里只是做了一些扩充变化：
  • 1.增加了全局数组sMem来存放变量，不过变量名有限制，只支持单字符。
  • 2.增加了全局数组sBuff存放分析过的语句
  • 3.增加debuginfo打印堆栈信息
  • 4.增加printinfo打印目前的分析语句
  • 要进行内部分析，就需要剖析生成的c文件，对程序(parser)进行跟踪调试。
  • (注：Lex编译时加上d参数，会在程序解释时输出详细的调试信息。如：lex -d lexya_$1.l)
  • 通过本示例再加上实际对lexya_b.tab.c的分析理解，会对lex，yacc理论有更进一步的理解。

增加支持的变量字符数，根据运行结果精读下面的源代码 草木鱼（三）

  • 上面的例子只支持单字符的变量，想支持多字符，需要定义一全局变量如：
struct varIndex
{
    int iValue;
    char sMark[10];
};
  • 同时打印信息加入对变量的显示，下面列出全部文件内容，比较简单，不再附加说明。
  • 下面是需要的四个文件

userdef.h

  • 头文件 userdef.h
typedef struct {
    int iValue; //存放的是标识符b被赋予的数值
    char sMark[10]; //存放的是标识符的字符串
} varIndex;
varIndex strMem[256];

lexya_c.l

  • lexya_c.l
%{
#include <stdlib.h>
#include "userdef.h"
#include "lexya_c.tab.h"

void yyerror(char *);
void add_buff(char *);
void add_var(char *);

extern char sBuff[10][20]; //引用其他地方定义的sBuff，存放源代码
extern int iBuffX; //源代码第几行
extern int iBuffY; //源代码第几列

extern varIndex strMem[256]; //存放标识符
extern int iMaxIndex; //标识符的个数
extern int iCurIndex; //当前指向第几个标识符
%}
%%
[a-zA-Z][a-zA-Z0-9]*         { add_var(yytext); yylval = iCurIndex; add_buff(yytext);   return VAR; }
[0-9]+        { yylval = atoi(yytext); add_buff(yytext); return INT;   }
[-+()=*/]     { yylval = *yytext; add_buff(yytext); return *yytext; }
[\n]          { yylval = *yytext; iBuffY=0;iBuffX++; return *yytext; }
[\t]          ;
.             yyerror("无效字符");
%%
void add_buff(char * buff) {
    strcat(sBuff[iBuffX],buff);
    iBuffY+=strlen(buff);
}
void add_var(char *mark) {
    if(iMaxIndex==0){
        strcpy(strMem[0].sMark,mark);
        iMaxIndex++;
        iCurIndex=0;
        return;
    }
    int i;
    for(i=0;i<=iMaxIndex-1;i++) {
        if(strcmp(strMem[i].sMark,mark)==0) {
            iCurIndex=i;
            return;
        }
    }
    strcpy(strMem[iMaxIndex].sMark,mark);
    iCurIndex=iMaxIndex;
    iMaxIndex++;
}
int yywrap(void) {
    return 1;
}

lexya_c.y

  • lexya_c.y
%{
#include <stdlib.h>
#include "userdef.h"
int yylex(void);
void yyerror(char *);
void debug_info(char *, int *, char *);
void stm_info();

extern varIndex strMem[256];

int iMaxIndex=0;
int iCurIndex=0;

char sBuff[10][20]={0};
int iBuffX=0;
int iBuffY=0;

%}
%token INT VAR //token表示终结符
%left ‘+‘ ‘-‘ //left表示左结合
%left ‘*‘ ‘/‘ //再后面的优先级比较高
%%
program:
program statement
|
;
statement:
expr { printf("%d\n",$1); }
| VAR ‘=‘ expr { debug_info("=",yyvsp,"210"); strMem[$1].iValue=$3;   }
| statement ‘\n‘ { printf("--------------------------------\n\n"); }
;
expr:
INT { debug_info("INT",yyvsp,"0"); $$ = $1;   }
| VAR { debug_info("VAR",yyvsp,"2"); $$ =   strMem[$1].iValue; }
| expr ‘*‘ expr { debug_info("*",yyvsp,"010"); $$ = $1 * $3; }
| expr ‘/‘ expr { debug_info("/",yyvsp,"010"); $$ = $1 / $3; }
| expr ‘+‘ expr { debug_info("+",yyvsp,"010"); $$ = $1 + $3; }
| expr ‘-‘ expr { debug_info("-",yyvsp,"010"); $$ = $1 - $3; }
| ‘(‘ expr ‘)‘   { debug_info("()",yyvsp,"101"); $$ = $2;      }
;
%%
void debug_info(char * info,int * vsp, char * mark) {
    printf("--RULE: %s \n", info);
    int i=0;
    int ilen=strlen(mark);
    for(i=0;i>=1-ilen;i--) {
        switch(mark[ilen+i-1]){
            case ‘1‘:
                printf("$%d %d %c \n", i+ilen, vsp[i], vsp[i]);
                break;
            case ‘0‘:
                printf("$%d %d \n", i+ilen, vsp[i]);
                break;
            case ‘2‘:
                printf("$%d %s %d\n", i+ilen, strMem[vsp[i]].sMark, strMem[vsp[i]].iValue);
                break;
        }
    }
    stm_info();

}
void stm_info() {
    int i=0;
    printf("--STATEMENT: \n");
    if(iBuffY==0)
        printf("%s \n",sBuff[iBuffX-1]);
    else
        printf("%s \n",sBuff[iBuffX]);
    printf("\n");
}
void yyerror(char *s) {
    printf("%s\n", s);
}
int main(void) {
    yyparse();
    return 0;
}

input

  • input
aa=4+2*(3-2-1)+6
bb=1-10/(6+4)+8
cd=aa-bb
aa
bb
cd
  • bison -d lexya_c.y
  • lex -d lexya_c.l //-d是打印调试信息
  • gcc -g -o parser lex.yy.c lexya_c.tab.c //参数-g是调试选项，这里可能会报Warning
  • ./parser < input
时间： 2024-10-04 07:29:28

Lex Yacc (一) 入门的相关文章

创造新语言（2）——用Lex&amp;Yacc构建简单的分析程序

昨天我们开始设计了一门新语言,制定了基本的开发架构,今天我们就先来了解一下,两个非常好用的工具,编译器前端构建的神器--Lex&Yacc,这两个工具在linux下叫做flex和bison. Lex是词法分析器构建工具,我们安装对应的词法规则书写,那么就能够为我们生成对应的词法分析器,自动帮我们分好token,而分词工作,一直是编译系统的基础任务. 我们今天,先来尝试编写一个BNF语法的解析器,将我们的BNF解析成代码可以识别的数据格式,BNF的格式大概是这样: {{ do_init() }} #

Lex+YACC详解

1. 简介 只要你在Unix环境中写过程序,你必定会邂逅神秘的Lex&YACC,就如GNU/Linux用户所熟知的Flex&Bison,这里的Flex就是由Vern Paxon实现的一个Lex,Bison则是GNU版本的YACC.在此我们将统一称呼这些程序为Lex和YACC.新版本的程序是向上兼容的(译注:即兼容老版本),所以你可以用Flex和Bison来尝试下我们的实例. 这些程序实用性极广,但如同你的C编译器一样,在其主页上并没有描述它们,也没有关于怎样使用的信息.当和Lex结合使用时

Lex Yacc (四) 实际应用全代码

修改后的实际应用全代码 草木鱼(七) 精读 源代码有百度云存盘 复杂的逻辑判断简化成程序判断语句,可便于应用的扩展和维护,也极大增强了代码的可读性. 我们对整体文件划分如下: tree.l tree.y parser.h #内部编译使用的头文件 parser.c #内部编译的主函数 compile.h #内外部交互的头文件 main.c #外部程序 修改说明 1.将内部使用变量,函数,结构体和宏定义集中到parser.h 2.将yyparser的输入进行重定义,见#undef YY_INPUT部

ubuntu下安装lex,yacc

最近在看<自制编程语言>这本书. 不过发现需要安装编译工具 lex, yacc. 书上说Linux自带lex, yacc.不过我发现我的没有. 并且,ubuntu不使用lex, yacc. 输入 sudo apt-get install yacc lex 会报错, 报错内容如下: Reading package lists... Done Building dependency tree Reading state information... Done E: Unable to locate

qmake理解（还可以加入Lex Yacc文件）

关于qmake,好一段时间令我一头雾水,不知道用来干嘛的,只知道怎么用,而且也只懂那么一两个命令,详细看过资料以后整理如下: 1.首先,感性的认识是,qmake可以利用源文件(包括头文件h,实现文件cpp,qt的ui文件等等)生成各种不同类型的工程,工程需要的Makefile文件,可执行的与不可执行的,这取决于所用的模板(包括app.lib.subdirs.vcapp.vclib). 2.创建pro文件,添加各种源文件,还可以设定平台相关的不同源文件,设置各种规则,利用qmake命令生成工程.后

lex yacc flex bison

lex与yacc是两个在Unix下的分别作词法分析和语法分析的工具, Linux对应flex与bison. windows:http://sourceforge.net/projects/unxutils/

PERL/LEX/YACC技术实现文本解析--XML解析

继周六的p_enum.pl后,再来一篇说说我用perl做的lex,yacc工具.之前说了,我学习lex和yacc的最初动机是为了做个C语言解释器的SHELL:但后来工作中的实际需要也是制作perl版lex和yacc的一个动机.Perl库里有lex和yacc,我没研究过,想来应该比我做的强大,不过对新手来说,未必能容易入手. 我的第一个应用场景是做一个xml配置文件的排序.XML是标签标记语言,同一级下,TAG顺序本身是无所谓的:但对于测试工作来说,经常要通过文本比较工作来确定两个配置文件差别.如

Lex Yacc (三) 语法树打印

语法树打印 草木鱼(六) 源代码有百度云存盘 node.h 中有是否打印内容栈的开关 treeinput treeinput if(1>1||2>2)print(1); else if(3>1&&2>2)print(2); else print(3); 和 再识语法树 中的文件放一起 bison -d lexya_e.y lex lexya_e.l gcc -g -o graph lex.yy.c lexya_e.tab.c liwei.c ./graph <

Lex Yacc (二) 语法树

语法树的应用 草木鱼 (四) 源码见百度云盘 详细讲解:草木鱼(四) input input i=0; while(i<=10){ print(i); i=i+1; } print(i+i); node.h node.h /* 定义树结点的权举类型 */ typedef enum { TYPE_CONTENT, TYPE_INDEX, TYPE_OP } NodeEnum; /* 操作符 */ typedef struct { int name; /* 操作符名称 */ int num; /*