davidcallanan / py-myopl-code Goto Github PK

Traceback (most recent call last):
  File "main.py", line 135, in <module>
    tokens, error = lexer.make_tokens()
  File "main.py", line 65, in make_tokens
    tokens.append(self.make_number())
  File "main.py", line 88, in make_number
    self.advance()
  File "main.py", line 54, in advance
    if self.character in " \t":
TypeError: 'in <string>' requires string as left operand, not NoneType

operators = {
    "+" : "ADDITION",
    "-" : "SUBTRACTION",
    "*" : "MULTIPLICATION",
    "/" : "DIVISION",
    "(" : "PARENTHESIS_LEFT",
    ")" : "PARENTHESIS_RIGHT"
}

class Exception:
    def __init__(self, name, details, inp):
        self.name = name + "Error"
        self.details = details.format(inp=inp)

    def __repr__(self):
        return f"{self.name}: {self.details}"


class InvalidCharacter(Exception):
    def __init__(self, character):
        super().__init__("InvalidCharacter", "\"{inp}\" is not a valid number, integer or decimal", character)

class Token:
    def __init__(self, type_of, value):
        self.type_of = type_of
        self.value = value
    
    def __repr__(self):
        if (self.value != "") and (self.type_of != ""): 
            return "{type_of} :: {value}".format(
                type_of = self.type_of,
                value = self.value
            )

        else:
            return self.type_of


class Lexer:
    def __init__(self, text):
        self.text = text
        self.position = -1
        self.character = None
        self.advance()
    
    def advance(self):
        self.position += 1

        if self.position < len(self.text):
            self.character = self.text[self.position]
        else:
            self.character = None
        
        if self.character in " \t":
            self.advance()
    
    def make_tokens(self):
        tokens = []

        while self.character != None:
            if self.character in "+-*/()":
                tokens.append(Token("OPERATOR", operators[self.character]))
                self.advance()
            elif self.character in "0123456789":
                tokens.append(self.make_number())
                self.advance()
            else:
                self.advance()
                return ([], InvalidCharacter(self.character))

        return (tokens, None)

    def make_number(self):
        num_string = ""
        dot_count = 0

        while self.character != None:
            if self.character in "0123456789.":
                if self.character == ".":
                    if dot_count > 0:
                        break
                    
                    dot_count += 1
                    num_string += "."
                else:
                    num_string += self.character

                self.advance()
            elif self.character in " \t":
                self.advance()
            self.advance()
        

        if dot_count == 0:
            return Token("INTEGER", int(num_string))
        elif dot_count == 1:
            return Token("DECIMAL", float(num_string))
        else:
            return "Something went very wrong. Here is your number: " + num_string

            


def zero_pad(n, width):
    out = str(n)

    while len(out) < width:
        out = "0" + out

    return out

def array_pad(arr):
    out = ""
    
    if not(arr):
        return None

    out += "["

    for el in arr:
        out += "\n\t" + el + ","
    
    out += "\n]"

    return out


n = 1
while True:
    inp = input(f"[{zero_pad(n, 3)}] >>> ")
    n += 1

    lexer = Lexer(inp)

    tokens, error = lexer.make_tokens()

    if error:
        print(repr(error))
    else:
        print(array_pad(tokens))

if other.value == 0:
	return None, RTError(
		other.pos_start, other.pos_end,
		'Division by zero',
		self.context
	)

	return Number(self.value / other.value).set_context(self.context), None

try:
    return Number(self.value / other.value).set_context(self.context), None
except ZeroDivisionError:
   return None, RTError(
	other.pos_start, other.pos_end,
	'Division by zero',
	self.context
    )

Traceback (most recent call last):
  File "c:\Users\..\Desktop\Real\shell.py", line 6, in <module>
    if error: print(error.as_string())
  File "c:\Users\..\Desktop\Real\basic.py", line 10, in as_string
    res += f'File {self.pos_start.fn}, line {self.pos_start.ln + 1}'
AttributeError: 'IllegalChar' object has no attribute 'pos_start'

class Error:
    def __init__(self, pos_start, pos_end,error, error_desc):
        self.start = pos_start
        self.end = pos_end
        self.error = error
        self.desc = error_desc
    def as_string(self):
        res = f'{self.error}: {self.desc}'
        res += f'File {self.pos_start.fn}, line {self.pos_start.ln + 1}'
        return res

class IllegalChar(Error):
    def __init__(self, pos_start, pos_end, desc):
        super().__init__(pos_start, pos_end, 'Illegal Character', desc)