swiftcode.py

##############################################
#            IMPORTS
##############################################

import datetime
import time
from string_with_arrows import string_with_arrows
import string
import os
import math
import sys
from dotenv import load_dotenv
##############################################
#            CONSTANTS
##############################################

DIGITS = '0123456789'
LETTERS = string.ascii_letters
LETTERS_DIGITS = LETTERS + DIGITS


##############################################
#            ERROR HANDLING
##############################################

class Error:
    def __init__(self, pos_start, pos_end, error_name, details):
        self.pos_start = pos_start
        self.pos_end = pos_end
        self.error_name = error_name
        self.details = details

    def as_string(self):
        result = f'\033[31mERROR:\033[0m {self.error_name}: {self.details}\n'
        result += f'File: {self.pos_start.fn}, Line: {self.pos_start.ln + 1}'
        result += '\n\n' + string_with_arrows(self.pos_start.ftxt, self.pos_start, self.pos_end)
        return result

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

class InvalidSyntaxError(Error):
    def __init__(self, pos_start, pos_end, details):
        super().__init__(pos_start, pos_end, 'Invalid Syntax', details)
class ExpectedCharError(Error):
    def __init__(self, pos_start, pos_end, details):
        super().__init__(pos_start, pos_end, 'Expected Character', details)
class RTError(Error):
    def __init__(self, pos_start, pos_end, details, context):
        super().__init__(pos_start, pos_end, 'Runtime Error', details)
        self.context = context

    def as_string(self):
        result = self.generate_traceback()
        result += f'\033[31mERROR:\033[0m {self.error_name}: {self.details}\n'
        result += '\n\n' + string_with_arrows(self.pos_start.ftxt, self.pos_start, self.pos_end)
        return result

    def generate_traceback(self):
        result = ''
        pos = self.pos_start
        ctx = self.context

        while ctx:
            result = f'\033[35mFile:\033[0m {self.pos_start.fn}, \033[35mLine:\033[0m {str(self.pos_end.ln + 1)}, \033[35min\033[0m {ctx.display_name}\n' + result
            pos = ctx.parent_entry_pos
            ctx = ctx.parent

        return 'SwiftCode Traceback (most recent call last):\n' + result
    

##############################################
#               POSITION
##############################################

class Position:
    def __init__(self, idx, ln, col, fn, ftxt):
        self.idx = idx
        self.ln = ln
        self.col = col
        self.fn = fn
        self.ftxt = ftxt

    def advance(self, current_char=None):
        self.idx += 1
        self.col += 1

        if current_char == "\n":
            self.ln += 1
            self.col = 0

        return self
    
    def copy(self):
        return Position(self.idx, self.ln, self.col, self.fn, self.ftxt)


##############################################
#               TOKENS
##############################################


ST_INT = 'INT'
ST_FLOAT = 'FLOAT'
ST_STRING = 'STRING'
ST_IDENTIFIER = 'IDENTIFIER'
ST_KEYWORD = 'KEYWORD'
ST_PLUS = 'PLUS'
ST_MINUS = 'MINUS'
ST_MUL = 'MUL'
ST_DIV = 'DIV'
ST_POW = 'POW'
ST_EQ = 'EQ'
ST_LPAREN = 'LPAREN'
ST_RPAREN = 'RPAREN'
ST_LSQUARE = 'LSQUARE'
ST_RSQUARE = 'RSQUARE'
ST_EE = 'EE'
ST_NE = 'NE'
ST_LT = 'LT'
ST_GT = 'GT'
ST_LTE = 'LTE'
ST_GTE = 'GTE'
ST_COMMA = 'COMMA'
ST_ARROW = 'ARROW'
ST_NEWLINE = 'NEWLINE'
ST_SEQ = 'SEQ'
ST_EOF = 'EOF'

KEYWORDS = [
    'variable', # Variable Declaration
    'and', # Logical
    'or', # Logical
    'not', # Logical
    'if', # Conditional
    'then', # Conditional
    'ifnot', # Conditional
    'else', # Conditional
    'iterate', # Loop
    'until', # Loop
    'step', # Loop
    'while', # Loop
    'funct', # Function
    'finish',
    'give',
    'continue',
    'destroy'
]
class Token:
    def __init__(self, type_, value=None, pos_start=None, pos_end=None):
        self.type = type_
        self.value = value

        if pos_start:
            self.pos_start = pos_start.copy()
            self.pos_end = self.pos_start.copy()
            self.pos_end.advance()

        if pos_end:
            self.pos_end = pos_end.copy()
        
    def matches(self, type_, value):
        return self.type == type_ and self.value == value
    def __repr__(self):
        if self.value: return f'{self.type}:{self.value}'
        return f'{self.type}'
    
##############################################
#               LEXER
##############################################

class Lexer:
    def __init__(self, fn, text):
        self.fn = fn
        self.text = text
        self.pos = Position(-1, 0, -1, fn, text)
        self.current_char = None
        self.advance()
    
    def advance(self):
        self.pos.advance(self.current_char)
        self.current_char = self.text[self.pos.idx] if self.pos.idx < len(self.text) else None
    
    def make_tokens(self):
        tokens = []

        while self.current_char != None:
            if self.current_char in ' \t':
                self.advance()
            elif self.current_char == '@':
                self.skip_comment()
            elif self.current_char in ';\n':
                tokens.append(Token(ST_NEWLINE, pos_start=self.pos))
                self.advance()
            elif self.current_char in LETTERS:
                tokens.append(self.make_identifier())
            elif self.current_char in DIGITS:
                tokens.append(self.make_number())
            elif self.current_char == '"':
                tokens.append(self.make_string())
            elif self.current_char == '+':
                tokens.append(Token(ST_PLUS, pos_start=self.pos))
                self.advance()
            elif self.current_char == '-':
                tokens.append(self.make_minus_or_arrow())
            elif self.current_char == '*':
                tokens.append(Token(ST_MUL, pos_start=self.pos))
                self.advance()
            elif self.current_char == '/':
                tokens.append(Token(ST_DIV, pos_start=self.pos))
                self.advance()
            elif self.current_char == '^':
                tokens.append(Token(ST_POW, pos_start=self.pos))
                self.advance()

            elif self.current_char == '(':
                tokens.append(Token(ST_LPAREN, pos_start=self.pos))
                self.advance()
            elif self.current_char == ')':
                tokens.append(Token(ST_RPAREN, pos_start=self.pos))
                self.advance()
            elif self.current_char == '[':
                tokens.append(Token(ST_LSQUARE, pos_start=self.pos))
                self.advance()
            elif self.current_char == ']':
                tokens.append(Token(ST_RSQUARE, pos_start=self.pos))
                self.advance()
            elif self.current_char == '!':
                tok, error = self.make_not_equals()
                if error: return [], error
                tokens.append(tok)
            elif self.current_char == '=':
                tokens.append(self.make_equals())
            elif self.current_char == '<':
                tokens.append(self.make_less_than())
            elif self.current_char == '>':
                tokens.append(self.make_greater_than())
            elif self.current_char == ',':
                tokens.append(Token(ST_COMMA, pos_start=self.pos))
                self.advance()
          #  elif self.current_char == '->':
             #   tokens.append(self.make_minus_or_arrow())
            #    self.advance()
            else:
                pos_start = self.pos.copy()
                char = self.current_char
                self.advance()
                return [], IllegalCharError(pos_start, self.pos, "'" + char + "'")
            
        tokens.append(Token(ST_EOF, pos_start=self.pos))
        return tokens, None
    
    def make_number(self):
        num_str = ''
        dot_count = 0
        pos_start = self.pos.copy()

        while self.current_char != None and self.current_char in DIGITS + '.':
            if self.current_char == '.':
                if dot_count == 1: break
                dot_count += 1
                num_str += '.'
            else:
                num_str += self.current_char
            self.advance()
        if dot_count == 0:
            return Token(ST_INT, int(num_str), pos_start, self.pos)
        else:
            return Token(ST_FLOAT, float(num_str), pos_start, self.pos)

    def make_string(self):
        string = ''
        pos_start = self.pos.copy()
        escape_character = False
        self.advance()

        escape_characters = {
            'n': '\n', #n
            't': '\t' #t
        }

        while self.current_char != None and (self.current_char != '"' or escape_character):
            if escape_character:
                string += escape_characters.get(self.current_char, self.current_char)
            else:
                if self.current_char == '\\':
                    escape_character = True
                else:
                    string += self.current_char
            self.advance()
            escape_character = False
        self.advance()
        return Token(ST_STRING, string, pos_start, self.pos)
        
    def make_identifier(self):
        id_str = ''
        pos_start = self.pos.copy()
        while self.current_char != None and self.current_char in LETTERS_DIGITS + '_':
            id_str += self.current_char
            self.advance()

        tok_type = ST_KEYWORD if id_str in KEYWORDS else ST_IDENTIFIER
        return Token(tok_type, id_str, pos_start, self.pos)
    def make_minus_or_arrow(self):
        tok_type = ST_MINUS
        pos_start = self.pos.copy()
        self.advance()

        if self.current_char == '>':
            self.advance()
            tok_type = ST_ARROW
        return Token(tok_type, pos_start=pos_start, pos_end=self.pos)
    def make_not_equals(self):
        pos_start = self.pos.copy()
        self.advance()

        if self.current_char == '=':
            self.advance()
            return Token(ST_NE, pos_start=pos_start, pos_end=self.pos), None
        self.advance()
        return None, ExpectedCharError(pos_start, self.pos, "'=' after '!'")
    
    def make_equals(self):
        pos_start = self.pos.copy()
        self.advance()

        if self.current_char == '=':
            self.advance()
            return Token(ST_EE, pos_start=pos_start, pos_end=self.pos)

        if self.current_char == '`':
            self.advance()
            return Token(ST_SEQ, pos_start=pos_start, pos_end=self.pos)

        return Token(ST_EQ, pos_start=pos_start, pos_end=self.pos)

    def make_less_than(self):
        tok_type = ST_LT
        pos_start = self.pos.copy()
        self.advance()

        if self.current_char == '=':
            self.advance()
            tok_type = ST_LTE

        return Token(tok_type, pos_start=pos_start, pos_end=self.pos)
    def make_greater_than(self):
        tok_type = ST_GT
        pos_start = self.pos.copy()
        self.advance()

        if self.current_char == '=':
            self.advance()
            tok_type = ST_GTE

        return Token(tok_type, pos_start=pos_start, pos_end=self.pos)
    
    def skip_comment(self):
        self.advance()

        while self.current_char != '\n':
            self.advance()

        self.advance()


