编译原理上机——函数绘图语言（四）：语义分析器

已于 2022-05-14 21:56:50 修改
阅读量1.5k 收藏 8
点赞数 1
分类专栏： 计算器与编译器 文章标签： python 编译器
于 2020-12-04 19:40:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FishPotatoChen/article/details/110671380
版权

目录

相关篇目

编译原理上机——函数绘图语言（一）
编译原理上机——函数绘图语言（二）：词法分析器
编译原理上机——函数绘图语言（三）：语法分析器
编译原理上机——函数绘图语言（五）：编译器与解释器
完整代码
Gitee开源代码

说明

为了让语法分析器更好的为语义分析器服务，我更改了语法分析器的部分代码。所以在这里重新进行说明。我将语义分析与语法分析结合在一个程序中，这样我就可以不用输出语法树而直接使用语法树。

生成符号表

文件名为createtable.py

# -*- coding: utf-8 -*-
"""
Created on Mon Nov 23 20:05:45 2020

@author: FishPotatoChen

Copyright (c) 2020 FishPotatoChen All rights reserved.
"""

import math

TOKEN = {
    # 常量
    'PI': {'TYPE': 'CONST_ID', 'VALUE': 'math.pi', 'FUNCTION': None},
    'E': {'TYPE': 'CONST_ID', 'VALUE': 'math.e', 'FUNCTION': None},
    # 变量
    'T': {'TYPE': 'SYMBOL', 'VALUE': None, 'FUNCTION': None},
    # 函数
    'SIN': {'TYPE': 'FUNC', 'VALUE': None, 'FUNCTION': 'math.sin'},
    'COS': {'TYPE': 'FUNC', 'VALUE': None, 'FUNCTION': 'math.cos'},
    'TAN': {'TYPE': 'FUNC', 'VALUE': None, 'FUNCTION': 'math.tan'},
    'LN': {'TYPE': 'FUNC', 'VALUE': None, 'FUNCTION': 'math.log'},
    'EXP': {'TYPE': 'FUNC', 'VALUE': None, 'FUNCTION': 'math.exp'},
    'SQRT': {'TYPE': 'FUNC', 'VALUE': None, 'FUNCTION': 'math.sqrt'},
    # 保留字
    'ORIGIN': {'TYPE': 'KEYWORD', 'VALUE': None, 'FUNCTION': None},
    'SCALE': {'TYPE': 'KEYWORD', 'VALUE': None, 'FUNCTION': None},
    'ROT': {'TYPE': 'KEYWORD', 'VALUE': None, 'FUNCTION': None},
    'IS': {'TYPE': 'KEYWORD', 'VALUE': None, 'FUNCTION': None},
    'FOR': {'TYPE': 'KEYWORD', 'VALUE': None, 'FUNCTION': None},
    'FROM': {'TYPE': 'KEYWORD', 'VALUE': None, 'FUNCTION': None},
    'TO': {'TYPE': 'KEYWORD', 'VALUE': None, 'FUNCTION': None},
    'STEP': {'TYPE': 'KEYWORD', 'VALUE': None, 'FUNCTION': None},
    'DRAW': {'TYPE': 'KEYWORD', 'VALUE': None, 'FUNCTION': None},
    # 运算符
    '+': {'TYPE': 'OP', 'VALUE': None, 'FUNCTION': None},
    '-': {'TYPE': 'OP', 'VALUE': None, 'FUNCTION': None},
    '*': {'TYPE': 'OP', 'VALUE': None, 'FUNCTION': None},
    '/': {'TYPE': 'OP', 'VALUE': None, 'FUNCTION': None},
    '**': {'TYPE': 'OP', 'VALUE': None, 'FUNCTION': None},
    # 记号
    '(': {'TYPE': 'MARK', 'VALUE': None, 'FUNCTION': None},
    ')': {'TYPE': 'MARK', 'VALUE': None, 'FUNCTION': None},
    ',': {'TYPE': 'MARK', 'VALUE': None, 'FUNCTION': None},
    # 结束符
    ';': {'TYPE': 'END', 'VALUE': None, 'FUNCTION': None},
    # 空
    '': {'TYPE': 'EMPTY', 'VALUE': None, 'FUNCTION': None},
    # 数字
    '0': {'TYPE': 'NUMBER', 'VALUE': 0.0, 'FUNCTION': None},
    '1': {'TYPE': 'NUMBER', 'VALUE': 1.0, 'FUNCTION': None},
    '2': {'TYPE': 'NUMBER', 'VALUE': 2.0, 'FUNCTION': None},
    '3': {'TYPE': 'NUMBER', 'VALUE': 3.0, 'FUNCTION': None},
    '4': {'TYPE': 'NUMBER', 'VALUE': 4.0, 'FUNCTION': None},
    '5': {'TYPE': 'NUMBER', 'VALUE': 5.0, 'FUNCTION': None},
    '6': {'TYPE': 'NUMBER', 'VALUE': 6.0, 'FUNCTION': None},
    '7': {'TYPE': 'NUMBER', 'VALUE': 7.0, 'FUNCTION': None},
    '8': {'TYPE': 'NUMBER', 'VALUE': 8.0, 'FUNCTION': None},
    '9': {'TYPE': 'NUMBER', 'VALUE': 9.0, 'FUNCTION': None},
    '.': {'TYPE': 'NUMBER', 'VALUE': None, 'FUNCTION': None},
}

