[编译原理]lex和bison实现逻辑表达式求值以及短路计算次数统计

最新推荐文章于 2024-04-27 11:13:02 发布
最新推荐文章于 2024-04-27 11:13:02 发布
阅读量1.2k 收藏 13
点赞数 5
分类专栏： complier 逻辑表达式 文章标签： 算法 自动驾驶 单元测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Joseph115/article/details/118274511
版权

目录

内容：逻辑表达式的求值工具

具体要求

解决方案

设计文法

设计语法制导定义

编写词法分析器

编辑语法和语义分析：

实验难点

完整代码

实验结果

内容：逻辑表达式的求值工具

输入一个包含数值的逻辑表达式，输出计算其真值，和因短路操作而跳过的数值比较的次数。输出格式为Output: [true or false], [次数]。注意，逻辑表达式的计算符合短路算法。其中，!计入逻辑运算次数，而 == 或 != 只用于非布尔型的数值比较。例如： 

  • 输入：3 == 2
    输出：Output: false, 0 
  • 输入：3 > 2
    输出：Output: true, 0 
  • 输入：3 > 2 && 10 > 1
    输出：Output: true, 0 
  • 输入：3 > 2 && 10 > 12
    输出：Output: false, 0 
  • 输入：3 < 2 && 10 > 12
    输出：Output: false, 1 
  • 输入：3 < 2 && 10 < 12
    输出：Output: false, 1 
  • 输入：( 3 <= 2 || 13 <= 19 ) && 1 < 2 
    输出：Output: true, 0 
  • 输入：( 3 >= 2 || 13 <= 19 ) && 1 < 2 
    输出：Output: true, 1 
  • 输入：( 3 >= 2 || 13 <= 19 ) || 1 < 2 
    输出：Output: true, 2 
  • 输入：! ( 3 > 2 )
    输出：Output: false, 0 
  • 输入：! ( 3 > 2 || ( 13 < 19 || 1 < 2 ) )
    输出：Output: false, 2 

具体要求

(1) 为了解决上面问题，需要设计一个文法描述该问题的逻辑表达式，并设计语法制导定义求解最后的输出值。

(2) 根据(1)的文法，设计基于flex的词法分析器。具体形式为1个flex文件的源代码。

(3) 在(2)的基础上，设计基于bison的语法（同时包含语义）分析器。具体形式为1个bison文件的源代码。

(4) 在文档中，描述(1)的内容，以及(2)(3)的设计方案（不需要粘贴很多源代码到文档中）。文档中可以包括问题的难点、求解思路等，但不要包含显而易见的步骤。文档以清楚描述内容为主，不易过长，字数和篇幅不是采分点。

(5) 已知输入的表达式中不包含中文字符。文法应该能够兼容下面字符：数值比较<、<=、>、>=、==、!=，布尔比较&&、||、！，以及括号(、)。注意：== 或 != 只用于非布尔型的数值比较

(6) 词法分析和语法分析应具有基本的报错能力，例如对于不符合的语法，如输入了字母或者小数，输出”Error.”。

解决方案

  • 设计文法

(1)S -> R
(2)R -> R or R
(3)R -> R and R

(4)R -> ! R
(5)R -> ( R )
(6)R -> value < value

(7)R -> value <= value
(8)R -> value > value

(9)R -> value >= value

(10)R -> value == value

(11)R -> value !=value

  • 设计语法制导定义

该程序输出为逻辑表达式的值以及因短路机制而跳过的运算步骤，因此，为非终结符定义综合属性val、total和cut。value值为其对应的真假值，total为其包含的总运算次数，cut为其已跳过的运算次数。

产生式

语义规则

S -> R

If(R.val) print(“Output: true,”+ R.cut);

Else print(“Output:false,”+ R.cut)

R -> R1 or R2

R.val = R1.val || R2.val; R.total = R1.total + R2.total;

If(R1.val) R.cut = R1.cut + R2.total;