##############################################
#               NODES
##############################################


class NumberNode:
    def __init__(self, tok):
        self.tok = tok

        self.pos_start = self.tok.pos_start
        self.pos_end = self.tok.pos_end

    def __repr__(self):
        return f'{self.tok}'
    
class StringNode:
    def __init__(self, tok):
        self.tok = tok

        self.pos_start = self.tok.pos_start
        self.pos_end = self.tok.pos_end

    def __repr__(self):
        return f'{self.tok}'
    
class ListNode:
    def __init__(self, element_nodes, pos_start, pos_end):
        self.element_nodes = element_nodes
        self.pos_start = pos_start
        self.pos_end = pos_end
    
class VarAccessNode:
    def __init__(self, var_name_tok):
        self.var_name_tok = var_name_tok
        self.pos_start = self.var_name_tok.pos_start
        self.pos_end = self.var_name_tok.pos_end

class VarAssignNode:
    def __init__(self, var_name_tok, value_node):
        self.var_name_tok = var_name_tok
        self.value_node = value_node
        self.pos_start = self.var_name_tok.pos_start
        self.pos_end = self.value_node.pos_end

class BinOpNode:
    def __init__(self, left_node, op_tok, right_node):
        self.left_node = left_node
        self.op_tok = op_tok
        self.right_node = right_node

        self.pos_start = self.left_node.pos_start
        self.pos_end = self.right_node.pos_end

    def __repr__(self):
        return f'({self.left_node}, {self.op_tok}, {self.right_node})'
    
class UnaryOpNode:
    def __init__(self, op_tok, node):
        self.op_tok = op_tok
        self.node = node

        self.pos_start = self.op_tok.pos_start
        self.pos_end = node.pos_end

    def __repr__(self):
        return f'({self.op_tok}, {self.node})'
    
class IfNode:
    def __init__(self, cases, else_case):
        self.cases = cases
        self.else_case = else_case

        self.pos_start = self.cases[0][0].pos_start
        self.pos_end = (self.else_case or self.cases[len(self.cases) - 1])[0].pos_end

class IterateNode:
    def __init__(self, var_name_tok, start_value_node, end_value_node, step_value_node, body_node, should_return_null):
        self.var_name_tok = var_name_tok
        self.start_value_node = start_value_node
        self.end_value_node = end_value_node
        self.step_value_node = step_value_node
        self.body_node = body_node
        self.pos_start = self.var_name_tok.pos_start
        self.pos_end = self.body_node.pos_end
        self.should_return_null = should_return_null

class WhileNode:
    def __init__(self, condition_node, body_node, should_return_null):
        self.condition_node = condition_node
        self.body_node = body_node
        self.pos_start = self.condition_node.pos_start
        self.pos_end = self.body_node.pos_end
        self.should_return_null = should_return_null

class FuncDefNode:
    def __init__(self, var_name_tok, arg_name_toks, body_node, should_auto_return):
        self.var_name_tok = var_name_tok
        self.arg_name_toks = arg_name_toks
        self.body_node = body_node
        self.should_auto_return = should_auto_return

        if self.var_name_tok:
            self.pos_start = self.var_name_tok.pos_start
        elif len(self.arg_name_toks) > 0:
            self.pos_start = self.arg_name_toks[0].pos_start
        else:
            self.pos_start = self.body_node.pos_start

        self.pos_end = self.body_node.pos_end

class CallNode:
    def __init__(self, node_to_call, arg_nodes):
        self.node_to_call = node_to_call
        self.arg_nodes = arg_nodes

        self.pos_start = self.node_to_call.pos_start

        if len(self.arg_nodes) > 0:
            self.pos_end = self.arg_nodes[len(self.arg_nodes) - 1].pos_end
        else:
            self.pos_end = self.node_to_call.pos_end

class ReturnNode: #give
    def __init__(self, node_to_return, pos_start, pos_end):
        self.node_to_return = node_to_return

        self.pos_start = pos_start
        self.pos_end = pos_end

class ContinueNode: #continue
    def __init__(self, pos_start, pos_end):
        self.pos_start = pos_start
        self.pos_end = pos_end

class BreakNode: #destroy
    def __init__(self, pos_start, pos_end):
        self.pos_start = pos_start
        self.pos_end = pos_end

##############################################
#               PARSE RESULT
##############################################

class ParseResult:
    def __init__(self):
        self.error = None
        self.node = None
        self.last_registered_advance_count = 0
        self.advance_count = 0
        self.to_reverse_count = 0


    def register_advancment(self):
        self.last_registered_advance_count = 1
        self.advance_count += 1

    def register(self, res):
        self.last_registered_advance_count = res.advance_count
        self.advance_count += res.advance_count
        if res.error: self.error = res.error
        return res.node
    
    def try_register(self, res):
        if res.error:
            self.to_reverse_count = res.advance_count
            return None
        return self.register(res)
    
    def success(self, node):
        self.node = node
        return self

    def failiure(self, error):
        self.error = error
        return self

##############################################
#               PARSER
##############################################

class Parser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.tok_idx = -1
        self.advance()
    
    def advance(self,):
        self.tok_idx += 1
        if self.tok_idx < len(self.tokens):
            self.current_tok = self.tokens[self.tok_idx]
            return self.current_tok
        
    def reverse(self, amount=1):
        self.tok_idx -= amount
        self.update_current_tok()
        return self.current_tok
    
    def update_current_tok(self):
        if self.tok_idx >= 0 and self.tok_idx < len(self.tokens):
            self.current_tok = self.tokens[self.tok_idx]

###################################################

    def parse(self):
        res = self.statements()
        if not res.error and self.current_tok.type != ST_EOF: 
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                "Expected a valid operator: '+', '-', '*', '^' or '/'. Got an invalid operator instead! "
            ))
        return res        
