Write a syntax parser based on Python.

TT_INT = "Integer"
TT_FLOAT = "Floating point."
TT_PLUS = "Plus."
TT_DIV = "Divisor."
TT_MINUS = "Minus."
TT_LPAREN = "Left bracket"
TT_RPAREN = "Right bracket"
TT_MUL = "Multiply."
TT_POWER = "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 "|typology：{},(be) worth：{}|".format(self.is_type,self.is_value)
        return "|typology：{}|".format(self.is_type)
    def __str__(self):
        if(self.is_value):
            return "|{}|".format(self.is_value)
        return "|这个对象没有(be) worth，typology为：{}|".format(self.is_type)

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

"""
Top Bugs (Boss)
"""
class HlangError:
    def __init__(self, pos_ln,in_fn,error_name, details):
        """
        :param pos_ln: error line
        :param in_fn: input file
        :param error_name: error name
        :param details: Error details, description
        """
        self.pos_ln = pos_ln
        self.in_fn = in_fn
        self.error_name = error_name
         = details
    def as_string(self):
        red_code = "\033[91m"
        reset_code = "\033[0m"
        result = f'{self.error_name}: {}\n'
        result += f'come from (a place) {self.in_fn}, line {self.pos_ln + 1}'
        return red_code+result+reset_code
class IllegalCharError(HlangError):
    """
    Illegal character error
    """
    def __init__(self, pos_ln,in_fn, details):
        super().__init__(pos_ln, in_fn, 'Illegal characters', details)

"""
Syntax parser
"""
class Lexer:
    def __init__(self, in_fn, text):
        """
        :param in_fn: where the text is input from (the file the text is in, standard input, output is also a file)
        It's actually the filename~~~
        :param text: text to be parsed
        """
        self.in_fn = in_fn
         = text
         = Position(-1, 0, -1)
        self.cur_char = None
        ()
        # Basic symbol handling
        self.char_pro_base = {
            '+':TT_PLUS,
            '-':TT_MINUS,
            '*':TT_MUL,
            '/':TT_DIV,
            '^':TT_POWER,
            '(':TT_LPAREN,
            ')':TT_RPAREN
        }
    def advance(self):
        (self.cur_char)
        self.cur_char = [] if  < len() else None
    def __char_process(self,tokens,TT):
        """
        A way to handle basic characters that
        Add the Token and move the character pointer
        :return.
        """
        (Token(TT))
        ()
    def make_tokens(self):
        """
        the text of the characters added to the syntax parser, will meet the grammatical specification of the content, encapsulated as Token, (just like Spring will object information and then encapsulated as a Wapper to facilitate subsequent operations).
        (just like Spring will be the object information and then encapsulated as a Wapper, to facilitate subsequent operations.)
        :return.
        """
        tokens = []
        while self.cur_char != None:
            if self.cur_char in ' \t':
                # Tabs (spaces), meaningless, move forward
                ()
            elif self.cur_char in DIGITS:
                # If it's a number, it automatically searches forward and adds the number and determines the type.
                #Numbers are special and are not involved character by character (the keywords to be defined later are similar)
                (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
                    ()
                    return [], IllegalCharError(,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
            ()
        if dot_count == 0:
            return Token(TT_INT, int(num_str))
        else:
            return Token(TT_FLOAT, float(num_str))

"""
Language Parsing, Running Entry
"""
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("Interactive terminals:")
    result, error = ('<standard input>', input_text)
    if error: print(error.as_string())
    else: print(result)