一、实验目的
1．熟悉体系结构的风格的概念
2．理解和应用管道过滤器型的风格。
3、理解解释器的原理
4、理解编译器模型
二、实验环境
硬件：
软件：Python或任何一种自己喜欢的语言
三、实验内容
1、实现“四则运算”的简易翻译器。
结果要求：
1）实现加减乘除四则运算，允许同时又多个操作数，如：2+3*5-6 结果是11
2）被操作数为整数，整数可以有多位
3）处理空格
4）输入错误显示错误提示，并返回命令状态“CALC”
图1 实验结果示例
加强练习：
1、有能力的同学，可以尝试实现赋值语句，例如x=2+3*5-6，返回x=11。（注意：要实现解释器的功能，而不是只是显示）
2、尝试实现自增和自减符号，例如x++
2、采用管道-过滤器（Pipes and Filters）风格实现解释器
图2 管道-过滤器风格
图 3 编译器模型示意图
本实验，实现的是词法分析和语法分析两个部分。
四、实验步骤：
INTEGER, PLUS, MINUS, MUL, DIV, LPAREN, RPAREN, EOF,VARIABLE,EQUALITY,INCREMENT,REDUCE = (
'INTEGER', 'PLUS', 'MINUS', 'MUL', 'DIV', 'LPAREN', 'RPAREN', 'EOF','VARIABLE','EQUALITY','INCREMENT','REDUCE')
class Token(object):
def __init__(self,type,value):
self.type = type
self.value = value
# toString
def __str__(self):
return 'Token({type},{value})'.format(
type=self.type,
value = self.value
)
class Lexer(object):
# 词法分析器
# 给每个词打标记
# text为输入的表达式
def __init__(self, text):
self.text = text
# pos为当前位置
self.pos = 0
# current_char为当前字符
self.current_char = self.text[self.pos]
# 取字符错误时调用的方法
def error(self):
# raise 抛出异常
raise Exception('Invalid Char')
#前进的方法，即取下一个字符
def advance(self):
# 往下走，取值
self.pos += 1
if self.pos > len(self.text) - 1:
self.current_char = None
else:
self.current_char = self.text[self.pos]
def variable(self):
# 变量处理
variable = ''
while self.current_char is not None and self.current_char.isalpha():
variable = variable + self.current_char
# 往下走，取值
self.advance()
# 取值完毕后，将该变量存入字典中
if variable not in variables:
variables[variable] = None
return variable
def integer(self):
# 多位整数处理
result = ''
while self.current_char is not None and self.current_char.isdigit():
result = result + self.current_char
# 往下走，取值
self.advance()
return int(result)
# 处理输入时的非法空格
def deal_space(self):
# 循环遍历，遇到空格则跳过，取下一个字符
while self.current_char is not None and self.current_char.isspace():
self.advance()
def get_next_token(self):
# 打标记:1）pos+1,2）返回Token(类型，数值）
while self.current_char is not None:
# 空格处理
if self.current_char.isspace():
self.deal_space()
# 数字处理（判断是否为多位整数）
if self.current_char.isdigit():
return Token(INTEGER, self.integer())
# 加号处理Plus
if self.current_char == '+':
# # 判断是自增还是加号
# if self.get_next_token() '+':
# self.advance()
# return Token(PLUS, '+')
self.advance()
return Token(PLUS, '+')
# 减号处理Minus
if self.current_char == '-':
self.advance()
return Token(MINUS, '-')
# 左括号
if self.current_char == '(':
self.advance()
return Token(LPAREN,'(')
# 右括号
if self.current_char == ')':
self.advance()
return Token(RPAREN,')')
# 乘号
if self.current_char == '*':
self.advance()
return Token(MUL,'*')
# 除号
if self.current_char == '/':
self.advance()
return Token(DIV,'/')
# 若是判断出字符则进入变量获取的方法
if self.current_char.isalpha():
return Token(VARIABLE,self.variable())
# 等号
if self.current_char == '=':
self.advance()
return Token(EQUALITY,'EQUALITY')
# # 自增
# if self.current_char == '++':
# self.advance()
# return Token(EQUALITY,'EQUALITY')
# 其余均为非法字符
self.error()
# 取到None字符 返回一个空的Token 表示循环结束
return Token(EOF, None)
class Interpreter(object):
# 句法分析
# 语法树
# 语法树中的一个参数为词法分析器Lexer
def __init__(self, lexer):
self.lexer = lexer
self.current_token = self.lexer.get_next_token()
def error(self):
raise Exception('Invalid Syntax')
# 当当前Token取值完毕
# 删除当前的Token，取下一个Token的值
def eat(self, token_type):
# 跳过与当前相同的Token，取下一个Token
if self.current_token.type == token_type:
self.current_token = self.lexer.get_next_token()
else:
# 若在删除的过程中出错，会引起整体的错误，故抛错
self.error()
# 工厂方法
def factor(self):
token = self.current_token
# 判断当前要删除的Token类型
if token.type == INTEGER:
self.eat(INTEGER)
return token.value
# 将类型为Variable的变量返回
if token.type == VARIABLE:
self.eat(VARIABLE)
return variables[token.value]
# 左括号
elif token.type == LPAREN:
self.eat(LPAREN)
result = self.expr()
self.eat(RPAREN)
return result
def term(self):
result = self.factor()
while self.current_token.type in (MUL, DIV):
token = self.current_token
if token.type == MUL:
self.eat(MUL)
result = result * self.factor()
if token.type == DIV:
self.eat(DIV)
result = result / self.factor()
return result
def expr(self):
result = self.term()
while self.current_token.type in (PLUS, MINUS):
token = self.current_token
if token.type == PLUS:
self.eat(PLUS)
result = result + self.term()
if token.type == MINUS:
self.eat(MINUS)
result = result - self.term()
return result
def assignment(self):
if self.current_token.type == VARIABLE:
var = self.current_token.value
self.eat(VARIABLE)
if self.current_token.type == EQUALITY:
self.eat(EQUALITY)
variables[var] = self.expr()
return var
def printResult(text):
lexer = Lexer(text)
variableKey = Interpreter(lexer).assignment()
print(variableKey,"=",variables[variableKey])
def main():
while True:
try:
text = input('calc_> ')
except EOFError:
break
if not text:
continue
# try:
printResult(text)
# except Exception:
# print('Invalid Syntax')
if __name__ == '__main__':
main()