词法分析器

文件名为lexer.py

# -*- coding: utf-8 -*-
"""
Created on Mon Nov 23 20:05:45 2020

@author: FishPotatoChen

Copyright (c) 2020 FishPotatoChen All rights reserved.
"""

# 词法分析器

import math
import re

import createtable


class Lexer:
    def __init__(self):
        # 从文件中读取记号表
        self.TOKEN = createtable.TOKEN

    def getToken(self, sentence):
        self.output_list = []
        if sentence:
            tokens = sentence.split()
            for token in tokens:
                try:
                    # No.0
                    # 首先识别直接可以识别的记号
                    # 正规式为ORIGIN|SCALE|ROT|IS|FOR|FROM|TO|STEP|DRAW|ε
                    self.output_token(token)
                    # No.0  识别结束
                except:
                    # 找不到就进入更高级的DFA中识别
                    self.argument_lexer(token)
            self.output_token(';')

    # 构造更为复杂、高级的、多种类的识别表达式
    def argument_lexer(self, argument):
        # 扫描位置
        i = 0
        # 字符串长度
        length = len(argument)
        while(i < length):
            # 临时字符串,即缓冲区
            temp = ''
            if argument[i] in ['P', 'S', 'C', 'L', 'E', 'T', '*']:
                # No.1
                # 识别"*"还是"**"的过程是一个上下文有关文法
                if argument[i] == '*':
                    i += 1
                    if i >= length:
                    	self.output_token(argument[i])
                        break
                    elif argument[i] == '*':
                        self.output_token('**')
                    else:
                        i -= 1
                        self.output_token(argument[i])
                # No.1  识别结束
                else:
                    # No.2
                    # DFA判断全为字母的字符串
                    # 正规式为PI|E|T|SIN|COS|TAN|LOG|EXP|SQRT
                    temp = re.findall(r"[A-Z]+", argument[i:])[0]
                    # 看该串是否接受
                    self.output_token(temp)
                    i += len(temp)-1
                    if i >= length:
                        break
                    # No.2  识别结束
            elif argument[i] in ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.']:
                # No.3
                # 识别数字
                if argument[i] == '.':
                    # 识别开头为"."的数字
                    # 正规式为.[0-9]+
                    # 如:.52=>0.52
                    i += 1
                    temp = re.findall(r"\d+", argument[i:])[0]
                    i += len(temp)-1
                    temp = '0.' + temp
                    self.output_token(temp, False)
                else:
                    # 识别一般数字
                    # 正规式为[0-9]+.?[0-9]*
                    # 如:5.52=>5.52;12=>12
                    temp = re.findall(r"\d+\.?\d*", argument[i:])[0]
                    i += len(temp)-1
                    self.output_token(temp, False)
                if i >= length:
                    break
                # No.3   识别结束
            else:
                # No.4
                # 识别其他字符
                # 正规式为+|-|/|(|)|,|ε
                self.output_token(argument[i])
            i += 1

    # 输出函数
    # 因为解释器可以不用输出至屏幕,但是题目要求输出至屏幕
    # 所以特别写了一个函数用于输出,便于接下来的语法分析器调用文法分析器
    # 当输出不为屏幕时，将输出嵌入代码会变得不好更改
    # 如果写成独立函数，直接更改输出函数即可
    def output_token(self, token, NotNumber=True):
        if NotNumber:
            self.output_list.append([token, self.TOKEN[token]])
        else:
            tempdic = {token: {'TYPE': 'NUMBER',
                               'VALUE': float(token), 'FUNCTION': None}}
            self.output_list.append([token, tempdic[token]])

