【编译原理】词法分析器

已于 2024-01-30 09:48:42 修改
阅读量456 收藏 6
点赞数 9
分类专栏： 编译原理 文章标签： python 编译原理
于 2023-12-27 11:41:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61839115/article/details/135241434
版权

【避雷】实验课打分离谱，同学一次性LL1语法分析器及参考我博客的同学分数还比我高，狠狠避雷

【编译原理】词法分析器

实验要求：

设置一个名字表NameL和常数表ConstL，当遇到标识符时，将其字符串送入名字表NameL，并把其名字表地址作为标识符的语义Seman值。常数情形也一样，不要求翻译成二进制数。要求在NameL和ConstL表中没有相同元素，同时具有简单的错误处理功能（找出源程序中所有存在的词法错误并指出错误所在的行数）。试用高级程序设计语言编写一个针对下述单词集的词法分析器。

token表

在这里插入图片描述

评分标准

①是否使用文件输入、输出；
②是否可以查找多个错误；
③每个错误是否有错误提示，包括错误所在行、错误信息；
④错误提示信息是否区分不同类别；
⑤同名标识符或常数是否重复存放；
⑥是否正确建立单词表和名字表、常量表的链接；
⑦是否处理注释。

词法分析器

import re


class MyToken:
    def __init__(self, MyType, seman, MyStr):
        self.MyType = MyType
        self.seman = seman
        self.MyStr = MyStr

    def __str__(self):
        s = self.MyStr.replace('\n','')
        return "token.class:  {:5}\t\tstr:  {:10}\tseman:\t{} \t".format(self.MyType, s, self.seman)


# 单词集状态列表
states = ['if', 'else', 'for', 'while', 'break', 'return', 'continue', 'float', 'int', 'char', '标识符',
          '正整数、正实数、零', '+', '-',
          '*', '/', '%', '>', '>=', '<', '<=', '!=', '==', '!', '&', '|', ',', '=', '[', ']', '(', ')', '{', '}', ';',
          '.', '\\', '#']
choiceStatec = [13, 14, 15, 16, 17, 18, 20, 24, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]  # 用于防止while循环中出现多次elif
inputs = []  # 输入的字符


tokens = []  # 单词表
NameL = []  # 名字表
ConstL = []  # 常数表



i = 0
line = 1



# 将文件内容提取到inputs
def codeToInputs(sourceCodes):
    for line in sourceCodes:
        for char in line:
            inputs.append(char)
            if char == '#':
                return


# 判断是否为字母
def isLetter(char):
    pattern = r"[a-zA-Z]"
    return bool(re.match(pattern, char))


# 判断是否为数字
def isDigit(char):
    pattern = r"[0-9]"
    return bool(re.match(pattern, char))


# 普通的字符识别
def isC(char, state):
    tokens.append(MyToken(state, "^", char))


def choiceState(char):  # 选择单字符对应状态
    state = 0
    if char in states:
        for k in range(len(states)):
            if states[k] == char:  # 判断单个字符
                if char in ['>', '<', '!', '=', '&', '|', '\\'] and inputs[i] in ['=', '&', '|', 'n']:  # 如果是双字符
                    state = 19
                else:
                    state = k + 1
    else:
        state = 0
    return state


def error():
    print(f"第{line}行---未知字符错误")


