Flex&Bison（四）规则引擎

最新推荐文章于 2022-09-06 15:58:12 发布
最新推荐文章于 2022-09-06 15:58:12 发布
阅读量325 收藏
点赞数
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38781075/article/details/107900339
版权

本文没有真的实现规则引擎，还是跟linux一样stdin输入stdout输出，没有集成到库中。但是还是一个不错的示例。

这可能是我写的学习Flex&Bison的最后一个版本了。

本篇文章的代码基于原版文档的中的——source code for calculator代码

https://www.epaperpress.com/lexandyacc/index.html

我改造的程序，由四个部分组成，分别是calc3.l、calc3.y、calc3.h、calc3.c。

编译命令

flex *.l
bison -d *.y
g++ -o cal *.c -lfl

支持的操作

采用类C语言设计，支持任意定义变量名字，支持整型、浮点型、bool型以及简易容器类型，打印变量或者常量必须使用print打印，支持if else、while操作、支持逻辑的&&、||、^、！操作，以及+-*/，还有==、>=、<=。一行语句结束必须加；。

已知bug

单个if语句（后面不写else）需要跟两个；结尾。

操作举例

a=3;b=4;if(a>b){a++;print a;}else {print b;}
11 add al;11 in al;
a=true;if(a)print 99.1;;
if(11>=22)print 33;else print 22;
a=3*4+5;print a;
a=true;b=false;if(a&&!b)print 99;;
a=true;b=false;if(a^b)print 99;;

源代码

calc3.l

%{
#include <stdlib.h>
#include "calc3.h"
#include "calc3.tab.h"
void yyerror(const char *);
#include <arpa/inet.h>
%}

%%
"true"      {
                yylval.iValue = 1;
                return INTEGER;
            }
"false"      {
                yylval.iValue = 0;
                return INTEGER;
            }
[0-9]*\.[0-9]+ {
                yylval.flo = atof(yytext);
                return FLO;
            }
[1-9][0-9]* {
                yylval.iValue = atoi(yytext);
                return INTEGER;
            }

[-()<>=+*/;{}.!^] {
                return *yytext;
             }

">="            return GE;
"<="            return LE;
"=="            return EQ;
"!="            return NE;
"while"         return WHILE;
"if"            return IF;
"else"          return ELSE;
"print"         return PRINT;
"++"            return GG;
"--"            return LL;
"&&"            return AND;
"||"            return OR;
"add"           return AD;
"in"            return IN;
[a-zA-Z][A-Za-z0-9]* {yylval.sIndex = strdup(yytext);return VARIABLE; }
[ \t\n]+        ;       /* ignore whitespace */

.               yyerror("Unknown character");
%%
int yywrap(void) {
    return 1;
}

calc3.y

%{
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include "calc3.h"

/* prototypes */
nodeType *opr(int oper, int nops, ...);
nodeType *id(char * s);
nodeType *con(double value);
void freeNode(nodeType *p);
double ex(nodeType *p);
int yylex(void);
#include <iostream>
#include<map>
#include<set>
using namespace std;
void yyerror(const char *s);
map<string,double> sym;                    /* symbol table */
map<string,set<double>> m;
%}

%union {
    int iValue;                 /* integer value */
    char *sIndex;                /* symbol table index */
	double flo;                /* symbol table index */
    nodeType *nPtr;             /* node pointer */
};

%token <iValue> INTEGER
%token <flo> FLO
%token <sIndex> VARIABLE
%token WHILE IF PRINT
%nonassoc IFX
%nonassoc ELSE

%left GE LE EQ NE '>' '<' GG LL
%left '+' '-' OR '^' AD IN
%left '*' '/' AND
%nonassoc UMINUS
%nonassoc ADD
%nonassoc NOT
%type <nPtr> stmt expr stmt_list

%%

program:
        function                { exit(0); }
        ;

function:
          function stmt         { ex($2); freeNode($2); }
        | /* NULL */
        ;