扫描器

文件名为scanner.py

# -*- coding: utf-8 -*-
"""
Created on Mon Nov 23 20:05:45 2020

@author: FishPotatoChen

Copyright (c) 2020 FishPotatoChen All rights reserved.
"""

# 输入处理器
import re

import lexer


class Scanner():
    def __init__(self, path):
        # 读入文件位置
        self.path = path
        # 设置缓冲区
        self.text = ""
        with open(self.path, "r") as f:
            lines = f.readlines()
            for line in lines:
                # 将文件中注释去掉
                self.text = self.text + \
                    line.split("//")[0].split("--")[0].split("\n")[0]
        self.text = self.text.upper().strip()
        self.lexer = lexer.Lexer()
        self.output_lists = []

    def analyze(self):
        sentences = re.split("(;)", self.text)
        # No.0
        # 识别
        # E->E;|ε
        # 用于记录状态机状态,当state == True时,意味着可以读入一个E,当state == False时,意味着可以读入一个;
        state = True
        for sentence in sentences:
            if state and sentence != ";":
                state = False
                self.lexer.getToken(sentence)
                self.output_lists.extend(self.lexer.output_list)
            elif sentence == ";":
                state = True
            else:
                raise SyntaxError()
        if state:
            raise SyntaxError()
        # No.0   识别结束
        return self.output_lists

语义分析器

语义分析器主体

文件名为myparser.py

# -*- coding: utf-8 -*-
"""
Created on Wed Dec 2 19:36:32 2020

@author: FishPotatoChen

Copyright (c) 2020 FishPotatoChen All rights reserved.
"""

# 语法分析器

import ast
import math
import os

import astunparse

import scanner