# 词法分析
def nextToken():
    global i
    global line
    name = ""
    char = inputs[i]
    i += 1
    while char == ' ' or char == '\n' or char == '\t':  # 如果是空就跳过
        if char == '\n':
            line += 1
        char = inputs[i]
        i += 1
        if char == '#':
            i -= 1
    global state
    state = 0
    while True:

        if state == 0:  # 选择
            if char == '#':
                i -= 1
                state = 38
                continue
            if char == '/' and (inputs[i] == '/' or inputs[i] == '*'):  # 注释
                state = 42
                continue
            if choiceState(char) != 0:  # 判断后面的单字符，获取状态
                state = choiceState(char)
                i -= 1
                continue
            if char == "i":
                state = 1
            elif char == "e":
                state = 2
            elif char == 'f':
                state = 3
            elif char == 'w':
                state = 4
            elif char == 'b':
                state = 5
            elif char == 'r':
                state = 6
            elif char == 'c':
                state = 7
            elif isDigit(char):  # 数字
                state = 12
            elif isLetter(char):  # 字符串
                i -= 1
                state = 11

            else:
                error()  # 非法字符报错
                i -= 1
                state = 38
        elif state == 1:  # if

            if inputs[i] == 'f':  # 判断第二个是否为f
                if isDigit(inputs[i + 1]) or isLetter(inputs[i + 1]):  # 标识符
                    i -= 1
                    state = 11
                else:
                    m = MyToken(1, "^", "if")  # 在单词表和名字表加入
                    tokens.append(m)
                    state = 38

            elif inputs[i] == 'n':  # 判断第二个是否为n
                i += 1
                if inputs[i] == 't':
                    if isDigit(inputs[i + 1]) or isLetter(inputs[i + 1]):  # 标识符
                        i -= 2
                        state = 11
                    else:
                        m = MyToken(9, "^", "int")  # 在单词表和名字表加入
                        tokens.append(m)
                        state = 38
                else:
                    if isDigit(inputs[i]) or isLetter(inputs[i]):  # 标识符
                        i -= 2
                        state = 11
                    else:
                        m = MyToken(11, "^", "in")  # 在单词表和名字表加入
                        tokens.append(m)
                        state = 38
                        i -= 1
            else:  # 以i开头的标识符
                i -= 1
                state = 11

        elif state == 2:  # else
            if ''.join(inputs[i:i + 3]) == 'lse':
                if isDigit(inputs[i + 3]) or isLetter(inputs[i + 3]):
                    i -= 1
                    state = 11
                else:
                    m = MyToken(2, "^", "else")  # 在单词表和名字表加入
                    tokens.append(m)
                    state = 38
                    i += 2
            else:
                i -= 1
                state = 11

        elif state == 3:  # for

            if inputs[i] == 'o':
                if inputs[i + 1] == 'r':
                    if isDigit(inputs[i + 2]) or isLetter(inputs[i + 2]):
                        i -= 1
                        state = 11
                    else:
                        m = MyToken(3, "^", "for")  # 在单词表和名字表加入
                        tokens.append(m)
                        state = 38
                        i += 1
                else:
                    i -= 1
                    state = 11
            elif inputs[i] == 'l':
                if "".join(inputs[i:i + 4]) == 'loat':
                    if isDigit(inputs[i + 4]) or isLetter(inputs[i + 4]):
                        i -= 1
                        state = 11
                    else:
                        m = MyToken(8, "^", "float")  # 在单词表和名字表加入
                        tokens.append(m)
                        state = 38
                        i += 3
                else:
                    i -= 1
                    state = 11
            else:
                i -= 1
                state = 11

        elif state == 4:  # while
            if "".join(inputs[i:i + 4]) == 'hile':
                if isDigit(inputs[i + 4]) or isLetter(inputs[i + 4]):
                    i -= 1
                    state = 11
                else:
                    m = MyToken(4, "^", "while")  # 在单词表和名字表加入
                    tokens.append(m)
                    state = 38
                    i += 3
            else:
                i -= 1
                state = 11


        elif state == 5:  # break
            if "".join(inputs[i:i + 4]) == 'reak':
                if isDigit(inputs[i + 4]) or isLetter(inputs[i + 4]):
                    i -= 1
                    state = 11
                else:
                    m = MyToken(5, "^", "break")  # 在单词表和名字表加入
                    tokens.append(m)
                    state = 38
                    i += 3
            else:
                i -= 1
                state = 11

        elif state == 6:  # return
            if "".join(inputs[i:i + 5]) == 'eturn':
                if isDigit(inputs[i + 5]) or isLetter(inputs[i + 5]):
                    i -= 1
                    state = 11
                else:
                    m = MyToken(6, "^", "return")  # 在单词表和名字表加入
                    tokens.append(m)
                    state = 38
                    i += 4
            else:
                i -= 1
                state = 11

        elif state == 7:  # continue
            if inputs[i] == 'o':
                if "".join(inputs[i + 1:i + 7]) == 'ntinue':
                    if isDigit(inputs[i + 7]) or isLetter(inputs[i + 7]):
                        i -= 1
                        state = 11
                    else:
                        m = MyToken(7, "^", "continue")  # 在单词表和名字表加入
                        tokens.append(m)
                        state = 38
                        i += 6
                else:
                    i -= 1
                    state = 11

            elif inputs[i] == 'h':
                if "".join(inputs[i + 1:i + 3]) == 'ar':
                    if isDigit(inputs[i + 3]) or isLetter(inputs[i + 3]):
                        i -= 1
                        state = 11
                    else:
                        m = MyToken(10, "^", "char")  # 在单词表和名字表加入
                        tokens.append(m)
                        state = 38
                        i += 2
                else:
                    state = 11
                    i -= 1
            else:
                i -= 1
                state = 11
        elif state == 11:  # 标识符
            char = inputs[i]
            i += 1
            name += char
            if isLetter(char):
                state = 39
            else:
                state = 40

        elif state == 12:

            name += char
            char = inputs[i]
            if isDigit(inputs[i]):  # 判断数字
                i += 1
                state = 12
            else:
                if inputs[i] == ' ' or inputs[i] == '\n' or inputs[i] == '\t' or inputs[i] == '#':

                    flag = 0
                    index = -1
                    for ii in range(len(ConstL)):
                        if ConstL[ii].MyStr == name:
                            flag = 1
                            index = ii
                    if flag == 1:
                        tokens.append(MyToken(12, index, name))

                    else:
                        ConstL.append(MyToken(12, len(ConstL), name))
                        tokens.append(MyToken(12, len(ConstL)-1, name))

                else:
                    print(f"第{line}行---标识符错误")
                    char = inputs[i]
                    while char != ' ' and char != '\t' and char != '\n' and char != '#':
                        i += 1
                        char = inputs[i]
                state = 38
                i -= 1

        elif state == 19:  # 处理双字符
            m = ""
            if inputs[i] == '>' and inputs[i + 1] == '=':
                m = MyToken(19, "^", ">=")
            if inputs[i] == '<' and inputs[i + 1] == '=':
                m = MyToken(21, "^", "<=")
            if inputs[i] == '!' and inputs[i + 1] == '=':
                m = MyToken(22, "^", "!=")
            if inputs[i] == '=' and inputs[i + 1] == '=':
                m = MyToken(23, "^", "==")
            if inputs[i] == '&' and inputs[i + 1] == '&':
                m = MyToken(25, "^", "&&")
            if inputs[i] == '|' and inputs[i + 1] == '|':
                m = MyToken(26, "^", "||")
            if inputs[i] == '\\' and inputs[i + 1] == 'n':
                m = MyToken(37, "^", "\\n")
            tokens.append(m)
            i += 1
            return

        elif state == 38:  # 文件结束
            return
        elif state == 39:  # 处理标识符
            char = inputs[i]
            i += 1
            if char == '#':
                i -= 1
                state = 40
                continue

            if isDigit(char) or isLetter(char):
                state = 39
                if char != '\n':
                    name += char
                else:
                    line += 1

            else:  # 不是字母和数字，就不是标识符了
                state = 40
        elif state == 40:
            flag = 0
            index = -1
            for ii in range(len(NameL)):
                if NameL[ii].MyStr == name:
                    flag = 1
                    index = ii
            if flag == 1:
                tokens.append(MyToken(11, index, name))

            else:
                NameL.append(MyToken(11, len(NameL), name))
                tokens.append(MyToken(11, len(NameL)-1, name))


            i -= 2  # 外面的while+1，所以这里要-1
            if char == '#':
                i += 1
            try:
                if states.index(char) and char != '#':  # 如果有字符
                    name = name[:-1]
                    state = 41

            except:
                pass
            return
        elif state == 41:
            st = states.index(char)
            isC(char, st)
            i -= 1
            return
        elif state == 42:  # 处理注释 // /**/
            if inputs[i] == '/':  # //注释
                i += 1
                char = inputs[i]
                while char != '\n':
                    i += 1
                    char = inputs[i]
                i += 1
                state = 0
            pass
        elif state in choiceStatec:
            isC(states[state - 1], state)  # 普通的字符识别
            return
        else:
            pass