stmt:
          ';'                            { $$ = opr(';', 2, NULL, NULL); }
        | expr  ';'                      { $$ = $1; }
        | PRINT expr ';'                 { $$ = opr(PRINT, 1, $2); }
        | VARIABLE '=' expr ';'          { $$ = opr('=', 2, id($1), $3); }
        | VARIABLE GG ';'                { $$ = opr('=', 2, id($1), opr('+', 2, id($1), con(1)));}
        | VARIABLE LL  ';'               { $$ = opr('=', 2, id($1), opr('-', 2, id($1), con(1))); }
        | INTEGER AD VARIABLE ';'        { $$ = NULL;m[$3].insert($1);}
        | INTEGER IN VARIABLE ';'        { $$ = NULL; if(m[$3].count($1))cout<<"true"<<endl;else cout<<"false";}
        | WHILE '(' expr ')' stmt        { $$ = opr(WHILE, 2, $3, $5); }
        | IF '(' expr ')' stmt %prec IFX { $$ = opr(IF, 2, $3, $5); }
        | IF '(' expr ')' stmt ELSE stmt { $$ = opr(IF, 3, $3, $5, $7); }
        | '{' stmt_list '}'              { $$ = $2; }
        ;

stmt_list:
          stmt                  { $$ = $1; }
        | stmt_list stmt        { $$ = opr(';', 2, $1, $2); }
        ;

expr:
          INTEGER               { $$ = con($1); }
        | VARIABLE              { $$ = id($1); }
        | FLO                   { $$ = con($1); }
        | '!' expr %prec NOT    { $$ = opr(NOT, 1, $2); }
        | '-' expr %prec UMINUS { $$ = opr(UMINUS, 1, $2); }
        | '+' expr %prec ADD    { $$ = opr(ADD, 1, $2); }
        | expr '^' expr         { $$ = opr('^', 2, $1, $3); }
        | expr '+' expr         { $$ = opr('+', 2, $1, $3); }
        | expr '-' expr         { $$ = opr('-', 2, $1, $3); }
        | expr '*' expr         { $$ = opr('*', 2, $1, $3); }
        | expr '/' expr         { $$ = opr('/', 2, $1, $3); }
        | expr '<' expr         { $$ = opr('<', 2, $1, $3); }
        | expr '>' expr         { $$ = opr('>', 2, $1, $3); }
        | expr GE expr          { $$ = opr(GE, 2, $1, $3); }
        | expr LE expr          { $$ = opr(LE, 2, $1, $3); }
        | expr NE expr          { $$ = opr(NE, 2, $1, $3); }
        | expr EQ expr          { $$ = opr(EQ, 2, $1, $3); }
        | expr AND expr         { $$ = opr(AND, 2, $1, $3); }
        | expr OR expr          { $$ = opr(OR, 2, $1, $3); }
        | '(' expr ')'          { $$ = $2; }
        ;

%%

nodeType *con(double value) {
    nodeType *p;

    /* allocate node */
    if ((p = (nodeType *)malloc(sizeof(nodeType))) == NULL)
        yyerror("out of memory");

    /* copy information */
    p->type = typeCon;
    p->con.value = value;

    return p;
}

nodeType *id(char * s) {
    nodeType *p;

    /* allocate node */
    if ((p =(nodeType *) malloc(sizeof(nodeType))) == NULL)
        yyerror("out of memory");

    /* copy information */
    p->type = typeId;
    p->id.s = s;

    return p;
}

nodeType *opr(int oper, int nops, ...) {
    va_list ap;
    nodeType *p;
    int i;

    /* allocate node, extending op array */
    if ((p = (nodeType *)malloc(sizeof(nodeType) + (nops-1) * sizeof(nodeType *))) == NULL)
        yyerror("out of memory");

    /* copy information */
    p->type = typeOpr;
    p->opr.oper = oper;
    p->opr.nops = nops;
    va_start(ap, nops);
    for (i = 0; i < nops; i++)
        p->opr.op[i] = va_arg(ap, nodeType*);
    va_end(ap);
    return p;
}

void freeNode(nodeType *p) {
    int i;

    if (!p) return;
    if (p->type == typeOpr) {
        for (i = 0; i < p->opr.nops; i++)
            freeNode(p->opr.op[i]);
    }
    free (p);
}