Else R.cut = R1.cut + R2.cut;

R -> R1 and R2

R.val = R1.val && R2.val; R.total = R1.total + R2.total;

If(R1.val) R.cut = R1.cut + R2.cut;

Else R.cut = R1.cut + R2.total;

R -> ! R1

R.val = !R1.val; R.total = R1.total + 1; R.cut = R1.cut;

R - > ( R )

R.val = R1.val; R.total = R1.total; R.cut = R1.cut;

R -> value < value

R.val = value < value; R.total = 1; R.cut = 0;

R -> value <= value

R.val = value <= value; R.total = 1; R.cut = 0;

R -> value > value

R.val = value > value; R.total = 1; R.cut = 0;

R -> value >= value

R.val = value >= value; R.total = 1; R.cut = 0;

R -> value == value

R.val = value == value; R.total = 1; R.cut = 0;

R -> value != value

R.val = value != value; R.total = 1; R.cut = 0;

  • 编写词法分析器

定义双符号非终结符：

NLT >=

NGT <=

EQL ==

NEQ !=

AND &&

OR \|\|
{NLT} {

yylval = *yytext;

return nlt;

}/* 此处以NLT为例 */

定义数字digit非终结符，需要做数值转换，将字符串转换为整型，用到atoi函数：

digit [0-9]

%%

{digit}+ {

yylval = atoi(yytext);

return VALUE; 

}

定义单符号终结符：

[()=!><\n] {return *yytext;}

定义空白：

{whitespace}	{ ; }


{newline}	{ return 0; }

.	{
	printf("Error! Wrong token '%s'.\n", yytext);
	exit(0);
}
  • 编译语法和语义分析器

设计非终结符结构，包含val、total和cut综合属性：

typedef struct

{

     int val;

     int total;

     int cut;

}myStruct;

定义token以及左右结合规则；其中除! 为右结合外，其余比较符号皆为左结合：

%token VALUE

%token nlt ngt eql neq and or 

%right   '!'

%left   '<'  '>' 

%left   nlt ngt eql neq and or

 

编辑语法和语义分析：

S: R {{if($1.val)printf("Output: true,%d",$1.cut);else printf("Output: false,%d",$1.cut); return 0;}}

;

R: 

  |R or R    {$$.val = $1.val || $3.val;

$$.total = $1.total + $3.total;

if($1.val) $$.cut = $1.cut + $3.total;

else $$.cut = $1.cut + $3.cut;}

  |R and R    {$$.val = $1.val && $3.val;

$$.total = $1.total + $3.total;

if($1.val) $$.cut = $1.cut + $3.cut;

else $$.cut = $1.cut + $3.total;}

  |'!' R         {$$.val =  ! $2.val; $$.total = $2.total + 1; $$.cut = $2.cut;}

  |'('R')'       {$$.val = $2.val; $$.total = $2.total; $$.cut = $2.cut;}

  |VALUE '<' VALUE   {$$.val = ($1.val < $3.val); $$.total = 1; $$.cut = 0;}

  |VALUE ngt VALUE   {$$.val = ($1.val <= $3.val); $$.total = 1; $$.cut = 0;}

  |VALUE '>' VALUE   {$$.val = ($1.val > $3.val); $$.total = 1; $$.cut = 0;}

  |VALUE nlt VALUE   {$$.val = ($1.val >= $3.val); $$.total = 1; $$.cut = 0;}

  |VALUE eql VALUE   {$$.val = ($1.val == $3.val); $$.total = 1; $$.cut = 0;}

  |VALUE neq VALUE   {$$.val = ($1.val != $3.val); $$.total = 1; $$.cut = 0;}

  • 实验难点

1、本实验在macOS系统上进行，与windows不同，在安装flex、bison和gcc后，可编写.l和.y文件，编译过程如下：

bison -d mytool.y

flex -omytool.yy.c mytool.l

gcc mytool.tab.c mytool.yy.c

./a.out

