一、实验目的

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 vardef 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()