基于Python编写个语法解析器

TT_INT = "整数"
TT_FLOAT = "浮点数"
TT_PLUS = "加号"
TT_DIV = "除号"
TT_MINUS = "减号"
TT_LPAREN = "左括号"
TT_RPAREN = "右括号"
TT_MUL = "乘"
TT_POWER = "次幂"
DIGITS = "123456789"

class Token:
    def __init__(self,is_type,is_value=None):
        self.is_type = is_type
        self.is_value = is_value
    def __repr__(self):
        if self.is_value:
            return "|类型：{},值：{}|".format(self.is_type,self.is_value)
        return "|类型：{}|".format(self.is_type)
    def __str__(self):
        if(self.is_value):
            return "|{}|".format(self.is_value)
        return "|这个对象没有值，类型为：{}|".format(self.is_type)

class Position:
    def __init__(self, idx, ln, col):
        self.idx = idx
        self.ln = ln
        self.col = col
    def advance(self, cur_char):
        self.idx += 1
        self.col += 1
        if cur_char == '\n':
            self.ln += 1
            self.col = 0
        return self

"""
顶级错误（老大）
"""
class HlangError:
    def __init__(self, pos_ln,in_fn,error_name, details):
        """
        :param pos_ln: 错误行
        :param in_fn: 输入文件
        :param error_name: 错误名称
        :param details: 错误细节，说明
        """
        self.pos_ln = pos_ln
        self.in_fn = in_fn
        self.error_name = error_name
        self.details = details
    def as_string(self):
        red_code = "\033[91m"
        reset_code = "\033[0m"
        result = f'{self.error_name}: {self.details}\n'
        result += f'来自 {self.in_fn}, line {self.pos_ln + 1}'
        return red_code+result+reset_code
class IllegalCharError(HlangError):
    """
    非法字符错误
    """
    def __init__(self, pos_ln,in_fn, details):
        super().__init__(pos_ln, in_fn, '非法字符', details)

"""
语法解析器
"""
class Lexer:
    def __init__(self, in_fn, text):
        """
        :param in_fn: 从哪里输入的文本（文本所在文件，标准输入，输出也是一个文件）
        其实就是文件名~~~
        :param text: 待解析文本
        """
        self.in_fn = in_fn
        self.text = text
        self.pos = Position(-1, 0, -1)
        self.cur_char = None
        self.advance()
        #基本的符号处理
        self.char_pro_base = {
            '+':TT_PLUS,
            '-':TT_MINUS,
            '*':TT_MUL,
            '/':TT_DIV,
            '^':TT_POWER,
            '(':TT_LPAREN,
            ')':TT_RPAREN
        }
    def advance(self):
        self.pos.advance(self.cur_char)
        self.cur_char = self.text[self.pos.idx] if self.pos.idx < len(self.text) else None
    def __char_process(self,tokens,TT):
        """
        处理基本字符的方法，
        添加Token，并且移动字符指针
        :return:
        """
        tokens.append(Token(TT))
        self.advance()
    def make_tokens(self):
        """
        将文本当中的字符添加到语法解析器当中，将符合语法规范的内容，封装为Token,
        （就像Spring将对象信息再封装为Wapper一样，方便后续进行操作。）
        :return:
        """
        tokens = []
        while self.cur_char != None:
            if self.cur_char in ' \t':
                #制表符（空格），没有意义，往前移动
                self.advance()
            elif self.cur_char in DIGITS:
                #如果是数字，自动往前搜索，并且将数字进行添加，并且判断类型，
                #数字比较特殊，不是一个字符一个字符参与的（后面还要定义关键字也是类似的）
                tokens.append(self.make_number())
            else:
                TT = self.char_pro_base.get(self.cur_char)
                if(TT):
                    self.__char_process(tokens,TT)
                else:
                    char = self.cur_char
                    self.advance()
                    return [], IllegalCharError(self.pos.ln,self.in_fn, "'" + char + "'")
        return tokens, None
    def make_number(self):
        num_str = ''
        dot_count = 0
        while self.cur_char != None and self.cur_char in DIGITS + '.':
            if self.cur_char == '.':
                if dot_count == 1: break
                dot_count += 1
                num_str += '.'
            else:
                num_str += self.cur_char
            self.advance()
        if dot_count == 0:
            return Token(TT_INT, int(num_str))
        else:
            return Token(TT_FLOAT, float(num_str))

"""
语言解析，运行入口
"""
def run(fn, text):
    lexer = Lexer(fn, text)
    tokens, error = lexer.make_tokens()
    return tokens, error

"""
Hlang is a Sample Language shell
Just a sample example for learning by Huterox
"""
import basic
while True:
    input_text = input("交互终端：")
    result, error = basic.run('<标准输入>', input_text)
    if error: print(error.as_string())
    else: print(result)