######################################################

    def statements(self):
        res = ParseResult()
        statements = []
        pos_start = self.current_tok.pos_start.copy()

        while self.current_tok.type == ST_NEWLINE:
            res.register_advancment()
            self.advance()

        statement = res.register(self.statement())
        if res.error: return res
        statements.append(statement)
        
        more_statements = True

        while True:
            newline_count = 0
            while self.current_tok.type == ST_NEWLINE:
                res.register_advancment()
                self.advance()
                newline_count += 1
            if newline_count == 0:
                more_statements = False
            if not more_statements: break
            statement = res.try_register(self.statement())
            if not statement:
                self.reverse(res.to_reverse_count)
                more_statements = False
                continue
            statements.append(statement)

        return res.success(ListNode(
            statements,
            pos_start,
            self.current_tok.pos_end.copy()
        ))

    def if_expr(self):
        res = ParseResult()
        all_cases = res.register(self.if_expr_cases('if'))
        if res.error: return res
        cases, else_case = all_cases
        return res.success(IfNode(cases, else_case))
    
    def if_expr_b(self):
        return self.if_expr_cases('ifnot')
    
    def if_expr_c(self):
        res = ParseResult()
        else_case = None

        if self.current_tok.matches(ST_KEYWORD, 'else'):
            res.register_advancment()
            self.advance()

            if self.current_tok.type == ST_NEWLINE:
                res.register_advancment()
                self.advance()

                statements = res.register(self.statements())
                if res.error: return res
                else_case = (statements, True)

                if self.current_tok.matches(ST_KEYWORD, 'finish'):
                    res.register_advancment()
                    self.advance()
                else:
                    return res.failiure(InvalidSyntaxError(
                        self.current_tok.pos_start, self.current_tok.pos_end,
                        "Expected keyword 'finish' after else statement!"
                    ))
            else:
                expr = res.register(self.statement())
                if res.error: return res
                else_case = (expr, False)
        return res.success(else_case)
    def if_expr_b_or_c(self):
        res = ParseResult()
        cases, else_case = [], None

        if self.current_tok.matches(ST_KEYWORD, 'ifnot'):
            all_cases = res.register(self.if_expr_b())
            if res.error: return res
            cases, else_case = all_cases
        else:
            else_case = res.register(self.if_expr_c())
            if res.error: return res

        return res.success((cases, else_case))
    def if_expr_cases(self, case_keyword):
        res = ParseResult()
        cases = []
        else_case = None

        if not self.current_tok.matches(ST_KEYWORD, case_keyword):
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                f"Expected {case_keyword}!"
            ))
        
        res.register_advancment()
        self.advance()

        condition = res.register(self.expr())
        if res.error: return res

        if not self.current_tok.matches(ST_KEYWORD, 'then'):
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                f"Expected 'then' after if statement"
            ))
        
        res.register_advancment()
        self.advance()

        if self.current_tok.type == ST_NEWLINE:
            res.register_advancment()
            self.advance()

            statements = res.register(self.statements())
            if res.error: return res
            cases.append((condition, statements, True))

            if self.current_tok.matches(ST_KEYWORD, 'finish'):
                res.register_advancment()
                self.advance
            else:
                all_cases = res.register(self.if_expr_b_or_c())
                if res.error: return res
                new_cases, else_case = all_cases
                cases.extend(new_cases)
        else:
            expr = res.register(self.statement())
            if res.error: return res
            cases.append((condition, expr, False))

            all_cases = res.register(self.if_expr_b_or_c())
            if res.error: return res
            new_cases, else_case = all_cases
            cases.extend(new_cases)

        return res.success((cases, else_case))
    def iterate_expr(self):
        res = ParseResult()

        if not self.current_tok.matches(ST_KEYWORD, 'iterate'):
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                f"Expected 'iterate'"
            ))
        res.register_advancment()
        self.advance()

        if self.current_tok.type != ST_IDENTIFIER:
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                "Expected identifier after 'iterate'"
            ))
        var_name = self.current_tok
        res.register_advancment()
        self.advance()

        if self.current_tok.type != ST_EQ:
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                "Expected '=' after identifier"
            ))
        res.register_advancment()
        self.advance()

        start_value = res.register(self.expr())
        if res.error: return res

        if not self.current_tok.matches(ST_KEYWORD, 'until'):
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                "Expected 'until' after start value"
            ))
        res.register_advancment()
        self.advance()

        end_value = res.register(self.expr())
        if res.error: return res


        if self.current_tok.matches(ST_KEYWORD, 'step'):
            res.register_advancment()
            self.advance()

            step_value = res.register(self.expr())
            if res.error: return res
        else:
            step_value = None

        if not self.current_tok.matches(ST_KEYWORD, 'then'):
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                "Expected 'then' after 'step' or 'until' value"
            ))
        res.register_advancment()
        self.advance()

        if self.current_tok.type == ST_NEWLINE:
            res.register_advancment()
            self.advance()

            body = res.register(self.statements())
            if res.error: return res

            if not self.current_tok.matches(ST_KEYWORD, 'finish'):
                return res.failiure(InvalidSyntaxError(
                    self.current_tok.pos_start, self.current_tok.pos_end,
                    f"Expected keyword 'finish'"
                ))
            
            res.register_advancment()
            self.advance()

            return res.success(IterateNode(var_name, start_value, end_value, step_value, body, True))

        body = res.register(self.statement())
        if res.error: return res

        return res.success(IterateNode(var_name, start_value, end_value, step_value, body, False))
    def while_expr(self):
        res = ParseResult()

        if not self.current_tok.matches(ST_KEYWORD, 'while'):
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                f"Expected 'while'"
            ))
        res.register_advancment()
        self.advance()

        condition = res.register(self.expr())
        if res.error: return res

        if not self.current_tok.matches(ST_KEYWORD, 'then'):
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                f"Expected 'then' after 'while'"
            ))
        res.register_advancment()
        self.advance()

        if self.current_tok.type == ST_NEWLINE:
            res.register_advancment()
            self.advance()

            body = res.register(self.statements())
            if res.error: return res

            if not self.current_tok.matches(ST_KEYWORD, 'finish'):
                return res.failiure(InvalidSyntaxError(
                    self.current_tok.pos_start, self.current_tok.pos_end,
                    f"Expected keyword 'finish'"
                ))
            
            res.register_advancment()
            self.advance()

            return res.success(WhileNode(condition, body, True))

        body = res.register(self.statement())
        if res.error: return res

        return res.success(WhileNode(condition, body, False))
    def func_def(self):
        res = ParseResult()

        if not self.current_tok.matches(ST_KEYWORD, 'funct'):
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                f"Expected 'funct'"
            ))
        res.register_advancment()
        self.advance()

        if self.current_tok.type == ST_IDENTIFIER:
            var_name_tok = self.current_tok
            res.register_advancment()
            self.advance()
            if self.current_tok.type != ST_LPAREN:
                return res.failiure(InvalidSyntaxError(
                    self.current_tok.pos_start, self.current_tok.pos_end,
                    "Expected '(' after function name"
                ))
        else:
            var_name_tok = None
            if self.current_tok.type != ST_LPAREN:
                return res.failiure(InvalidSyntaxError(
                    self.current_tok.pos_start, self.current_tok.pos_end,
                    "Expected identifier or '(' after 'funct'"
                ))
    
        res.register_advancment()
        self.advance()
        arg_name_toks = []

        if self.current_tok.type == ST_IDENTIFIER:
            arg_name_toks.append(self.current_tok)
            res.register_advancment()
            self.advance()

            while self.current_tok.type == ST_COMMA:
                res.register_advancment()
                self.advance()
 
                if self.current_tok.type != ST_IDENTIFIER:
                    return res.failiure(InvalidSyntaxError(
                        self.current_tok.pos_start, self.current_tok.pos_end,
                        "Expected identifier after ','"
                    ))
                
                arg_name_toks.append(self.current_tok)
                res.register_advancment()
                self.advance()

            if self.current_tok.type != ST_RPAREN:
                return res.failiure(InvalidSyntaxError(
                    self.current_tok.pos_start, self.current_tok.pos_end,
                    "Expected ',' or ')' after identifier"
                ))
        else:
            if self.current_tok.type != ST_RPAREN:
                return res.failiure(InvalidSyntaxError(
                    self.current_tok.pos_start, self.current_tok.pos_end,
                    "Expected identifier or ')' after '('"
                ))
        res.register_advancment()
        self.advance()

        if self.current_tok.type == ST_ARROW:
            res.register_advancment()
            self.advance()
            body = res.register(self.expr())
            if res.error: return res

            return res.success(FuncDefNode(
                var_name_tok,
                arg_name_toks,
                body,
                True
            ))
        
        if self.current_tok.type != ST_NEWLINE:
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                f"Expected '->' or a new line"
            ))
        res.register_advancment()
        self.advance()

        body = res.register(self.statements())
        if res.error: return res

        if not self.current_tok.matches(ST_KEYWORD, 'finish'):
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                f"Expected keyword 'finish' after statement"
            ))
        
        res.register_advancment()
        self.advance()

        return res.success(FuncDefNode(
            var_name_tok,
            arg_name_toks,
            body,
            False
        ))

    def call(self):
        res = ParseResult()
        atom = res.register(self.atom())
        if res.error: return res

        if self.current_tok.type == ST_LPAREN:
            res.register_advancment()
            self.advance()
            arg_nodes = []

            if self.current_tok.type == ST_RPAREN:
                res.register_advancment()
                self.advance()
            else:
                arg_nodes.append(res.register(self.expr()))
                if res.error:
                    return res.failiure(InvalidSyntaxError(
                        self.current_tok.pos_start, self.current_tok.pos_end,
                        "Expected ')', 'variable', 'if', 'while', 'iterate', 'funct' an integer, a float, an identifier or '['"
                    ))
                while self.current_tok.type == ST_COMMA:
                    res.register_advancment()
                    self.advance()

                    arg_nodes.append(res.register(self.expr()))
                    if res.error: return res

                if self.current_tok.type != ST_RPAREN:
                    return res.failiure(InvalidSyntaxError(
                        self.current_tok.pos_start, self.current_tok.pos_end,
                        "Expected ',' or ')' after function call arguments"
                    ))
                res.register_advancment()
                self.advance()
            return res.success(CallNode(atom, arg_nodes))
        return res.success(atom)
    def atom(self):
        res = ParseResult()
        tok = self.current_tok
        if tok.type in (ST_INT, ST_FLOAT):
            res.register_advancment()
            self.advance()
            return res.success(NumberNode(tok))
        
        if tok.type in ST_STRING:
            res.register_advancment()
            self.advance()
            return res.success(StringNode(tok))
        
        elif tok.type == ST_IDENTIFIER:
            res.register_advancment()
            self.advance()
            return res.success(VarAccessNode(tok))
        
        elif tok.type == ST_LPAREN:
            res.register_advancment()
            self.advance()
            expr = res.register(self.expr())
            if res.error: return res
            if self.current_tok.type == ST_RPAREN:
                res.register_advancment()
                self.advance()
                return res.success(expr)
            else:
                return res.failiure(InvalidSyntaxError(
                    self.current_tok.pos_start, self.current_tok.pos_end,
                    "Expected a closing bracket ')'"
                ))
            
        elif tok.type == ST_LSQUARE:
            list_expr = res.register(self.list_expr())
            if res.error: return res
            return res.success(list_expr)
        
        elif tok.matches(ST_KEYWORD, 'if'):
            if_expr = res.register(self.if_expr())
            if res.error: return res
            return res.success(if_expr)
        
        elif tok.matches(ST_KEYWORD, 'iterate'):
            iterate_expr = res.register(self.iterate_expr())
            if res.error: return res
            return res.success(iterate_expr)

        elif tok.matches(ST_KEYWORD, 'while'):
            while_expr = res.register(self.while_expr())
            if res.error: return res
            return res.success(while_expr)  
        elif tok.matches(ST_KEYWORD, 'funct'):
            func_def = res.register(self.func_def())
            if res.error: return res
            return res.success(func_def)      
        return res.failiure(InvalidSyntaxError(
            tok.pos_start, tok.pos_end,
            "Expected an int, a float, an identifier, '+', '[', '-', '(', 'if', 'while', 'iterate', 'funct'"
        ))
    
    def power(self):
        return self.bin_op(self.call, (ST_POW, ), self.factor)
    
    def list_expr(self):
        res = ParseResult()
        element_nodes = []
        pos_start = self.current_tok.pos_start.copy()

        if self.current_tok.type != ST_LSQUARE:
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                "Expected '['"
            ))

        res.register_advancment()
        self.advance()

        if self.current_tok.type == ST_RSQUARE:
            res.register_advancment()
            self.advance()
        else:
            element_nodes.append(res.register(self.expr()))
            if res.error: 
                return res.failiure(InvalidSyntaxError(
                    self.current_tok.pos_start, self.current_tok.pos_end,
                    "Expected ']', 'variable', 'if', 'while', 'iterate', 'funct' an integer, a float, '[' or an identifier"
                ))

            while self.current_tok.type == ST_COMMA:
                res.register_advancment()
                self.advance()

                element_nodes.append(res.register(self.expr()))
                if res.error: return res

            if self.current_tok.type != ST_RSQUARE:
                return res.failiure(InvalidSyntaxError(
                    self.current_tok.pos_start, self.current_tok.pos_end,
                    "Expected ',' or ']' after last element"
                ))
            res.register_advancment()
            self.advance()

        return res.success(ListNode(element_nodes, pos_start, self.current_tok.pos_end.copy()))
   
    def factor(self):
        res = ParseResult()
        tok = self.current_tok

        if tok.type in (ST_PLUS, ST_MINUS):
            res.register_advancment()
            self.advance()
            factor = res.register(self.factor())
            if res.error: return res
            return res.success(UnaryOpNode(tok, factor))


        return self.power()

    def term(self):
        return self.bin_op(self.factor, (ST_MUL,ST_DIV))
    
    def arith_expr(self):
        return self.bin_op(self.term, (ST_PLUS, ST_MINUS))

    def comp_expr(self):
        res = ParseResult()

        if self.current_tok.matches(ST_KEYWORD, 'not'):
            op_tok = self.current_tok
            res.register_advancment()
            self.advance()

            node = res.register(self.comp_expr())
            if res.error: return res
            return res.success(UnaryOpNode(op_tok, node))
        node = res.register(self.bin_op(self.arith_expr,((ST_EE, ST_NE, ST_LT, ST_GT, ST_LTE, ST_GTE, ST_SEQ))))

        if res.error:
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                "Expected an int, a float, an identifier, '+', '-', '(', '[' or 'not'"
            ))
        return res.success(node)

    def statement(self):
        res = ParseResult()
        pos_start = self.current_tok.pos_start.copy()

        if self.current_tok.matches(ST_KEYWORD, "give"):
            res.register_advancment()
            self.advance()

            expr = res.try_register(self.expr())
            if not expr:
                self.reverse(res.to_reverse_count)
            return res.success(ReturnNode(expr, pos_start, self.current_tok.pos_start.copy()))

        if self.current_tok.matches(ST_KEYWORD, "continue"):
            res.register_advancment()
            self.advance()
            return res.success(ContinueNode(pos_start, self.current_tok.pos_start.copy()))
        
        if self.current_tok.matches(ST_KEYWORD, "destroy"):
            res.register_advancment()
            self.advance()
            return res.success(BreakNode(pos_start, self.current_tok.pos_start.copy()))

        expr = res.register(self.expr())
        if res.error: 
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                "Expected 'give', 'continue', 'destroy', '[', 'variable', an integer, a float, an identifier, '+', '-', '(', 'if', 'while', 'iterate' or 'funct'"
            ))
        
        return res.success(expr)
    def expr(self):
        res = ParseResult()
        if self.current_tok.matches(ST_KEYWORD, 'variable'):
            res.register_advancment()
            self.advance()
            if self.current_tok.type != ST_IDENTIFIER:
                return res.failiure(InvalidSyntaxError(
                    self.current_tok.pos_start, self.current_tok.pos_end,
                    'Expected identifier after variable declaration'
                )) 
            var_name = self.current_tok
            res.register_advancment()
            self.advance()

            if self.current_tok.type != ST_EQ:
                return res.failiure(InvalidSyntaxError(
                    self.current_tok.pos_start, self.current_tok.pos_end,
                    "Expected '=' after variable name"
                ))
            
            res.register_advancment()
            self.advance()
            expr = res.register(self.expr())
            if res.error: return res
            return res.success(VarAssignNode(var_name, expr))


        node =  res.register(self.bin_op(self.comp_expr, ((ST_KEYWORD, 'and'), (ST_KEYWORD, 'or'))))

        if res.error: 
            return res.failiure(InvalidSyntaxError(
                self.current_tok.pos_start, self.current_tok.pos_end,
                "Expected '[', 'variable', an integer, a float, an identifier, '+', '-', '(', 'if', 'while', 'iterate' or 'funct'"
            ))
        return res.success(node)
    
    def bin_op(self, func_a, ops, func_b=None):
        if func_b == None:
            func_b = func_a
        res = ParseResult()
        left = res.register(func_a())
        if res.error: return res

        while self.current_tok.type in ops or (self.current_tok.type, self.current_tok.value) in ops: 
            op_tok = self.current_tok
            res.register_advancment()
            self.advance()
            right = res.register(func_b())
            if res.error: return res
            left = BinOpNode(left, op_tok, right)

        return res.success(left)