2、由于非终结符有多个综合属性，因此需要定义struct添加多个属性。

3、语义设计时需要注意优先级，依次为or and ! () < <= > >= == !=

4、在词法定义中，需要给双符号比较符定义别名，才可在之后设计词法；digit非终结符需要使用atoi方法将输入的字符串转换为int格式，否则在后续的比较中无法比较两位以上的数字。

  • 完整代码

mytool.l

%{
	#include <stdio.h>
	#include "mytool.tab.h"
%}

NLT >=
NGT <=
EQL ==
NEQ !=
AND &&
OR \|\|

whitespace [ \t\f\v]
newline [\r\n]

digit	[0-9]
%%

{whitespace}	{ ; }


{newline}	{ return 0; }

{digit}+ {
yylval = atoi(yytext);
return VALUE; 
}



[()=!><\n]	{return *yytext;}


{NLT}	{
yylval = *yytext;
return nlt;
}
{NGT}	{
yylval = *yytext;
return ngt;
}
{EQL}	{
yylval = *yytext;
return eql;
}
{NEQ}	{
yylval = *yytext;
return neq;
}
{AND}	{
yylval = *yytext;
return and;
}
{OR}	{
yylval = *yytext;
return or;
}

.	{
	printf("Error! Wrong token '%s'.\n", yytext);
	exit(0);
}

%%
int yywrap(void)
{
	return 1;
}

mytool.y

%{
	#include <stdio.h>

	#ifndef BTOD_H_INCLUDED
	#define BTOD_H_INCLUDED
	typedef struct
	{
   	 int val;
   	 int total;
   	 int cut;
	}myStruct;


	#endif

	#define YYSTYPE myStruct
	int yylex(void);  
	void yyerror(char const *);      
%}
%token VALUE
%token nlt ngt eql neq and or 
%right   '!'
%left   '<'  '>' 
%left   nlt ngt eql neq and or 

%%
S: R {{if($1.val)printf("Output: true,%d",$1.cut);else printf("Output: false,%d",$1.cut); return 0;}}
;
R: 
  |R or R    {$$.val = $1.val || $3.val;
		$$.total = $1.total + $3.total;
		if($1.val) $$.cut = $1.cut + $3.total;
		else $$.cut = $1.cut + $3.cut;}
  |R and R    {$$.val = $1.val && $3.val;
		$$.total = $1.total + $3.total;
		if($1.val) $$.cut = $1.cut + $3.cut;
		else $$.cut = $1.cut + $3.total;}
  |'!' R         {$$.val =  ! $2.val; $$.total = $2.total + 1; $$.cut = $2.cut;}
  |'('R')'       {$$.val = $2.val; $$.total = $2.total; $$.cut = $2.cut;}
  |VALUE '<' VALUE   {$$.val = ($1.val < $3.val); $$.total = 1; $$.cut = 0;}
  |VALUE ngt VALUE   {$$.val = ($1.val <= $3.val); $$.total = 1; $$.cut = 0;}
  |VALUE '>' VALUE   {$$.val = ($1.val > $3.val); $$.total = 1; $$.cut = 0;}
  |VALUE nlt VALUE   {$$.val = ($1.val >= $3.val); $$.total = 1; $$.cut = 0;}
  |VALUE eql VALUE   {$$.val = ($1.val == $3.val); $$.total = 1; $$.cut = 0;}
  |VALUE neq VALUE   {$$.val = ($1.val != $3.val); $$.total = 1; $$.cut = 0;}
 
;
%%
int main()
{
	yyparse();
	return 0;
}
void yyerror(char const *msg)  
{  
    fprintf(stderr, "%s\n",msg);  
}

  • 实验结果

        (太尴尬了，把experiment拼错了) 以下是要求给的数据：

(base) joseph@MacBook-Pro exepriment % ./a.out          
3>5&&1<2
Output: false,1%                                                                (base) joseph@MacBook-Pro exepriment % ./a.out 
3 == 2      
  Output: false,0%                                                              (base) joseph@eMacBook-Pro exepriment % ./a.out