class Parser:
    def __init__(self, path):
        # 中间代码生成
        self.state_of_origin = [0, 0]  # 原点默认值
        self.state_of_scale = [1, 1]  # 图像放大默认值
        self.state_of_rot = 0  # 图像旋转默认值
        self.state_of_for = [0, 0, 0]  # 绘图的状态参数
        self.draw = ['', '']  # 画图
        # 中间代码生成结束
        self.scanner = scanner.Scanner(path)
        self.dataflow = self.scanner.analyze()
        self.pos = 0  # 数据读取位置
        self.length = len(self.dataflow)  # 数据流长度

    def analyze(self):
        while(self.pos < self.length):
            # 匹配保留字
            # S->'ORIGIN'T|'SCALE'T|'ROT'T|'FOR'P
            # T->'IS('E','E')'|'IS'E
            # E为一个算数表达式
            # P为FOR后特殊结构
            if self.dataflow[self.pos][1]['TYPE'] == 'KEYWORD':
                self.output(self.dataflow[self.pos][0])

    def output(self, string):
        # 输出
        # 因为输出语句结构相同
        # 所以放在同一个函数中
        # 实际上,语法分析到得到语法树便结束了
        self.pos += 1
        if string == 'ORIGIN':
            self.ORIGIN()
        elif string == 'SCALE':
            self.SCALE()
        elif string == 'ROT':
            self.ROT()
        elif string == 'FOR':
            self.FOR()
            # 输出中间代码
            print((self.state_of_origin, self.state_of_scale,
                   self.state_of_rot, self.state_of_for, self.draw))
        else:
            raise SyntaxError()

    def ORIGIN(self):
        self.matchstring('IS')
        templist = self.matchparameter()
        self.state_of_origin[0] = eval(templist[0])
        self.state_of_origin[1] = eval(templist[1])

    def SCALE(self):
        self.matchstring('IS')
        templist = self.matchparameter()
        self.state_of_scale[0] = eval(templist[0])
        self.state_of_scale[1] = eval(templist[1])

    def ROT(self):
        self.matchstring('IS')
        self.state_of_rot = eval(self.matchexpression())

    def FOR(self):
        self.matchstring('T')
        self.matchstring('FROM')
        self.state_of_for[0] = eval(self.matchexpression())
        self.matchstring('TO')
        self.state_of_for[1] = eval(self.matchexpression())
        self.matchstring('STEP')
        self.state_of_for[2] = eval(self.matchexpression())
        self.matchstring('DRAW')
        templist = self.matchparameter()
        self.draw[0] = templist[0]
        self.draw[1] = templist[1]

    def matchstring(self, string):
        # 匹配一个特定的字符串
        if self.dataflow[self.pos][0] == string:
            self.pos += 1
        else:
            raise SyntaxError()

    # matchparameter与matchexpression的区别
    # 前者匹配双表达式
    # 或者既可以匹配双表达式又可以匹配单表达式
    # 分开原因：
    # 考虑到ROT后面是单表达式而ORIGIN与SCALE后面都是算表达式
    # 并且FOR后面既有单表达式又有双表达式
    # 所以特此区分
    def matchparameter(self):
        # 匹配(E,E)
        # 即匹配参数列表
        # 如：
        # ORIGIN IS (5,5);
        # 后面的括号中包括括号的部分都是参数列表
        temp = self.matchexpression()  # 缓冲区
        # 转换为列表[E,E]
        if temp[0] == '(' and temp[-1] == ')':
            temp = temp[1:-1].split(',')
        else:
            raise SyntaxError()
        return temp

    def matchexpression(self):
        # 匹配E或者(E,E)
        # 即匹配一个算数表达式
        # 如
        # 5*2-LN(3)
        # (5*2-3,tan(0.1))
        temp = ''  # 缓冲区
        while(self.dataflow[self.pos][0] != ';' and self.pos < self.length and self.dataflow[self.pos][1]['TYPE'] != 'KEYWORD'):
            if self.dataflow[self.pos][1]['TYPE'] == 'FUNC':
                temp += self.dataflow[self.pos][1]['FUNCTION']
            elif self.dataflow[self.pos][1]['TYPE'] == 'CONST_ID':
                temp += self.dataflow[self.pos][1]['VALUE']
            else:
                temp += self.dataflow[self.pos][0]
            self.pos += 1
        if self.dataflow[self.pos][0] == ';':
            self.pos += 1  # 跳过结尾的分号
        return temp

主函数

文件名为main.py

# -*- coding: utf-8 -*-
"""
Created on Wed Dec 3 18:27:18 2020

@author: FishPotatoChen

Copyright (c) 2020 FishPotatoChen All rights reserved.
"""

import os

from myparser import Parser

if __name__ == '__main__':
    print('state_of_origin, state_of_scale, state_of_rot, state_of_for, draw')
    path = os.getcwd()
    Parser(path+r'\test.txt').analyze()

测试

测试文件

文件名为test.txt

origin is (100*sin(0.5),100*cos(0.6)); 
origin is (0+tan(0.1),0-ln(e)); 
origin is (10,10);
origin is (0,0); 
origin is (10,10); 
scale is (100,100);
ROT is E/4;
ROT is pi ** 4;
ROT is pi /4*5;
ROT is sin( 4.5)*cos(3.5);
ROT is pi/4;
for t from 0 to pi step pi/50 draw (cos(t),sin(t));