##############################################
#               RT RESULT
##############################################

class RTResult:
    def __init__(self):
        self.reset()
       # self.advance_count = 0

    def reset(self):
        self.value = None
        self.error = None
        self.func_return_value = None
        self.loop_should_continue = False
        self.loop_should_break = False

   # def register_advancement(self):
    #    self.advance_count += 1
    
    def register(self, res):
       # self.advance_count += res.advance_count
        self.error = res.error
        self.func_return_value = res.func_return_value
        self.loop_should_continue = res.loop_should_continue
        self.loop_should_break = res.loop_should_break
      #  if res.error: self.error = res.error
        return res.value
    def success(self, value):
        self.reset()
        self.value = value
        return self
    
    def success_return(self, value):
        self.reset()
        self.func_return_value = value
        return self
    
    def success_continue(self):
        self.reset()
        self.loop_should_continue = True
        return self
    
    def success_break(self):
        self.reset()
        self.loop_should_break = True
        return self

    
    def failiure(self, error):
        self.reset()
        #if not self.error or self.advance_count == 0:
        #    self.error = error
        self.error = error
        return self
    def should_return(self):
        return (
            self.error or
            self.func_return_value or
            self.loop_should_continue or
            self.loop_should_break
        )

##############################################
#               VALUES
##############################################