void yyerror(const char *s) {
   fprintf(stdout, "%s\n", s);
}

int main(void) {
    yyparse();
    return 0;
}

calc3.h----辅助头文件

#include <iostream>
#include<map>
using namespace std;
typedef enum { typeCon, typeId, typeOpr } nodeEnum;

/* constants */
typedef struct {
    double value;                  /* value of constant */
} conNodeType;

/* identifiers */
typedef struct {
    char *s;                      /* subscript to sym array */
} idNodeType;

/* operators */
typedef struct {
    int oper;                   /* operator */
    int nops;                   /* number of operands */
    struct nodeTypeTag *op[1];	/* operands, extended at runtime */
} oprNodeType;

typedef struct nodeTypeTag {
    nodeEnum type;              /* type of node */

    union {
        conNodeType con;        /* constants */
        idNodeType id;          /* identifiers */
        oprNodeType opr;        /* operators */
    };
} nodeType;

extern map<string,double> sym;

calc3.c---核心处理函数

#include <stdio.h>
#include "calc3.h"
#include "calc3.tab.h"
#include <iostream>
#include<map>
using namespace std;
double ex(nodeType *p) {
    if (!p) return 0;
    switch(p->type) {
    case typeCon:       return p->con.value;
    case typeId:        if(sym.count(p->id.s))return sym[p->id.s];else {cout<<p->id.s<<" is Uninitialized"<<endl;exit(0);}
    case typeOpr:
        switch(p->opr.oper) {
        case WHILE:     while(ex(p->opr.op[0])) ex(p->opr.op[1]); return 0;
        case IF:        if (ex(p->opr.op[0]))
                            ex(p->opr.op[1]);
                        else if (p->opr.nops > 2)
                            ex(p->opr.op[2]);
                        return 0;
        case PRINT:     cout<<ex(p->opr.op[0])<<endl;; return 0;
        case ';':       ex(p->opr.op[0]); return ex(p->opr.op[1]);
        case '=':       return sym[p->opr.op[0]->id.s] = ex(p->opr.op[1]);
        case UMINUS:    return -ex(p->opr.op[0]);
        case ADD:    return ex(p->opr.op[0]);
        case '+':       return ex(p->opr.op[0]) + ex(p->opr.op[1]);
        case '-':       return ex(p->opr.op[0]) - ex(p->opr.op[1]);
        case '*':       return ex(p->opr.op[0]) * ex(p->opr.op[1]);
        case '/':       if(ex(p->opr.op[1])==0){cout<<"can't divide by 0"<<endl;exit(0);}return ex(p->opr.op[0]) / ex(p->opr.op[1]);
        case '<':       return ex(p->opr.op[0]) < ex(p->opr.op[1]);
        case '>':       return ex(p->opr.op[0]) > ex(p->opr.op[1]);
        case '^':       return (!ex(p->opr.op[0])&&ex(p->opr.op[1]))||(ex(p->opr.op[0])&&!ex(p->opr.op[1]));
        case GE:        return ex(p->opr.op[0]) >= ex(p->opr.op[1]);
        case LE:        return ex(p->opr.op[0]) <= ex(p->opr.op[1]);
        case NE:        return ex(p->opr.op[0]) != ex(p->opr.op[1]);
        case EQ:        return ex(p->opr.op[0]) == ex(p->opr.op[1]);
        case OR:        return ex(p->opr.op[0]) || ex(p->opr.op[1]);
        case AND:        return ex(p->opr.op[0]) && ex(p->opr.op[1]);
        case NOT:        return !ex(p->opr.op[0]);
        }
    }
    return 0;
}

 

 

