• 编译原理实验--实验二 递归下降法判断算术表达式的正确性--Python实现

    目录

    一、实验目的和要求

    二、实验内容

    三、实验环境

    四、实验步骤

    1、语法分析所依据的文法；

    2、给出消除左递归及提取左公因子的文法；

    五、测试要求

    六、实验步骤

    1、语法分析所依据的文法

    2、给出消除左递归及提取左公因子的文法；

    3、关键代码

    七、实验结果与分析

     

    一、实验目的和要求

    1. 理解自顶向下语法分析方法；
    2. 用递归下降技术实现语法分析器；

    二、实验内容

            算术表达式的文法是G[E]：

    E→E+T| E-T| T

    T→T*F| T/F| F

    F→(E)| i

            用递归下降分析法按文法G[E]对算术表达式（包括+、-、*、/、（）的算术表达式）进行语法分析，判断该表达式是否正确。

    三、实验环境

    处理器     AMD Ryzen 7 5800H with Radeon Graphics3.20 GHz

    机带RAM   16.0 GB(13.9 GB可用)

    Win10家庭版20H2 X64  

    PyCharm 2012.2

    Python 3.10

    四、实验步骤

    1、准备：阅读课本有关章节，将上述算术表达式的文法改造成LL(1)文法（即消除左递归和提取左公因子）；

    2、参考课件P52编写递归下降分析程序。

    1、语法分析所依据的文法；

         算术表达式的文法是G[E]：

    E→E+T| E-T| T

    T→T*F| T/F| F

    F→(E)| i

    2、给出消除左递归及提取左公因子的文法；

    将文法G[E]改造为LL(1)文法如下：

    G’[E]：

    E →  TE’

    E’ → +TE’| -TE’|ε

    T  →  FT’

    T’→  *FT’|/FT’|ε

    F  → (E)| i

    五、测试要求

    1、为降低难度，表达式中不含变量，只含单个无符号整数或i；

    2、如果遇到错误的表达式，应输出错误提示信息（该信息越详细越好）；

    3、测试用的表达式建议事先放在文本文件中，一行存放一个表达式，以分号结束。而语法分析程序的输出结果写在另一个文本文件中；

    4、程序输入/输出示例：

    输入如下表达式（以分号为结束）和输出结果：

    （a）i;  或  1;

    输出：正确

    （b）i+i; 或 1+2;

    输出：正确

    （c）(i+i)*i+i-(i+i*i);  或 (1+2)*3+4-(5+6*7);

    输出：正确

    （d）((i+i)*i+i;    或 ((1+2)*3+4;  

    输出：错误，缺少右括号

    （e）i+i+i+(*i/i);   或   1+2+3+(*4/5)

    输出：错误

    5、选作：对学有余力的同学，可增加功能：当判断一个表达式正确时，输出计算结果。

    六、实验步骤

    1、语法分析所依据的文法

         算术表达式的文法是G[E]：

    E→E+T| E-T| T

    T→T*F| T/F| F

    F→(E)| i

    2、给出消除左递归及提取左公因子的文法；

    将文法G[E]改造为LL(1)文法如下：

    G’[E]：

    E →  TE’

    E’ → +TE’| -TE’|ε

    T  →  FT’

    T’→  *FT’|/FT’|ε

    F  → (E)| i

    3、关键代码

    1. '''
    2. 在实验一的基础上进行语法分析
    3. 递归下降分析法
    4. E→TE'
    5. E'→+TE'| -TE' |ε
    6. T→FT'
    7. T'→*FT'| /FT' |ε
    8. F→(E) | id |num
    10. 保留关键字及种别编码
    11. Static_word = {"begin": 1, "end": 2, "if": 3, "then": 4, "while": 5,
    12.                "do": 6, "const": 7, "var": 8, "call": 9, "procedure": 10}
    14. 算符和界符及种别编码
    15. Punctuation_marks = {"+": 11, "-": 12, "*": 13, "/": 14, "odd": 15, "=": 16, "<>": 17, "<": 18, ">": 19,
    16.                      "<=": 20, ">=": 21, ":=": 22, "(": 23, ")": 24, ".": 25, ",": 26, ";": 27}
    18. 常数的种别编码为28，标识符的种别编码为29，非法字符的种别编码为30
    19. '''
    20. # 导入词法分析的程序
    21. from cifafenxi_rtda import *
    22.  
    23. # 由于实验二的特殊性，单独把i(id)当做保留字处理
    24. Static_word["i"] = 0
    25.  
    26. # i + - * 、 ( ) num的种别编码
    27. Lab2_word = [0, 11, 12, 13, 14, 23, 24, 28]
    28.  
    29. # 出错标志
    30. Err = 0
    31.  
    32. # 位置标志
    33. Index = 0
    34.  
    35. # 算术表达式是否符合文法
    36. Correct = "***************正确！"
    37. Error = "*************错误!"
    38.  
    39.  
    40. # 语法分析结果写入文件
    41. def WriteFile(string):
    42.     fW = open(pathW, 'a')
    43.     fW.write(string + "\n")
    44.     fW.close()
    45.  
    46.  
    47. # 开始正式语法分析前首先判断该算术表达式中的各个字符以及首尾字符是否符合要求
    48. def First():
    49.     index = 0
    50.     if (Result_Lex[0][0] in [0, 23, 28]) and (Result_Lex[0][-1] in [0, 24, 28]):
    51.         for i in Result_Lex[:-2]:
    52.             if i not in Lab2_word:
    53.                 index += 1
    54.                 break
    55.             else:
    56.                 continue
    57.     else:
    58.         index += 1
    59.     return index
    60.  
    61.  
    62. # E→TE'
    63. def E():
    64.     global Err
    65.     if Err == 0:
    66.         T()
    67.         E1()
    68.  
    69.  
    70. # E'→+TE'| -TE' |ε
    71. def E1():
    72.     global Err, Index
    73.     if Err == 0 and Index != len(Result_Lex[0]):
    74.         if Result_Lex[0][Index] in [11, 12]:
    75.             Index += 1
    76.             if Index != len(Result_Lex[0]) - 1:
    77.                 T()
    78.                 E1()
    79.             else:
    80.                 Index = len(Result_Lex[0])
    81.         elif Result_Lex[0][Index] != 24:
    82.             Err = 1
    83.  
    84.  
    85. # T→FT'
    86. def T():
    87.     global Err
    88.     if Err == 0:
    89.         F()
    90.         T1()
    91.  
    92.  
    93. # T'→*FT'| /FT' |ε
    94. def T1():
    95.     global Err, Index
    96.     if Err == 0 and Index != len(Result_Lex[0]):
    97.         if Result_Lex[0][Index] in [13, 14]:
    98.             Index += 1
    99.             if Index != len(Result_Lex[0]) - 1:
    100.                 F()
    101.                 T1()
    102.             else:
    103.                 Index = len(Result_Lex[0])
    104.         elif Result_Lex[0][Index] not in [11, 12, 24]:
    105.             Err = 1
    106.  
    107.  
    108. # F→(E) | id |num
    109. def F():
    110.     global Err, Index
    111.     if Err == 0:
    112.         if Result_Lex[0][Index] in [0, 28]:
    113.             Index += 1
    114.         elif Result_Lex[0][Index] == 23:
    115.             Index += 1
    116.             E()
    117.             if Result_Lex[0][Index] != 24:
    118.                 Err = 1
    119.  
    120.             Index += 1
    121.         else:
    122.             Err = 1
    123.  
    124.  
    125. # 分析主程序
    126. def Analysis_Gs():
    127.     global Err, Index
    128.     if First() == 0:
    129.         F()
    130.         while Index < len(Result_Lex[0]):
    131.             if Result_Lex[0][Index] in [11, 12]:
    132.                 E1()
    133.             elif Result_Lex[0][Index] in [13, 14]:
    134.                 T1()
    135.             else:
    136.                 Index = len(Result_Lex[0])
    137.                 Err = 1
    138.  
    139.         if Err == 0:
    140.             print("语法分析结果：" + Correct)
    141.         else:
    142.             print("语法分析结果：" + Error)
    143.     else:
    144.         print("语法分析结果：" + Error)
    145.  
    146.  
    147. if __name__ == '__main__':
    148.     # 首先运行词法分析程序
    149.     Lex_main()
    150.     # 运行语法分析程序
    151.     Analysis_Gs()

    1. """
    2. PL/0程序大纲：
    3. 1、PL/0语言的单词结构
    4. 关键字(10个)：begin, end ,if ,then, while, do, const, var,call,procedure
    5. 标识符：字母序列，最大长度10
    6. 常数：整型常数
    7. 算符和界符（17个）：+， -， *，/，odd，=，<>，<，>，<=，>=，:=，(，) ，, ，.，;
    8. 2、单词的种别划分
    9.     标识符 作为一种
    10.     常数 作为一种
    11.     算符和界符每个单词作为一个单独种别
    12. 3、PL/0的语言的词法分析器将要完成以下工作：
    13. （1）跳过分隔符（如空格，回车，制表符）；
    14. （2）识别诸如begin，end，if，while等保留字；
    15. （3）识别非保留字的一般标识符。
    16. （4）识别数字序列。
    17. （5）识别:=，<=，>=之类的特殊符号。
    18. """
    19.  
    20. # 输入文件路径
    21. pathR = ""
    22.  
    23. # 输出文件路径
    24. pathW = ""
    25.  
    26. # 保存所有字符
    27. strAll = []
    28.  
    29. # 保存词法分析后的字符及种别编码
    30. Result_Lex = [[], []]
    31.  
    32. # 保留关键字及种别编码
    33. Static_word = {"begin": 1, "end": 2, "if": 3, "then": 4, "while": 5,
    34.                "do": 6, "const": 7, "var": 8, "call": 9, "procedure": 10}
    35.  
    36. # 算符和界符及种别编码
    37. Punctuation_marks = {"+": 11, "-": 12, "*": 13, "/": 14, "odd": 15, "=": 16, "<>": 17, "<": 18, ">": 19,
    38.                      "<=": 20, ">=": 21, ":=": 22, "(": 23, ")": 24, ".": 25, ",": 26, ";": 27}
    39.  
    40. # 常数的种别编码为28，标识符的种别编码为29，非法字符的种别编码为30
    41.  
    42. # 空格或换行
    43. Blank = {" ", "\n"}
    44.  
    45. # 中文说明
    46. Explanation = ["保留字", "加号", "减号", "乘号", "除号", "odd运算符", "等于号", "不等于号", "小于号",
    47.                "大于号", "小于等于号", "大于等于", "赋值符号", "左括号", "右括号", "点号", "逗号", "分号", "常数", "标识符"]
    48.  
    49.  
    50. # 判断字符数否为保留关键字
    51. def Is_static(string):
    52.     if string in Static_word:
    53.         return True
    54.     else:
    55.         return False
    56.  
    57.  
    58. # 判断字符是否为算符或者界符
    59. def Is_marks(string):
    60.     if string in Punctuation_marks:
    61.         return True
    62.     else:
    63.         return False
    64.  
    65.  
    66. # 判断是不是空格或者换行
    67. def Is_blank(string):
    68.     if string in Blank:
    69.         return True
    70.     else:
    71.         return False
    72.  
    73.  
    74. # 读取文件所有字符并保存在一个列表中
    75. def Scanner():
    76.     fR = open(pathR)  # 返回一个文件对象
    77.     lines = fR.readlines()  # 调用文件的 readline()方法
    78.     for line in lines:
    79.         for i in line:
    80.             strAll.append(i)
    81.     fR.close()
    82.     # strAll.pop()
    83.  
    84.  
    85. # 多次重复的操作语句
    86. def Option(num, temp, explanation):
    87.     fW = open(pathW, 'a')
    88.     txt = '%-20s%s' % ("（" + str(num) + "，" + temp + "）", explanation + ":" + temp)
    89.     # txt = "({0}，{1}）\t{2}:{3}".format(num, temp, explanation, temp)
    90.     print(txt)
    91.     fW.write(txt + "\n")
    92.     fW.close()
    93.     Result_Lex[0].append(int(num))
    94.     Result_Lex[1].append(temp)
    95.  
    96.  
    97. # 结束
    98. def End(id):
    99.     if id >= len(strAll):
    100.         return True
    101.  
    102.  
    103. # 词法分析主方法
    104. def Analysis_Lex():
    105.     """
    106.         共分为四大块，分别是标识符、常数、算符或界符、空格或换行、非法字符，对应下面的 if, elif, elif, elif和 else
    107.     """
    108.     # 索引值
    109.     id = 0
    110.  
    111.     # 忽略代码段开头的空格或换行
    112.     while Is_blank(strAll[id]):
    113.         id += 1
    114.  
    115.     # 从第一个有意义的字符开始循环识别直至最后一个字符
    116.     while id < len(strAll):
    117.         # 保存临时结果
    118.         temporary = ""
    119.  
    120.         # 判断是否为保留字或者标识符
    121.         if ('a' <= strAll[id] <= 'z') or ('A' <= strAll[id] <= 'Z'):
    122.             while ('0' <= strAll[id] <= '9') or ('a' <= strAll[id] <= 'z') or (
    123.                     'A' <= strAll[id] <= 'Z'):
    124.                 temporary += strAll[id]
    125.                 id += 1
    126.                 if End(id): break
    127.             # 判断是否未保留字
    128.             if Is_static(temporary):
    129.                 num = Static_word[temporary]
    130.                 Option(num, temporary, Explanation[0])
    131.  
    132.             # 判断是否为特殊运算符odd
    133.             elif temporary == "odd":
    134.                 num = Punctuation_marks[temporary]
    135.                 Option(num, temporary, Explanation[num - 10])
    136.             # 否则为非保留字标识符
    137.             else:
    138.                 Option("29", temporary, Explanation[-1])
    139.         # 判断是否为常数（正数或小数）
    140.         elif '0' <= strAll[id] <= '9':
    141.             while ('0' <= strAll[id] <= '9') or strAll[id] == ".":
    142.                 if strAll[id] != ".":
    143.                     temporary += strAll[id]
    144.                     id += 1
    145.                     if End(id): break
    146.                 elif strAll[id] == "." and ('0' <= strAll[id + 1] <= '9'):
    147.                     temporary += strAll[id]
    148.                     id += 1
    149.                     if End(id): break
    150.                 else:
    151.                     break
    152.             Option("28", temporary, Explanation[-2])
    153.         # 判断是否为运算符或界符
    154.         elif Is_marks(strAll[id]) or strAll[id] == ":":
    155.             temporary += strAll[id]
    156.             # 判断小于号三种情况：小于、小于等于、不等于
    157.             if strAll[id] == "<":
    158.                 if strAll[id + 1] == ">" or strAll[id + 1] == "=":
    159.                     temporary += strAll[id + 1]
    160.                     id += 2
    161.                     num = Punctuation_marks[temporary]
    162.                     Option(num, temporary, Explanation[num - 10])
    163.                 else:
    164.                     id += 1
    165.                     num = Punctuation_marks[temporary]
    166.                     Option(num, temporary, Explanation[num - 10])
    167.             # 判断大于号两种情况：大于、大于等于
    168.             elif strAll[id] == ">":
    169.                 if strAll[id + 1] == "=":
    170.                     temporary += strAll[id + 1]
    171.                     id += 2
    172.                     num = Punctuation_marks[temporary]
    173.                     Option(num, temporary, Explanation[num - 10])
    174.                 else:
    175.                     id += 1
    176.                     num = Punctuation_marks[temporary]
    177.                     Option(num, temporary, Explanation[num - 10])
    178.             # 判断赋值符号特殊情况
    179.             elif strAll[id] == ":":
    180.                 if strAll[id + 1] == "=":
    181.                     temporary += strAll[id + 1]
    182.                     id += 2
    183.                     num = Punctuation_marks[temporary]
    184.                     Option(num, temporary, Explanation[num - 10])
    185.                 # 单独的冒号不是运算符或界符，当非法字符处理
    186.                 else:
    187.                     id += 1
    188.                     Option("30", temporary, "非法字符")
    189.             # 其他运算法或界符
    190.             else:
    191.                 id += 1
    192.                 num = Punctuation_marks[temporary]
    193.                 Option(num, temporary, Explanation[num - 10])
    194.         # 对空格、换行过滤
    195.         elif Is_blank(strAll[id]):
    196.             id += 1
    197.             continue
    198.         # 对非法字符的处理
    199.         else:
    200.             temporary += strAll[id]
    201.             id += 1
    202.             Option("30", temporary, "非法字符")
    203.  
    204.  
    205. def Lex_main():
    206.     # 获取代码文件
    207.     print("请输入要分析的代码文件(.txt)路径及完整名称：", end='')
    208.     global pathR, pathW
    209.  
    210.     pathR = input()
    211.  
    212.     # 读入代码文件
    213.     Scanner()
    214.  
    215.     # 读入保存结果文件
    216.     print("请输入保存结果的文件(.txt)路径及完整名称：", end='')
    217.     pathW = input()
    218.  
    219.     # 开始分析代码文件及结果写入
    220.     # print(strAll)
    221.     print('%-16s%s' % ("（种别编码，字符）", "中文介绍:字符"))
    222.     print("-------------词法分析结果为-------------\n")
    223.     # 打开需要写入结果的文档（不存在则创建）并开始写入！
    224.     f = open(pathW, 'a')
    225.     f.write('%-16s%s' % ("（种别编码，字符）", "中文介绍:字符\n"))
    226.     f.write("-------------词法分析结果为-------------\n")
    227.     f.close()
    228.  
    229.     # 程序实现主方法
    230.     Analysis_Lex()
    231.  
    232.  
    233. # 程序运行点
    234. if __name__ == '__main__':
    235.     Lex_main()

    七、实验结果与分析

     

     

  • 相关阅读:
    微前端总结
    vector的模拟实现
    代码随想录-024-454.四数相加 II
    高性能网络编程 - select、 poll 、epoll 、libevent
    Vue或React项目配置@路径别名及智能提示方案
    EasyUi常用代码
    反射知识点学习
    xxe漏洞——无回显（ctfshow web374——378）
    数据结构-考研-第八章——排序（各种算法总结 + 动态演示）
    python的opencv操作记录(五) - 插值第一篇
  • 原文地址：https://blog.csdn.net/c_lanxiaofang/article/details/127997330