# 从文件读取内容
def readSourceCode(read_path):
    with open(read_path, "r") as file:
        lines = file.readlines()
    return lines

# def sort_by_type(token):
#     return token.MyType


# 将单词表输出到文件
def writeTokens(tokens,Name,Const):
    with open("tokens.txt", "w") as file:
        for token in tokens:
            file.write(f"{token}\n")
    with open("NameL.txt","w") as file:
        for n in Name:
            file.write(str(n)+"\n")
    with open("ConstL.txt", "w") as file:
        for c in Const:
            file.write(str(c)+"\n")

if __name__ == '__main__':
    read_path = 'source_code.txt'
    sourceCodes = readSourceCode(read_path)
    codeToInputs(sourceCodes)
    while inputs[i] != '#':
        nextToken()
        i += 1
    tokens.append(MyToken(38, "^", "#"))  # 最后一个
    writeTokens(tokens,NameL,ConstL)




"""
设置一个名字表NameL和常数表ConstL，当遇到标识符时，将其字符串送入名字表NameL，并把其名字表地址作为标识符的语义Seman值。
常数情形也一样，不要求翻译成二进制数。
要求在NameL和ConstL表中没有相同元素，同时具有简单的错误处理功能（找出源程序中所有存在的词法错误并指出错误所在的行数）。
试用高级程序设计语言编写一个针对下述单词集的词法分析器
"""
# 单词       编码  语义
# if         1     空（^）
# else       2     空（^）
# for        3     空（^）
# while      4     空（^）
# break      5     空（^）
# return     6     空（^）
# continue   7     空（^）
# float      8     空（^）
# int        9     空（^）
# char       10    空（^）
# 标识符      11    名字表地址
# 正整数      12    常数表地址
# 正实数      12    常数表地址
# 零         12    常数表地址
# +          13    空（^）
# -          14    空（^）
# *          15    空（^）
# /          16    空（^）
# %          17    空（^）
# >          18    空（^）
# >=         19    空（^）
# <          20    空（^）
# <=         21    空（^）
# !=         22    空（^）
# ==         23    空（^）
# !          24    空（^）
# &&         25    空（^）
# ||         26    空（^）
# ,          27    空（^）
# =          28    空（^）
# [          29    空（^）
# ]          30    空（^）
# (          31    空（^）
# )          32    空（^）
# {          33    空（^）
# }          34    空（^）
# ;          35    空（^）
# .          36    空（^）
# 换行符      37    空（^）
# 文件结束    38    空（^）