3 > 2
 Output: true,0%                                                                (base) joseph@MacBook-Pro exepriment % ./a.out
3 > 2 && 10 > 1
      Output: true,0%                                                           (base) joseph@MacBook-Pro exepriment % ./a.out
3 > 2 && 10 > 12
      Output: false,0%                                                          (base) joseph@MacBook-Pro exepriment % ./a.out
3 > 2 && 10 > 12
      Output: false,0%                                                          (base) joseph@MacBook-Pro exepriment % ./a.out
3 < 2 && 10 > 12
      Output: false,1%                                                          (base) joseph@MacBook-Pro exepriment % ./a.out
3 < 2 && 10 < 12
      Output: false,1%                                                          (base) joseph@MacBook-Pro exepriment % ./a.out
( 3 <= 2 || 13 <= 19 ) && 1 < 2 
             Output: true,0%                                                    (base) joseph@MacBook-Pro exepriment % ./a.out
( 3 >= 2 || 13 <= 19 ) && 1 < 2
            Output: true,1%                                                     (base) joseph@MacBook-Pro exepriment % ./a.out
( 3 >= 2 || 13 <= 19 ) || 1 < 2
            Output: true,2%                                                     (base) joseph@MacBook-Pro exepriment % ./a.out
! ( 3 > 2 )
     Output: false,0%                                                           (base) joseph@MacBook-Pro exepriment % ./a.out
! ( 3 > 2 || ( 13 < 19 || 1 < 2 ) )
               Output: false,2%

以下是扩展的数据和错误输入：

(base) joseph@MacBook-Pro exepriment % ./a.out 
a > b
Error! Wrong token 'a'.
(base) joseph@MacBook-Pro exepriment % ./a.out
3.4 > 4.4
Error! Wrong token '.'.
(base) joseph@MacBook-Pro exepriment % ./a.out
3 > 4 , 2>3
Error! Wrong token ','.
(base) joseph@MacBook-Pro exepriment % ./a.out
1 == 1 == 1
Output: true,0%                                                                 (base) joseph@MacBook-Pro exepriment % ./a.out
! ( 3 > 2 || ! ( 13 < 19 || 1 < 2 ) )
Output: false,3%                                                                (base) joseph@MacBook-Pro exepriment % ./a.out
! ( 3 > 2 && 4 < 5 ) && !( 3 > 1 || ! ( 4 < 1 && 2 < 1))
Output: true,3%                                                                 (base) joseph@MacBook-Pro exepriment % ./a.out
  (! ( 3 > 2 && 4 < 5 ) )&& !( 3 > 1 || ! ( 4 < 1 && 2 < 1))
Output: false,5%

实验结果与预期相符。