qq_38781075
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【手写数据库toadb】语言解析器，编程语言是这样被解析理解，解析器利器flex和bison,解析树与逆波兰式
一个追逐梦想的码农
10-21 2万+
在当今信息化时代，数据已经成为企业和个人最为宝贵的资产之一。为了有效地管理和利用这些数据，数据库技术应运而生，并得到了广泛的应用。目前市场上已经有很多成熟的数据库产品，如MySQL、Oracle、PostgreSQL等，它们提供了丰富的功能和性能，满足了不同场景的需求。然而，这些数据库产品的庞大和复杂也让很多人感到困惑和不解，不知道数据库内部的运作机制和原理。为了解决这个问题，我们开发了toadb数据库。toadb的目标是以最基础的骨架来搭建一个数据库，让人们能够更清晰地了解数据库的本质和运作原理。
Flex
qq_41956860的博客
11-23 445
文章目录tipsFLEX 结构踩过的坑 tips gcc 安装： 安装mingw-get, 并将bin目录添加到环境变量 命令行输入 mingw-get install gcc FLEX 结构 定义段 (definitions) %% 规则段 (rules) %% 用户代码段 (user code) 注释 /*…*/ 规则段中，正则表达式必须顶行，否则直接复制到...
业务规则引擎
weixin_33862188的博客
07-28 722
什么是业务规则？在需求里面我们往往把约束，完整性，校验，分支流等都可以算到业务规则里面。在规则引擎里面谈的业务规则重点是谈当满足什么样的条件的时候，需要执行什么样的操作。因此一个完整的业务规则包括了条件和触发操作两部分内容。而引擎是事物内部的重要的运行机制，规则引擎即重点是解决规则如何描述，如何执行，如何监控等一系列问题。对于快速软件开发平台往往会包括两个方面的内容，一个是可...
C语言规则总结一
cogizh
07-31 3002
最近又重新认真的学习了一下C语言的基础，看到很多值得注意的地方，现在总结下来，共大家谈论，也方便以后查阅。 本文章适合已经掌握一定C语言基础的朋友！ 声明和初始化 1.      如何决定使用哪种数值类型？ Int,long,short的关系，原则上long保存的数值范围要不小于int，而short不大于int. 一般情况下，如果要保存的数据>32767,或者 Char
Bison常用规范（待续）
chenxijian2010的博客
08-29 257
移进shifting/归约reduction 二义性和冲突 转载于:https://my.oschina.net/liuyuanyuangogo/b...
规则引擎和 Flink CEP
qq_32323239的博客
09-06 1449
结合了时序的上下文：如风控场景识别了作弊的行为序列后，给「先做 xx，后做 xx，再做 xx」的用户进行封禁；结合了否定的语义：如电商营销场景给「浏览商品后 10 分钟未下单的用户」发送优惠券；结合了自定义统计的语义：如实时监控场景为每个微服务设定监控规则，「第一次报警发生后，30s 内发生第二次报警」的情况进行报警升级；CEP 本身并没有脱离实时计算的范畴，所以绝大部分用户还是选择基于 Flink，或者已有的计算服务上去搭建相关的框架，CEP 对应的功能更多是以 library 的形式存在。
《flex&bison》之sql解析
intheworld
12-21 3468
大概上半年接了一本《深入理解MySQL》，看了个一知半解吧！这里不得不说这本书有点贪大求全了。什么存储引擎、sql解析、查询优化等等的内容都涉及。如果领悟能力高的话，可能对数据库有一种全局的把握。不然的话还是需要看看其他资料了。当时不懂sql编译原理（其实现在也不懂，这货太愁银了），以为sql解析应该是一个简单的事情。毕竟不需要生成最终机器代码嘛，其实不然呀！举个例子吧，使用flex和bison为
使用flex和bison实现的sql引擎解析
最新发布
06-09
具体实现中，我们可以在Flex中定义所有的Token，然后在Bison中定义所有的语法规则，然后在Bison中使用Flex生成的Token进行语法分析，最终得到一个语法树。 使用Flex和Bison实现SQL引擎解析可以让我们更加专注于SQL...
flex and bison
12-13
#### 四、Flex与Bison结合使用 - **Flex与Bison的协同工作**：Flex负责词法分析，生成标记；而Bison则根据这些标记构建语法树或执行其他操作。 - **协程式的扫描器**：在Flex中，可以通过定义特定的规则使扫描器...
lex-yacc或flex-bison的介绍
10-13
yacc/bison 工具可以读取 lex/flex 工具生成的标记序列，然后根据配置文件中的规则来确定标记序列的结构和含义。 通过使用 lex/flex 和 yacc/bison 工具，我们可以构建一个简单的计算器，并进一步研究 lex 和 yacc...
bison生成c语言文件指令,分享一个ST语言的bison文件
weixin_39897758的博客
05-20 337
%code top{#include #include }%code requires{#define YYLTYPE YYLTYPEtypedef struct PlcSrcLocation YYLTYPE;typedef void* yyscan_t;#define YYLTYPE_IS_TRIVIAL 1}%code provides{#define YY_DECL int yylex ...
规则引擎CKRule --最简引言
ckrule的专栏
04-08 928
1. 什么是规则引擎 引用IBM一位技术专家的说法是这样的： “业务软件系统通常要处理复杂的重复任务。这些系统是使用专用业务规则编码的，用于完成这些任务，但必须能够灵活适应变化。为了简化开发，允许快速部署更改，人们创建了规则引擎，独立于过程代码执行业务规则，允许在无需修改底层代码的前提下更改规则。” 简单来说，规则引擎就是为了处理复杂多变的业务而出现的，而把这些变化封装到规则引擎中，提供通用
简易编译器实现（二）使用Bison创建语法分析器
胡LiuJia@BLOG
03-28 5696
你也可以通过我的独立博客 —— www.huliujia.com 获取本篇文章 简易编译器实现（一）使用Flex创建词法分析器一文介绍了编译器的概念和七个阶段，并说明了如何使用Flex创建词法分析器。本篇文章介绍如何使用Bison创建语法分析器，并实现基本的运算能力。本文继续使用简易编译器实现（一）使用Flex创建词法分析器中提出的集合运算语言AlphaGun作为演示的例子。 语法分析 语法分析器使用词法分析器输出的token流作为输入，把token流转换成树状的中间表示，通常会转换成语法树，本文中使用.
几个常见规则引擎的简单介绍和演示
weixin_30695195的博客
10-27 2752
Ilog JRules是最有名的商用BRMS； Drools是最活跃的开源规则引擎； Jess是Clips的java实现，就如JRuby之于Ruby，是AI系的代表； Visual Rules（旗正规则引擎）国内商业规则引擎品牌。 今天对比了一下这四个颇有代表性的规则引擎的规则语言。其中Ilog和visual rules是商业产品，没有机会实战。 1.一样的If--The...
【采用】规则引擎Pyke与PyClips对比研究报告（高大上啊，第一次听说pyke和pyclips这俩词~）
xiaoxiaoniaoer1的专栏
12-30 1980
1．背景综述 规则引擎主要实现的功能是存储、分类和管理规则，执行规则、推断其它事实的应用程序。其中的规则主要是指企业或商务业务逻辑、法律条款等。在规则引擎发展的过程中，Rete算法和Prolog语言是两个重要的理论分支，多数规则引擎都是基于以上二者扩展而来的。在工业活动铸造中，发展时间较长、应用广泛的两个体系是Clips体系和Prolog体系。 Clips是美国航空航天局NASA- J...
风控逻辑利器---规则引擎
zhuanzhuantech的博客
08-10 1622
只要有规则的存在，规则引擎都可以在此大放异彩。你还在频繁的写if-else吗？不如试试规则引擎。它绝对会给你带来意想不到的效果。
Ilog、Drools、Jess规则引擎的Rule Language 比对
花钱的年华
05-27 7523
Ilog JRules今天对比了一下这三个颇有代表性的规则引擎的规则语言。其中Ilog是商业产品，没有机会实战。作者：江南白衣 1.一样的If--Then 句式与Rete引擎    三者都会把原来混乱不堪的if---else---elseif----else谜团，    拆成N条带优先级的"If  条件语句  then  执行语句" 的句式。        三者都主要使用forew
规则引擎描述
weixin_34143774的博客
10-30 314
2019独角兽企业重金招聘Python工程师标准>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值