运行

首先创建：source_code.txt

123 456 123
while ( i < 0 )
    if i > 1
        return
    else
        i += 1
for ( int i = 0 ; i <= 3 ; i += 1 )
    flag += 1
    if flag == 10
        continue
int j = 0 ;
#

执行后，会在同目录下生成三个文件：
tokens.txt、NameL.txt、ConstL.txt

token.txt内容如下：
在这里插入图片描述

Leekos
关注
  • 9
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编译原理词法分析器_编译原理_词法分析_
09-30
a)启动程序，请求输入测试程序名，键入程序名后自动开始词法分析并输出结果；b)输出结果为单词的二元式序列（样式见样板输出1和2）；c)要求能发现下列词法错误和指出错误性质和位置：非法字符，即不是SAMPLE字符集的...
编译原理词法分析器（C/C++）
热门推荐
沉在海里的鱼的博客
03-24 1万+
词法分析器不用多说，一开始我还不知道是什么样的，看了下别人的博客，再看看书，原来是输出二元组，这不就是字符串操作嘛。然后细看几篇博客，发现大都是用暴力判断来写的。我对代码重复性比较高的方法不太感冒，不是说我编程有多好，就是单纯的不喜欢。于是我就想到了用偏移量的方法，先弄好单词分类器，再用几个数组将关键字、运算符、界符的所有定义的字符串保存为全局变量，顺序要按单词分类器的顺序，然后根据这三种字符串在表中的位置，定一个偏移量。
编译原理 词法分析器 实验报告
qq_62385631的博客
10-05 413
测试数据： 源程序： #include "math.h" main() { float a,b,y1,y2;int c,d,e;4.设计扫描器 把扫描器作为语法分析的一个过程，当语法分析需要一个单词时，就调用扫描器。扫描器从初态出发，当识别一个单词后便进入终态，送出二元式。3.把各转换图的初态连在一起，构成识别该语言的自动机。
【编译原理】手工打造词法分析器
笨鸟先飞的博客
03-28 326
带你手工打造词法分析器
编译原理词法分析器——C语言实现
秋刀鱼丢了水蜜桃
10-31 6646
词法分析器 （一）基本内容 实现一个可以识别C语言（子集）词法的程序，识别源代码中的每个词，并且将结果保存下来。 可识别的词包括 头文件：以#include开头的过滤为头文件 保留字：“auto”, “break”, “case”, “char”, “const”, “continue”, “default”, “do”, “double”, “else”, “enum”, “extern”,“f...
编译原理词法分析器
soxia的博客
11-02 942
编译原理词法分析器代码 编译原理词法分析器代码 记得输入好路径例如D:\test.txt;讲指定文件导入测试。 编译原理 词法分析器 // // //(1)按规则拼写单词，并转换成二元式形式。 //(2)删除注释行。 //(3)删除空白符。 //(4)列表打印源程序，按照源程序的行打印，在每行的前面加上行号，并且打印出每行包含的二元形式。 //(5)发现并定位错误。 // #incl...
编译原理——词法分析器
wen3017的博客
12-18 1万+
编译原理词法分析器
编译原理实验词法分析器
01-02
编译原理实验词法分析器
【Python】Python中变量或者函数加下划线‘_‘的含义
yangweipeng708的博客
05-14 670
理解这些约定可以帮助Python开发者编写更清晰、更Pythonic的代码，并理解其他Python代码中的命名习惯。）通常用来指示特定的编程约定或用法，这些约定主要关乎变量和函数的可访问性以及预期的使用范围。在Python中，变量或函数前面加一个下划线（
python数据分析numpy基础之intersect1d求数组交集
sinat_34735632的博客
05-19 190
python的numpy库的intersect1d(x,y)函数，计算x和y的公共元素，并返回去重后的有序结果。相当于求两个数组中的交集，并且进行去重和排序。numpy.intersect1()查找两个数组的公共元素，并且返回去重后的有序结果。ar1，ar2：必选，列表、元组、数组；如果是多维则自动转一维数组；assume_unique：可选，bool，默认False，若为True则可以加快计算素材，此时ar1和ar2需为元素唯一的数组，否则结果不会去重；
windows11 Django环境安装
云深海阔专栏
05-15 153
3）在这个文件夹中使用manager.py和runserver命令运行开发 web 服务器。2）使用 django-admin 工具创建一个名为“mytestsite”的新框架站点。浏览器上访问http://localhost:800。2、windows10 虚拟环境设置。1、验证python和pip3环境。1）创建文件夹及项目目录。4）web浏览器上验证。3、安装Django。
python数据分析——时间序列
qq_74013365的博客
05-14 1991
时间序列是按照时间顺序排列的一系列随时间变化而变化的数据点或观测值。时间序列可以是离散的，例如每月的销售数据，也可以是连续的，例如气温和股票价格等。时间序列常用于预测和分析未来的趋势，例如经济增长、股票走势、天气变化等。时间序列分析是数据分析中的重要部分，它涉及到对随时间变化的数据进行研究，以揭示其内在规律、趋势和周期性变化。Python作为一种强大的编程语言，拥有众多的数据处理和可视化库，如pandasnumpymatplotlib和seaborn等，这些库在处理时间序列数据时表现出色。
代码随想录算法训练营第二十八天|​216.组合总和III​、17.电话号码的字母组合
qq_52149213的博客
05-14 526
回溯法第二天
Gradio 案例——将 dicom 文件转为 nii文件
蒋含竹的博客
05-15 356
Gradio 的WEB界面案例：利用 SimpleITK 库，将 dicom 文件转为 nii文件
【华为OD机试-C卷D卷-200分】 简易内存池【C++/Java/Python】
goldarmour的博客
05-14 160
请实现一个简易内存池,根据请求命令完成内存分配和释放。 内存池支持两种操作命令，REQUEST和RELEASE，其格式为： REQUEST=请求的内存大小 表示请求分配指定大小内存，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输出error。 RELEASE=释放的内存首地址 表示释放掉之前分配的内存，释放成功无需输出，如果释放不存在的首地址则输出error。
python EEL + vue3.js 简单示例
bigcarp的专栏
05-15 185
eel官方示例中暴露的js函数是全局函数，vue中的自定义函数作用域通常都是组件范围内。要让eel.js调用，需要将其升为全局可用。一般方法有 app.config.globalProperties 或 mixin等。
Python slice() 使用方法及示例说明
ym62033的博客
05-15 193
处。
用python进行“个税计算”
最新发布
算法与编程之美
05-20 69
1 问题企业发放的奖金根据利润来提成。利润(I)低于或等于5万元时，奖金可提10%；利润高于5万元，低于20万元时，低于5万元的部分按10%提成，高于5万元的部分，可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键...
编译原理 词法分析器
09-19
编译原理中的词法分析器是编译过程中的第一个阶段，用于将源代码分割成一个个的词法单元。词法分析器需要根据给定的词法规则，将输入的源代码转化为一个个的标记(token)，并生成相应的二元组。对于C语言子集的词法分析，可以采用结构体来表示词法单元的二元组，以便于后续的处理。 在设计和实现词法分析器时，需要考虑以下几个方面： 1. 定义词法规则：根据C语言的词法定义，确定各种词法单元的规则，例如标识符、关键字、常量、运算符等。 2. 构建有限自动机：根据词法规则，设计有限自动机来识别不同的词法单元。有限自动机可以采用手工编码或者使用词法分析工具如Lex进行构建。 3. 实现预处理功能：词法分析器可以包含预处理功能，例如去除注释、处理宏定义等。 4. 错误处理：对于不符合词法规则的输入，需要进行错误处理，例如报错或者尝试进行修复。 5. 生成二元组：根据识别到的词法单元，生成相应的二元组，以便后续的语法分析和语义分析。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值