class Value:
    def __init__(self):
        self.set_pos() 
        self.set_context() 

    def set_pos(self, pos_start=None, pos_end=None):
        self.pos_start = pos_start
        self.pos_end = pos_end
        return self
    def set_context(self, context=None):
        self.context = context
        return self
    def added_to(self, other):
        return None, self.IllgalOperation(other)
    def subbed_by(self, other):
        return None, self.IllgalOperation(other)
        
    def multed_by(self, other):
        return None, self.IllgalOperation(other)
    def dived_by(self, other):
        return None, self.IllgalOperation(other)
    def powed_by(self, other):
        return None, self.IllgalOperation(other)
    def get_comparison_eq(self, other):
        return None, self.IllgalOperation(other)
    def get_comparison_ne(self, other):
        return None, self.IllgalOperation(other)
    def get_comparison_lt(self, other):
        return None, self.IllgalOperation(other)
    def get_comparison_gt(self, other):
        return None, self.IllgalOperation(other)
    def get_comparison_lte(self, other):
        return None, self.IllgalOperation(other)
    def get_comparison_gte(self, other):
        return None, self.IllgalOperation(other)
    def anded_by(self, other):
        return None, self.IllgalOperation(other)
    def ored_by(self, other):
        return None, self.IllgalOperation(other)
    def notted(self, other):
        return None, self.IllgalOperation(other)
    def execute(self, args):
        return RTResult().failiure(self.IllgalOperation())

    def copy(self):
        raise Exception('No copy method defined')
    
    def is_true(self):
        return False

    def IllgalOperation(self, other=None):
            if not other: other = self
            return None, RTError(
                self.pos_start, other.pos_end,
                'Illegal Operation',
                self.context
            )

class Number(Value):
    def __init__(self, value):
        self.value = value
        self.set_pos() 
        self.set_context() 

    def set_pos(self, pos_start=None, pos_end=None):
        self.pos_start = pos_start
        self.pos_end = pos_end
        return self
    def set_context(self, context=None):
        self.context = context
        return self
    def added_to(self, other):
        if isinstance(other, Number):
            return Number(self.value + other.value).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
    def subbed_by(self, other):
        if isinstance(other, Number):
            return Number(self.value - other.value).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
        
    def multed_by(self, other):
        if isinstance(other, Number):
            return Number(self.value * other.value).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
    def dived_by(self, other):
        if isinstance(other, Number):
            if other.value == 0:
                return None, RTError(
                    other.pos_start, other.pos_end,
                    'Division by zero is not possible!',
                    self.context
                )
            return Number(self.value / other.value).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
    def powed_by(self, other):
        if isinstance(other, Number):
            return Number(self.value ** other.value).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
        
    def get_comparison_eq(self, other):
        if isinstance(other, Number):
            return Number(int(self.value == other.value)).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
    def get_comparison_ne(self, other):
        if isinstance(other, Number):
            return Number(int(self.value != other.value)).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
    def get_comparison_lt(self, other):
        if isinstance(other, Number):
            return Number(int(self.value < other.value)).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
    def get_comparison_gt(self, other):
        if isinstance(other, Number):
            return Number(int(self.value > other.value)).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
    def get_comparison_lte(self, other):
        if isinstance(other, Number):
            return Number(int(self.value <= other.value)).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
    def get_comparison_gte(self, other):
        if isinstance(other, Number):
            return Number(int(self.value >= other.value)).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
    def anded_by(self, other):
        if isinstance(other, Number):
            return Number(int(self.value and other.value)).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
    def ored_by(self, other):
        if isinstance(other, Number):
            return Number(int(self.value or other.value)).set_context(self.context), None
        else:
            return None, self.IllgalOperation(self.pos_start, other.pos_end)
    def notted(self):
        return Number(1 if self.value == 0 else 0).set_context(self.context), None

    def copy(self):
        copy = Number(self.value)
        copy.set_pos(self.pos_start, self.pos_end)
        copy.set_context(self.context)
        return copy
    
    def is_true(self):
        return self.value != 0
    def __repr__(self):
        return str(self.value)
Number.null = Number(0)
Number.false = Number(0)
Number.true = Number(1)
Number.math_PI = Number(math.pi)
Number.math_inf = Number(math.inf)
Number.math_tau = Number(math.tau)
class String(Value):
    def __init__(self, value):
        super().__init__()
        self.value = value

    def added_to(self, other):
        if isinstance(other, String):
            return String(self.value + other.value).set_context(self.context), None
        else:
            return None, Value.IllgalOperation(self.other)
    def multed_by(self, other):
        if isinstance(other, Number):
            return String(self.value * other.value).set_context(self.context), None
        else:
            return None, Value.IllgalOperation(self.other)
        
    def get_string_eq(self, other):
        if isinstance(other, String):
            return Number(int(self.value == other.value)).set_context(self.context), None
        return None, self.IllgalOperation(other)

    def is_true(self):
        return len(self.value) > 0
    
    def copy(self):
        copy = String(self.value)
        copy.set_pos(self.pos_start, self.pos_end)
        copy.set_context(self.context)
        return copy
    
    def __str__(self):
        return self.value
    
    def __repr__(self):
        return f'"{self.value}"'


class List(Value):
    def __init__(self, elements):
        super().__init__()
        self.elements = elements

    def added_to(self, other):
        new_list = self.copy()
        new_list.elements.append(other)
        return new_list, None

    def multed_by(self, other):
        if isinstance(other, List):
            new_list = self.copy()
            new_list.elements.extend(other.elements)
            return new_list, None
        else:
            return None, Value.IllgalOperation(self.other)
    
    def subbed_by(self, other):
        if isinstance(other, Number):
            new_list = self.copy()
            try:
                new_list.elements.pop(other.value)
                return new_list, None
            except:
                return None, RTError(
                    other.pos_start, other.pos_end,
                    'Element at this index could not be removed from list because index is out of bounds!',
                    self.context
                )
        else:
            return None, Value.IllgalOperation(self.other)

    def dived_by(self, other):
        if isinstance(other, Number):
            try:
                return self.elements[other.value], None
            except:
                return None, RTError(
                    other.pos_start, other.pos_end,
                    'Element at this index does not exist!',
                    self.context
                )
        else:
            return None, Value.IllgalOperation(self.other)

    def copy(self):
        copy = List(self.elements)
        copy.set_pos(self.pos_start, self.pos_end)
        copy.set_context(self.context)
        return copy
    
    def __str__(self):
        return f"{', '.join([str(x) for x in self.elements])}"

    def __repr__(self):
        return f'[{", ".join([str(x) for x in self.elements])}]'