Joseph115
关注
  • 5
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Python实现Lex词法分析器(编译原理大作业) 【100012187】
05-15
主要分为四个部分，第一部分会演示一下Lex的用法并表达一下膜拜之情；之后是自己pyLex的用法；第三部分会详细解释从re到dfa的转换过程；最后是讲解如何读取配置文件，如何生成代码，如何匹配等问题。
编译原理课程设计--用LEX&YACC实现一个简单的C编译器
10-09
自己做编译课程设计写的一个很简单的C编译器，用的是LEX+YACC写的，方法比较新，由于时间的关系写的不是很完善，但是要扩充的话比较容易。压缩包中附LEX&YACC的语言详解，相信对于对编译有兴趣的人有些帮助。
算数表达式逻辑表达式求值
9r3y的专栏
05-07 2355
项目中要实现校验公式，一开始使用BeanShell插件求值，后来改用Dijkstra(迪杰斯特拉)算法自己实现表达式求值。该算法使用一个符号栈和一个数值栈，遍历表达式字符串当遇到数值时入数值栈。当遇到符号时若比符号栈顶的符号优先级高则入符号栈，若比符号栈顶的符号优先级低，则先把两栈中能计算的统统计算掉（直到符号栈顶的符号优先级小于遇到的符号）。遍历完再计算掉两栈中剩余的项。对于括号的处理也是类似，
将lex,yacc（flex,bison)与MFC结合起来使用！
P2P 研究 思考
12-24 5783
近来开始用lex和bison来写一些东东，这两者结合起来使用是相当的方便。用lex，bison做完核心的分析处理之后，想必大家都会把这些嵌入到自己的工程里面，和其他的功能结合起来。但是，往往此时会出现许多的错误。       lex,bison默认生成的都是C的源程序，而且二者都有自己的语法规则。 有时会与VC有些冲突，但是，只要修改部分定义之后这些问题都是可以解决的。1，yyerror()函数，
Windows中使用Lex（Win flex-bison）
Alexabc3000的专栏
08-09 3634
在Windows中使用Lex，即Win-flex bison。
1225-实验四-递归下降语法分析程序设计
12-31 374
#include<stdio.h> #include<string> char str[10]; int index=0; void E(); //E->TX; void X(); //X->+TX | e void T(); //T->FY v...
[编译原理]用flex和bison生成逻辑表达式的求值工具
m0_45338067的博客
06-27 2490
文章目录实验内容逻辑表达式的求值工具词法分析语法分析bison使用文法优先级和结合律文法设计短路次数统计语义处理错误处理编译及运行编译结果运行结果 实验内容 逻辑表达式的求值工具 ​ 输入一个包含数值的逻辑表达式，输出计算其真值，和因短路操作而跳过的数值比较的次数。输出格式为Output: [true or false], [次数]。注意，逻辑表达式的计算符合短路算法。其中，!计入逻辑运算次数，而 == 或 != 只用于非布尔型的数值比较。 词法分析 ​ Flex器是一个开源的词法分析器，编译器将开发者
【编译原理】第三章语法分析
小梁说代码的博客
03-19 2767
语法分析 根据词法单元的构成规则，对源代码文件的字符流进行了词法分析，由词法单元的模式 → 正则表达式 → DFA → 词法 语法分析就是根据一个个单词，让它们组成逻辑关系，语言规约是上下文无关语法 要进行语法分析，输入的是词素流，类似于这样，这是之前词法分析得到的结果 如何进行语法分析？ 先引入一个概念，文法 文法 算术表达式文法 我们都知道算术表达式是什么，就是一个式子，式子和式子之间也能构成新的式子。算术运算表达式文法的构成因此有： ① E →num ② E →id ③ E →F ④ E →( E
手把手教程-lex与yacc/flex与bison入门（一）（使用windows环境）
热门推荐
weixin_44007632的博客
09-20 4万+
前言 1.文章诞生的契机 在计算机学习中，我们有时可能会想到自制一门属于自己的编程语言，此时选择lex与yacc来生成词法分析器与语法分析器是非常不错的选择。然而，这两个工具虽然用起来简单，但对于新手来说，入门还有着些许的难度。 入门的难度通常不是因为工具的复杂，而是因为教程有些难懂。在大多数教程作者眼里，想要自制一个语言的必然不会是初学者，毕竟新手们还在被C和JAVA等语言搞得晕头转向。这导致大多数lex与yacc教程都是面向进阶选手，内容“点到为止”，并心照不宣地省略了一些“常识”。导致内容在我等这般新
Diagram Designer 的表达式求值工具（Expression Evaluator）
06-11 373
软件版本：Diagram Designer (Version 1.24) 一、Diagram Designer 的表达式求值工具 下图为 Diagram Designer 的表达式求值工具： 在程序的帮助手册中，对这个表达式求值工具的使用有着较为详细的描述。（在【Using D...
编译原理 词法分析器 lex词法分析器
07-26
编译原理 词法分析器 lex词法分析器
lex_实验-编译原理词法分析器实现
05-02
这是一个编译原理lex工具，具备词法分析器的功能，方便了解编译原理词法分析器的功能
lex(flex)&yacc(bison)
banana_baba的博客
05-28 6541
初始配置 文法分析用Flex(Lex):将数据分隔成一个个的标记token (标示符identifiers，关键字keywords，数字numbers, 中括号brackets, 大括号braces, 等等etc.) 语法分析用Bison(Yacc): 在分析标记的时候生成抽象语法树. Bison 将会做掉几乎所有的这些工作, 我们定义好我们的抽象语法树就OK了. 组装用LLVM:
编译原理—Lex和Bison实现计算器
LY_624的专栏
04-20 3802
calc.lex文件 %{ /* * 一个简单计算器的Lex词法文件 */ #include #include void yyerror(char*); /* #include "calc.tab.h" */ %} %% /* a-z为变量 */ [a-z] { yylval =
编译原理---四则运算表达式的计算简单实现
bwju的专栏
09-05 1万+
编译原理---四则运算表达式的计算简单实现
lex yacc flex bison
嵌入式技术
07-01 211
简介 lex与yacc是两个在Unix下的分别作词法分析和语法分析的工具， Linux对应flex与bison。 Yacc 与 Lex 快速入门 flex 和bison的安装和使用 Windows下安装lex(flex)与yacc(bison)
数据结构表达式求值代码_编译原理学习笔记-编写简单的数学表达式计算器
weixin_39790877的博客
12-05 837
按照老规矩，应该是先放示例图简单介绍后序表达式一般我们以前数学课学习的数学表达式都是中序的，比如说一加一，则写法就是1+1。而在计算的时候，为了方便编写数学表达式求值的计算机程序，通常会输入后序表达式。如1+1的后缀表达式为1 1 -。举个更复杂的例子，比如今有中序表达式：1 + (1 - 2) / 3则它的后序表达式为：1 2 - 3 / 1 +为什么后序表达式会更方便编写计算的算法呢？我们使用...
编译原理实验2-递归下降分析–表达式求值
yizhangbiao的专栏
06-14 2426
http://blog.csdn.net/xuzengqiang/article/details/7596357 这是源地址，个人并没有做太大改动，于是就不写原创。 写编译原理实验的时候，当写到 Expression->Term|Expression+Term|Expression-Term      Term->Factor|Term*Factor|Term/Factor
代码随想录算法训练营day53
最新发布
Mitakiyuki的博客
04-27 214
从前到后遍历。
lex和bison制作简单计算器
08-08
lex和bison是两个在编译原理中使用的工具，可以帮助开发者构建编译器或解析器。通过结合使用lex和bison，我们可以制作一个简单的计算器。 首先，我们需要使用lex来定义我们的词法规则。词法规则会对输入的字符序列进行分类，并且生成对应的标记。比如，我们可以定义一些基本的词法规则，如加号、减号、数字等等。 接下来，我们使用bison来定义我们的语法规则。语法规则会描述输入字符序列如何组成合法的表达式。比如，我们可以定义加法表达式等等。 在我们的语法规则中，可以使用词法的标记进行组合，并且指定操作的优先级和结合性等等。然后，bison将会自动生成解析器代码。 在解析器代码中，我们可以编写相应的语义动作。这样，当解析器通过输入的字符序列来构建语法树时，我们可以在特定的语法规则或标记上执行一些操作，如计算出表达式的结果。 最后，我们可以使用编译器或解释器来编译或解释这些生成的代码。当我们输入一个表达式时，词法分析器会将其转化为字符序列，并且传递给语法分析器。语法分析器根据我们的语法规则来构建语法树，并且执行相应的动作。最终，我们可以得到表达式的计算结果。 通过使用lex和bison，我们能够轻松地实现一个简单的计算器，让用户可以输入表达式，并且得到相应的计算结果。当然，对于更复杂的计算器，我们可以进一步扩展词法和语法规则，以支持更多的操作符和函数等等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值