origin is (0+tan(0.1),0-ln(e)); 
origin is (10,10);
origin is (0,0); 
scale is (100,100/3);
ROT is E/4;
ROT is pi ** 4;
ROT is pi /4*5;
for t from 0 to pi*5 step pi/5 draw (cos(5*t),sin(t));

测试结果

state_of_origin, state_of_scale, state_of_rot, state_of_for, draw
([10, 10], [100, 100], 0.7853981633974483, [0, 3.141592653589793, 0.06283185307179587], ['math.cos(T)', 'math.sin(T)'])
([0, 0], [100, 33.333333333333336], 3.9269908169872414, [0, 15.707963267948966, 0.6283185307179586], ['math.cos(5*T)', 'math.sin(T)'])

结果解释

state_of_origin, state_of_scale, state_of_rot, state_of_for, draw依次为平移状态(X轴，Y轴)，比例放缩状态(X轴，Y轴)，旋转状态(弧度制)，FOR循环状态(开始，结尾，步长)，画图语句(X=f(T) ，Y=g(T))。

代码说明

很明显，语法分析器生成中间代码，6+2图我们已经生成了中间代码，并且这个中间代码是已经优化过的。

FishPotatoChen
关注
专栏目录
编译原理-语义分析器（C语言源码）
06-01
编译原理语义分析器，实现分析部分C语言的语法成分，将其翻译成三地址代码。
编译原理（词法、语法、语义分析器）
01-13
以计算器危机春，实现编译原理中的词法、语法、语义分析，编写成的词法、语法、语义分析器，用vs2010编写
编译原理实验语义分析器
01-12
表达式计算器的语法、语义分析器的设计与实现（输出四元式的中间结果和最终的运算结果）。 在实验一词法分析的基础上，以词法分析输出结果（单词串或者成为多元式序列）作为该语法语义分析器的输入，最后输出中间代码四元式序列，并计算出表达式最后的结果。采用优先算符算法。
编译原理 语义分析器
weixin_43973089的博客
05-23 6922
实验五 语义分析器一、实验目的二、实验任务三、实验内容（一）学习经典的语义分析器1.选择一个编译器2.阅读语义分析源程序并理解3.理解符号表的定义4.测试语义分析器（二）实现一门语言的语义分析器四、系统设计（C-语言的语义分析器）1.完成C－语言的符号表的定义设计。规划类型检查/推论的实现方法。1.1.文件结构1.2.重要数据结构（符号表的设计）1.3.符号表的组成1.4.符号表图示1.5.简单规划设计2.仿照前面学习的语义分析器，编写选定语言的语义分析器。2.1.主函数main2.2.Semantic_p
语义分析器—编译原理
09-25
语义分析器，完成基本语义分析功能，加深对理论知识的理解
编译原理上机实验
12-19
本次上机实验是基于C++来实现一个简单的函数绘图语言，目的是通过编程实践来加深对编译原理的理解。 首先，我们要构建词法分析器（Tokenizer）。词法分析是将源代码分解成一个个有意义的单元——词法单元或标记...
编译原理上机实验 关于正规式 产生式 编写词法分析器
06-17
编译原理上机实验关于正规式产生式编写词法分析器 本实验的目的是通过编写一个简单的函数绘图语言解释器，掌握语言翻译的基本方法，特别是语言识别的基本方法。实验的过程可以分为三个步骤：词法分析、语法分析和...
西电 编译原理上级报告
06-14
《西电 编译原理上级报告》探讨了如何构建一个解释器来处理简单的函数绘图语言，这个解释器能够接收并解析用特定绘图语言编写的源程序，然后在屏幕上直接展示程序定义的图形。实验的主要目标是让学生通过实际操作...
编译原理词法语法语义分析器
01-13
这是编译原理的分析器，一直做到了中间代码生成。词法分析能识别基本的c语言的语言元素，语法分析用了预测分析法，递归下降法。语义分析也做了，能够识别赋值，循环，条件等多种语句。
编译原理实验2《语义分析器》
12-21
实验二：表达式计算器的语法、语义分析器的设计与实现（输出四元式的中间结果和最终的运算结果）。 在实验一词法分析的基础上，以词法分析输出结果（单词串或者成为多元式序列）作为该语法语义分析器的输入，最后输出中间代码四元式序列，并计算出表达式最后的结果。（共8个上机学时，时间不够的请自己课下找时间补完） 实现方法上，建议大家采用算符优先分析法或者LR分析方法，进行语法制导翻译。先根据上述文法中的“表达式定义”构造算符优先关系表或者LR分析表进行语法分析。 检查要求： e) 启动程序后，先输出作者姓名、班级、学号（可用汉语、英语或拼音）。 f) 请求输入测试程序名，键入程序名后自动开始编译。 g) 输出四元式中间代码（样式见样板输出3）。 h) 能发现程序的语法错误并输出出错信息（样式见样板输出4）。
语义分析器
04-30
prog -> { decs stms } decs -> dec decs | dec -> type id ; type -> int | bool stms -> stm stms | stm -> id = exp ; | printi(exp) ; | printb(exp) ; exp -> intnum | true | false | id | (exp) | exp + exp | exp - exp | exp * exp | exp / exp | exp && exp | exp || exp
编译原理-语义分析
05-11
选择部分C语言的语法成分（可参考附录C.5）或选择附录C.3的简单语言，采用递归下降的语法制导翻译技术，设计一个一遍扫描的词法语法语义分析程序。 注意与实验1、2的衔接。 •内容：设计并实现一个一遍扫描的词法语法语义分析程序，将多条简单赋值语句翻译成后缀式或三地址代码，要求有一定的出错提示和错误恢复功能。 实验报告内容要求：要给出所分析简单语言语法结构的词法说明、上下文无关文法描述，单词的种别编码方案，词法分析程序的主要算法思想，以及所采用的语法语义分析方法的算法思想的详细描述，测试结果与分析，实验总结等。
函数绘图语言编写一个解释器c实现
01-05
解释器接受用绘图语言编写的源程序，经语法和语义分析之后，将源程序所规定的图形显示在显示屏（或窗口）中。（命令行窗口使用）
编译原理课程设计——语义分析器
hujiaxuan1995的专栏
10-31 2952
#include #include #include #include #define max 20 void scaner(); int digit(char ch); int letter(char ch); char **variable;//定义用户自变量信息表 FILE *fpw; FILE *fprt; void P();//递归下降主控制程序 void Parse();
编译原理实验六：语义分析器
热门推荐
裕东方的博客
04-12 1万+
（一）学习经典的语义分析器（2小时） 实验目的 学习已有编译器的经典语义分析源程序。 实验任务 阅读已有编译器的经典语义分析源程序，并测试语义分析器的输出。 实验内容 （1）选择一个编译器，如：TINY或PL/0，其它编译器也可（需自备源代码）。 （2）阅读语义分析源程序，加上你自己的理解。尤其要求对相关函数与重要变量的作用与功能进行稍微详细的描述。若能加上学习心得则更好。TI...
LLVM系列第十四章：写一个简单的语义分析器Semantic Analyzer
Zhanglin_Wu的专栏, C++, Scrum, LLVM, 编译器
06-03 2500
基于LLVM提供的API，用C++写一个很简单的词法分析器Semantic Analyzer
编译原理语法分析器_编译原理踩点
weixin_39788256的博客
12-01 887
基础及前言编译器由 analysis 分析（也称为前端部分）、synthesis 综合（也称为后端部分）两部分构成。编译器执行的各 phase 步骤如下：词法分析 lexical analysis：将字符流源程序解析成 token 词法单元。这一部分将收集源程序的变量信息，并存入 symbol table 符号表。语法分析 syntax analysis：构建词法单元的语法结构 —— syntax...
南开大学编译原理：语义分析——类型检查与转换详解
在南开大学编译原理课程中，语义分析是编译过程中的重要环节，主要关注类型检查与转换。这个阶段的核心任务是对源代码的语义进行深入理解和验证，确保程序的正确性和执行效率。课程内容包括以下几个部分： 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FishPotatoChen

谢谢您的支持，我会更努力的~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值