class BaseFunction(Value):
    def __init__(self, name):
        super().__init__()
        self.name = name or "<hidden>"

    def generate_new_context(self):
        new_context = Context(self.name, self.context)
        new_context.symbol_table = SymbolTable(new_context.parent.symbol_table)
        return new_context

    def check_args(self, arg_names, args):
        res = RTResult()
        if len(args) > len(arg_names):
            return res.failiure(RTError(
                self.pos_start, self.pos_end,
                f"{len(args) - len(arg_names)} too many arguments passed into '{self.name}'",
                self.context
            ))
        if len(args) < len(arg_names):
            return res.failiure(RTError(
                self.pos_start, self.pos_end,
                f"{len(arg_names) - len(args)} not enough arguments passed into '{self.name}'",
                self.context
            ))
        return res.success(None)

    def populate_args(self, arg_names, args, exec_ctx):
        for i in range(len(args)):
            arg_name = arg_names[i]
            arg_value = args[i]
            arg_value.set_context(exec_ctx)
            exec_ctx.symbol_table.set(arg_name, arg_value)

    def check_and_populate_args(self, arg_names, args, exec_ctx):
        res = RTResult()
        res.register(self.check_args(arg_names, args))
        if res.should_return(): return res
        self.populate_args(arg_names,    args, exec_ctx)
        return res.success(None)
class Function(BaseFunction):
    def __init__(self, name, body_node, arg_name_toks, should_auto_return):
        super().__init__(name)
        self.body_node = body_node
        self.arg_name_toks = arg_name_toks
        self.should_auto_return = should_auto_return
    def execute(self, args):
        res = RTResult()
        interpreter = Interpreter()
        exec_ctx = self.generate_new_context()

        res.register(self.check_and_populate_args(self.arg_name_toks, args, exec_ctx))
        if res.should_return(): return res

        value = res.register(interpreter.visit(self.body_node, exec_ctx))
        if res.should_return() and res.func_return_value == None: return res
        
        ret_value = (value if self.should_auto_return else None) or res.func_return_value or Number.null
        return res.success(ret_value)

    def copy(self):
        copy = Function(self.name, self.body_node, self.arg_name_toks, self.should_auto_return)
        copy.set_context(self.context)
        copy.set_pos(self.pos_start, self.pos_end)
        return copy
    def __repr__(self):
        return f"<function {self.name}>"
    
class BuiltInFunction(BaseFunction):
    def __init__(self, name):
        super().__init__(name)

    def execute(self, args):
        res = RTResult()
        exec_ctx = self.generate_new_context()

        method_name = f'execute_{self.name}'
        method = getattr(self, method_name, self.no_visit_method)

        res.register(self.check_and_populate_args(method.arg_names, args, exec_ctx))
        if res.should_return(): return res

        return_value = res.register(method(exec_ctx))
        if res.should_return(): return res
        return res.success(return_value)

    def no_visit_method(self, node, context):
        raise Exception(f'NO EXECUTE METHOD DEFINED!!! {self.name}')
    
    def copy(self):
        copy = BuiltInFunction(self.name)
        copy.set_context(self.context)
        copy.set_pos(self.pos_start, self.pos_end)
        return copy
    def __repr__(self):
        return f"<built in function {self.name}>"
    
    ##############################################

    def execute_show(self, exec_ctx):
        print(str(exec_ctx.symbol_table.get('value')))
        return RTResult().success(Number.null)
    execute_show.arg_names = ['value']



    def execute_termp(self, exec_ctx):
        print("Termination Point ", exec_ctx.symbol_table.get('value'), " reached!")
        print("     EXITING PROGRAM ...  ")
        sys.exit()
        return RTResult().success(Number.null)
    execute_termp.arg_names = ['value']

    def execute_showwar(self, exec_ctx):
        print("⚠️   WARNING   ⚠️")
        print(str(exec_ctx.symbol_table.get('value')))
        print("⚠️   WARNING   ⚠️")
        return RTResult().success(Number.null)
    execute_showwar.arg_names = ['value']

    def execute_sleep(self, exec_ctx):
        res = RTResult()
        value = exec_ctx.symbol_table.get("value")
        unit = exec_ctx.symbol_table.get("unit")
        if not isinstance(value, Number):
            return res.failiure(RTError(self.pos_start, self.pos_end,"sleep() first argument must be a number",exec_ctx))
        if not isinstance(unit, Number):
            return res.failiure(RTError(self.pos_start, self.pos_end,"sleep() second argument must be a time unit(s,ms,m)",exec_ctx ))
        time.sleep(value.value * unit.value)
        return res.success(Number.null)
    execute_sleep.arg_names = ["value", "unit"]

    def execute_date(self, exec_ctx):
        return RTResult().success(String(datetime.date.today().isoformat()))
    execute_date.arg_names = []

    def execute_date_time(self, exec_ctx):
        return RTResult().success(String(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
    execute_date_time.arg_names = []

    def execute_weekday(self, exec_ctx):
        return RTResult().success(Number(datetime.datetime.now().weekday()))
    execute_weekday.arg_names = []

    def execute_weekday_str(self, exec_ctx):
        return RTResult().success(String(datetime.datetime.now().strftime("%A")))
    execute_weekday_str.arg_names = []
    
    def execute_showerr(self, exec_ctx):
        print("❌   ERROR   ❌")
        print(str(exec_ctx.symbol_table.get('value')))
        print("❌   ERROR   ❌")
        return RTResult().success(Number.null)
    execute_showerr.arg_names = ['value']

    def execute_loadenv(self, exec_ctx):
        load_dotenv()
        return RTResult().success(Number(1))
    execute_loadenv.arg_names = []

    def execute_findenv(self, exec_ctx):
        key = exec_ctx.symbol_table.get("key")
        value = os.getenv(key.value)
        if value is None:
            return RTResult().success()
        return RTResult().success(String(value))
    execute_findenv.arg_names = ["key"]

    def execute_showret(self, exec_ctx):
        return RTResult().success(String(exec_ctx.symbol_table.get('value')))
    execute_showret.arg_names = ['value']

    def execute_usrinput(self, exec_ctx):
        text = input()
        return RTResult().success(String(text))
    execute_usrinput.arg_names = []

    def execute_intinput(self, exec_ctx):
        while True:
            text = input()
            try:
                number = int(text)
                break
            except ValueError:
                print(f"ERROR: '{text}' is not an integer. Intinput accepts only integers.")
        return RTResult().success(Number(number))
    execute_intinput.arg_names = []

    def execute_clean(self, exec_ctx):
        os.system('cls' if os.name == 'nt' else 'clear')
        return RTResult().success(Number.null)
    execute_clean.arg_names = []

    def execute_isnum(self, exec_ctx):
        is_number = isinstance(exec_ctx.symbol_table.get('value'), Number)
        return RTResult().success(Number.true if is_number else Number.false)
    execute_isnum.arg_names = ['value']

    def execute_isstr(self, exec_ctx):
        is_number = isinstance(exec_ctx.symbol_table.get('value'), String)
        return RTResult().success(Number.true if is_number else Number.false)
    execute_isstr.arg_names = ['value']

    def execute_islist(self, exec_ctx):
        is_number = isinstance(exec_ctx.symbol_table.get('value'), List)
        return RTResult().success(Number.true if is_number else Number.false)
    execute_islist.arg_names = ['value']

    def execute_is_funct(self, exec_ctx):
        is_number = isinstance(exec_ctx.symbol_table.get('value'), BaseFunction)
        return RTResult().success(Number.true if is_number else Number.false)
    execute_is_funct.arg_names = ['value']

    def execute_add(self, exec_ctx):
        list_ = exec_ctx.symbol_table.get('list')
        value = exec_ctx.symbol_table.get('value')

        if not isinstance(list_, List):
            return RTResult().failiure(RTError(
                self.pos_start, self.pos_end,
                'First argument must be a list',
                exec_ctx
            ))
        list_.elements.append(value)
        return RTResult().success(Number.null)
    execute_add.arg_names = ['list', 'value']

    def execute_remove(self, exec_ctx):
        list_ = exec_ctx.symbol_table.get('list')
        index = exec_ctx.symbol_table.get('index')

        if not isinstance(list_, List):
            return RTResult().failiure(RTError(
                self.pos_start, self.pos_end,
                'First argument must be a list',
                exec_ctx
            ))

        if not isinstance(index, Number):
            return RTResult().failiure(RTError(
                self.pos_start, self.pos_end,
                'Second argument must be a number',
                exec_ctx
            ))

        try:
            element = list_.elements.pop(index.value)
        except:
            return RTResult().failiure(RTError(
                self.pos_start, self.pos_end,
                'Element at this index could not be removed from list because index is out of bounds!',
                exec_ctx
            ))
        return RTResult().success(element)
    execute_remove.arg_names = ['list', 'index']

    def execute_extend(self, exec_ctx):
        listA = exec_ctx.symbol_table.get('listA')
        listB = exec_ctx.symbol_table.get('listB')

        if not isinstance(listA, List):
            return RTResult().failiure(RTError(
                self.pos_start, self.pos_end,
                'First argument must be a list',
                exec_ctx
            ))

        if not isinstance(listB, List):
            return RTResult().failiure(RTError(
                self.pos_start, self.pos_end,
                'Second argument must be a second list',
                exec_ctx
            ))

        listA.elements.extend(listB.elements)
        return RTResult().success(Number.null)
    execute_extend.arg_names = ['listA', 'listB']

    def execute_filefound(self, exec_ctx):
        path = exec_ctx.symbol_table.get("path").value
        return RTResult().success(Number(int(os.path.exists(path))))
    execute_filefound.arg_names = ["path"]

    def execute_readfile(self, exec_ctx):
        path = exec_ctx.symbol_table.get("path").value
        try:
            with open(path, "r", encoding="utf-8") as f:
                return RTResult().success(String(f.read()))
        except Exception as e:
            return RTResult().failure(RTError(self.pos_start, self.pos_end,str("Could not read file. Check if file exists.", e),exec_ctx))
    execute_readfile.arg_names = ["path"]

    def execute_writefile(self, exec_ctx):
        path = exec_ctx.symbol_table.get("path").value
        text = exec_ctx.symbol_table.get("text").value
        with open(path, "w", encoding="utf-8") as f:
            f.write(text)
        return RTResult().success(Number(1))

    execute_writefile.arg_names = ["path", "text"]

    def execute_appendfile(self, exec_ctx):
        path = exec_ctx.symbol_table.get("path").value
        text = exec_ctx.symbol_table.get("text").value
        with open(path, "a", encoding="utf-8") as f:
            f.write(text)
        return RTResult().success(Number(1))
    execute_appendfile.arg_names = ["path", "text"]


    def execute_len(self, exec_ctx):
        list_ = exec_ctx.symbol_table.get("list")

        if not isinstance(list_, List):
            return RTResult.failiure(RTError(
                self.pos_start, self.pos_end,
                "Argument must be a list!",
                exec_ctx
            ))
        
        return RTResult().success(Number(len(list_.elements)))
    execute_len.arg_names = ["list"]

    def execute_run(self, exec_ctx):
        fn = exec_ctx.symbol_table.get("fn")

        if not isinstance(fn, String):
            return RTResult.failiure(RTError(
                self.pos_start, self.pos_end,
                "Argument must be a string!",
                exec_ctx
            ))
        fn = fn.value

        try:
            with open(fn, "r") as f:
                script = f.read()
        except Exception as e:
            return RTResult().failiure(RTError(
                self.pos_start, self.pos_end,
                f"Failed to read swiftcode file {fn}\n" + str(e),
                exec_ctx
            ))
        
        _, error = run(fn, script)

        if error:
            return RTResult().failiure(RTError(
                self.pos_start, self.pos_end,
                f"Failed to finish executing file {fn}\n" + 
                error.as_string(),
                exec_ctx
            ))
        
        return RTResult().success(Number.null)
    execute_run.arg_names = ["fn"]

BuiltInFunction.print = BuiltInFunction('show')
BuiltInFunction.printco = BuiltInFunction('showco')
BuiltInFunction.printwar = BuiltInFunction('showwar')
BuiltInFunction.printerr = BuiltInFunction('showerr')
BuiltInFunction.print_ret = BuiltInFunction('showret')
BuiltInFunction.input = BuiltInFunction('usrinput')
BuiltInFunction.input_int = BuiltInFunction('intinput')
BuiltInFunction.clear = BuiltInFunction('clean')
BuiltInFunction.is_number = BuiltInFunction('isnum')
BuiltInFunction.is_string = BuiltInFunction('isstr')
BuiltInFunction.is_list = BuiltInFunction('islist')
BuiltInFunction.is_function = BuiltInFunction('isfunct')
BuiltInFunction.append = BuiltInFunction('add')
BuiltInFunction.pop = BuiltInFunction('remove')
BuiltInFunction.extend = BuiltInFunction('extend')
BuiltInFunction.len = BuiltInFunction('len')
BuiltInFunction.run = BuiltInFunction('run')
BuiltInFunction.termp = BuiltInFunction('termp')
BuiltInFunction.loadenv = BuiltInFunction('loadenv')
BuiltInFunction.findenv = BuiltInFunction('findenv')
BuiltInFunction.appendfile = BuiltInFunction('appendfile')
BuiltInFunction.filefound = BuiltInFunction('filefound')
BuiltInFunction.readfile = BuiltInFunction('readfile')
BuiltInFunction.writefile = BuiltInFunction('writefile')
##############################################
#               CONTEXT
##############################################

class Context:
    def __init__(self, display_name, parent=None, parent_entry_pos=None):
        self.display_name = display_name
        self.parent = parent
        self.parent_entry_pos = parent_entry_pos
        self.symbol_table = None

##############################################
#               SYMBOL TABLE
##############################################

class SymbolTable:
    def __init__(self, parent=None):
        self.symbols = {}
        self.parent = parent

    def get(self, name):
        value = self.symbols.get(name, None)
        if value == None and self.parent:
            return self.parent.get(name)
        return value
    
    def set(self, name, value):
        self.symbols[name] = value

    def remove(self, name):
        del self.symbols[name]

##############################################
#               INTERPRETER
##############################################

class Interpreter:
    def visit(self, node, context):
        method_name = f'visit_{type(node).__name__}'
        method = getattr(self, method_name, self.no_visit_method)
        return method(node, context)

    def no_visit_method(self, node, context):
        raise Exception(f'NO VISIT METHOD DEFINED!!! {type(node).__name__}')

    def visit_NumberNode(self, node, context):
        return RTResult().success(
            Number(node.tok.value).set_context(context).set_pos(node.pos_start, node.pos_end)
        )
    
    def visit_StringNode(self, node, context):
        return RTResult().success(
        String(node.tok.value).set_context(context).set_pos(node.pos_start, node.pos_end))

    def visit_ListNode(self, node, context):
        res = RTResult()
        elements = []

        for element_node in node.element_nodes:
            elements.append(res.register(self.visit(element_node, context)))
            if res.should_return(): return res

        return res.success(
            List(elements).set_context(context).set_pos(node.pos_start, node.pos_end)
        )
    
    def visit_VarAccessNode(self, node, context):
        res = RTResult()
        var_name = node.var_name_tok.value
        value = context.symbol_table.get(var_name)

        if not value:
            return res.failiure(RTError(
                node.pos_start, node.pos_end,
                f"Variable '{var_name}' is not defined!!",
                context
            ))
        
        value = value.copy().set_pos(node.pos_start, node.pos_end).set_context(context)
        return res.success(value)
    
    def visit_VarAssignNode(self, node, context):
        res = RTResult()
        var_name = node.var_name_tok.value
        value = res.register(self.visit(node.value_node, context))
        if res.should_return(): return res

        context.symbol_table.set(var_name, value)
        return res.success(value)

    def visit_BinOpNode(self, node, context):
        res = RTResult()
        left = res.register(self.visit(node.left_node, context))
        if res.should_return(): return res
        right = res.register(self.visit(node.right_node, context))
        if res.should_return(): return res

        if node.op_tok.type == ST_PLUS:
            result, error = left.added_to(right)
        elif node.op_tok.type == ST_MINUS:
            result, error = left.subbed_by(right)
        elif node.op_tok.type == ST_MUL:
            result, error = left.multed_by(right)
        elif node.op_tok.type == ST_DIV:
            result, error = left.dived_by(right)
        elif node.op_tok.type == ST_POW:
            result, error = left.powed_by(right)
        elif node.op_tok.type == ST_EE:
            result, error = left.get_comparison_eq(right)
        elif node.op_tok.type == ST_NE:
            result, error = left.get_comparison_ne(right)
        elif node.op_tok.type == ST_LT:
            result, error = left.get_comparison_lt(right)
        elif node.op_tok.type == ST_GT:
            result, error = left.get_comparison_gt(right)
        elif node.op_tok.type == ST_LTE:
            result, error = left.get_comparison_lte(right)
        elif node.op_tok.type == ST_GTE:
            result, error = left.get_comparison_gte(right)
        elif node.op_tok.matches(ST_KEYWORD, 'and'):
            result, error = left.anded_by(right)
        elif node.op_tok.matches(ST_KEYWORD, 'or'):
            result, error = left.ored_by(right)
        elif node.op_tok.type == ST_SEQ:
            if isinstance(left, String):
                result, error = left.get_string_eq(right)
            else:
                return res.failiure(RTError(node.pos_start, node.pos_end,"=` can only be used for string comparison",context))

        if error:
            return res.failiure(error)
        else:
            return res.success(result.set_pos(node.pos_start, node.pos_end))
    
    def visit_UnaryOpNode(self, node, context):
        res = RTResult()
        number = res.register(self.visit(node.node, context))
        if res.should_return(): return res

        error = None

        if node.op_tok.type == ST_MINUS:
            number, error = number.multed_by(Number(-1))
        elif node.op_tok.matches(ST_KEYWORD, 'not'):
            number, error = number.notted()

        if res.error:
            return res.failiure(error)
        else:
            return res.success(number.set_pos(node.pos_start, node.pos_end))
        
    def visit_IfNode(self, node, context):
        res = RTResult()

        for condition, expr, should_return_null in node.cases:
            condition_value = res.register(self.visit(condition, context))
            if res.should_return(): return res

            if condition_value.is_true():
                expr_value = res.register(self.visit(expr, context))
                if res.should_return(): return res
                return res.success(Number.null if should_return_null else expr_value)
        if node.else_case:
            expr, should_return_null = node.else_case
            
            expr_value = res.register(self.visit(expr, context))
            if res.should_return(): return res
            return res.success(Number.null if should_return_null else expr_value)
        
        return res.success(Number.null)
    def visit_IterateNode(self, node, context):
        res = RTResult()
        elements = []

        start_value = res.register(self.visit(node.start_value_node, context))
        if res.should_return(): return res
        end_value = res.register(self.visit(node.end_value_node, context))
        if res.should_return(): return res

        if node.step_value_node:
            step_value = res.register(self.visit(node.step_value_node, context))
            if res.should_return(): return res
        else:
            step_value = Number(1)

        i = start_value.value

        if step_value.value >= 0:
            condition = lambda: i < end_value.value
        else:
            condition = lambda: i > end_value.value

        while condition():
            context.symbol_table.set(node.var_name_tok.value, Number(i))
            i += step_value.value
            value = (res.register(self.visit(node.body_node, context)))
            if res.should_return() and res.loop_should_continue == False and res.loop_should_break == False: return res

            if res.loop_should_continue:
                continue

            if res.loop_should_break:
                break

            elements.append(value)

        return res.success(
            Number.null if node.should_return_null else
            List(elements).set_context(context).set_pos(node.pos_start, node.pos_end)
        )
    def visit_WhileNode(self, node, context):
        res = RTResult()
        elements = []

        while True:
            condition = res.register(self.visit(node.condition_node, context))
            if res.should_return(): return res

            if not condition.is_true(): break

            value = (res.register(self.visit(node.body_node, context)))
            if res.should_return() and res.loop_should_continue == False and res.loop_should_break == False: return res

            if res.loop_should_continue:
                continue
            if res.loop_should_break:
                break
            elements.append(value)
        return res.success(
            Number.null if node.should_return_null else
            List(elements).set_context(context).set_pos(node.pos_start, node.pos_end)  
        )

    def visit_FuncDefNode(self, node, context):
        res = RTResult()
        func_name = node.var_name_tok.value if node.var_name_tok else None
        body_node = node.body_node
        arg_names = [arg_name.value for arg_name in node.arg_name_toks]
        func_value = Function(func_name, body_node, arg_names, node.should_auto_return).set_context(context).set_pos(node.pos_start, node.pos_end)

        if node.var_name_tok:
            context.symbol_table.set(func_name, func_value)
        return res.success(func_value)
    def visit_CallNode(self, node, context):
        res = RTResult()
        args = []

        value_to_call = res.register(self.visit(node.node_to_call, context))
        if res.should_return(): return res
        value_to_call = value_to_call.copy().set_pos(node.pos_start, node.pos_end)

        for arg_node in node.arg_nodes:
            args.append(res.register(self.visit(arg_node, context)))
            if res.should_return(): return res
        return_value = res.register(value_to_call.execute(args))
        if res.should_return(): return res
        return_value = return_value.copy().set_pos(node.pos_start, node.pos_end).set_context(context)
        return res.success(return_value)
    
    def visit_ReturnNode(self, node, context):
        res = RTResult()

        if node.node_to_return:
            value = res.register(self.visit(node.node_to_return, context))
            if res.should_return(): return res
        else:
            value= Number.null

        return res.success_return(value)
    
    def visit_ContinueNode(self, node, context):
        return RTResult().success_continue()
    
    def visit_BreakNode(self, node, context):
        return RTResult().success_break()

##############################################
#               RUN
##############################################

global_symbol_table = SymbolTable()
global_symbol_table.set("null", Number.null)
global_symbol_table.set("true", Number.true)
global_symbol_table.set("false", Number.false)
global_symbol_table.set("pimat", Number(math.pi))
global_symbol_table.set("infimat", Number(math.inf))
global_symbol_table.set("taumat", Number(math.tau))
global_symbol_table.set("show", BuiltInFunction.print)
global_symbol_table.set("showco", BuiltInFunction.printco)
global_symbol_table.set("showret", BuiltInFunction.print_ret)
global_symbol_table.set("usrinput", BuiltInFunction.input)
global_symbol_table.set("intinput", BuiltInFunction.input_int)
global_symbol_table.set("clean", BuiltInFunction.clear)
global_symbol_table.set("showwar", BuiltInFunction.printwar)
global_symbol_table.set("showerr", BuiltInFunction.printerr)
global_symbol_table.set("isnum", BuiltInFunction.is_number)
global_symbol_table.set("isstr", BuiltInFunction.is_string)
global_symbol_table.set("islist", BuiltInFunction.is_list)
global_symbol_table.set("isfunct", BuiltInFunction.is_function)
global_symbol_table.set("add", BuiltInFunction.append)
global_symbol_table.set("remove", BuiltInFunction.pop)
global_symbol_table.set("extend", BuiltInFunction.extend)
global_symbol_table.set("lenl", BuiltInFunction.len)
global_symbol_table.set("frun", BuiltInFunction.run)
global_symbol_table.set("termp", BuiltInFunction.termp)
global_symbol_table.set("s", Number(1))
global_symbol_table.set("m", Number(60))
global_symbol_table.set("ms", Number(0.001))
global_symbol_table.set("sleep", BuiltInFunction("sleep"))
global_symbol_table.set("date", BuiltInFunction("date"))
global_symbol_table.set("date_time", BuiltInFunction("date_time"))
global_symbol_table.set("weekday", BuiltInFunction("weekday"))
global_symbol_table.set("weekday_str", BuiltInFunction("weekday_str"))
global_symbol_table.set("loadenv", BuiltInFunction("loadenv"))
global_symbol_table.set("findenv", BuiltInFunction("findenv"))
global_symbol_table.set("readfile", BuiltInFunction("readfile"))
global_symbol_table.set("writefile", BuiltInFunction("writefile"))
global_symbol_table.set("appendfile", BuiltInFunction("appendfile"))
global_symbol_table.set("filefound", BuiltInFunction("filefound"))


def run(fn, text):
    # Gen Tokens
    lexer = Lexer(fn, text)
    tokens, error = lexer.make_tokens()
    if error: return None, error

    # Gen AST
    parser = Parser(tokens)
    ast = parser.parse()
    if ast.error: return None, ast.error
    #Run
    interpreter = Interpreter()
    context = Context('<code>')
    context.symbol_table = global_symbol_table
    result = interpreter.visit(ast.node, context)
    return result.value, result.error