colon3 0.0.9__py3-none-any.whl

colon3/cli.py

@@ -0,0 +1,47 @@
+from modules.evaulator import Ev
+from pathlib import Path
+import sys
+
+def print_error(prefix, string_reason):
+    print(f"{prefix}: {string_reason}")
+
+def main():
+    args = sys.argv[1:]
+
+    if not args:
+        print("colon three,,, the programming language... Why did i make this language...")
+        return
+
+    if args[0] == "run":
+        if len(args) != 2:
+            print("Usage: colon-three run [FILE]...")
+            return
+
+        file_path = Path(args[1]).expanduser()
+        # print("FILE_PATH:", file_path)
+
+        if not file_path.exists():
+            print_error(sys.argv[1], f"cannot run '{file_path}': No such file or directory. (colon-three)")
+            return
+
+        if not file_path.is_file():
+            print_error(sys.argv[1], f"cannot run '{file_path}': Not a file. (colon-three)")
+            return
+
+        try:
+            with file_path.open("r", encoding="utf-8") as file:
+                content = file.read()
+            
+        except OSError as e:
+            print_error(sys.argv[:1], f"cannot read '{file_path}': {e}")
+            return
+
+        ev = Ev()
+        ev.ev(content)
+        
+    else:
+        print(f"Unknown command: {args[0]}")
+
+
+if __name__ == "__main__":
+    main()

colon3-0.0.9.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: colon3
+Version: 0.0.9
+Summary: You can now convert your silly nature of meowwws and mrrrppss into executable code! (If all code-lines align perfectly)
+Requires-Python: >=3.10

colon3-0.0.9.dist-info/RECORD

@@ -0,0 +1,15 @@
+colon3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+colon3/cli.py,sha256=vWdB95INxCSlh9rrU4IR5MiY0FOYqG_Pr2a3FuGJiAA,1234
+modules/SETTINGS.py,sha256=Xv1VFl3MARK3gYrqTkHg2JQYlKN9m7_Vd1UhhkSFO-s,754
+modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modules/evaulator.py,sha256=lnycyvStCaeC0_I3oIgic26sTSaq9xEqjJMW3ct-nTQ,5162
+modules/parser.py,sha256=OudnmJk2Gep74uSvRrfOmhGJmk5oZZSZYbNiSTEUmdg,4666
+modules/tokens.py,sha256=7ELSjuehjbORyaSTmVrvPNWrz8HDu_S9CKUV6Xm6a5g,4947
+modules/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modules/functions/pointer_related.py,sha256=0FYwGmtmIRnOG6zRpQBbWyidKIcmG0xnmAOoP5WSTIY,4390
+modules/functions/variable_parsing.py,sha256=9bThRl80plq5ADhSYsEu6jr1YbTI9fD_9FjEw_oW0o0,7366
+colon3-0.0.9.dist-info/METADATA,sha256=375fObotcUC_Q9ZUGI8rqZqmJc2Pz43Yv-Z7nRNPpFQ,203
+colon3-0.0.9.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+colon3-0.0.9.dist-info/entry_points.txt,sha256=VLABzUkYBdDCOYfiNllBVk8tJWrE-F7g-R4Hrb2FcPA,43
+colon3-0.0.9.dist-info/top_level.txt,sha256=CzY29IQbUXXGD9vh77xH9G1bN0HKit0QV8K_Dl4mds0,15
+colon3-0.0.9.dist-info/RECORD,,

colon3-0.0.9.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

colon3-0.0.9.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+colon3 = colon3.cli:main

colon3-0.0.9.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+colon3
+modules

modules/SETTINGS.py

@@ -0,0 +1,29 @@
+settings = {
+    "debug": False,
+    "show_intent": True,
+    "returning_values": False,
+    "output_lines": False,
+    "show_tokenized_code": True
+}
+
+if not settings["debug"]:
+    settings["show_intent"] = False
+    settings["returning_values"] = False
+    settings["output_lines"] = False
+    settings["show_tokenized_code"] = False
+
+def debugPrint(*args):
+    if settings["debug"]:
+        print(*args)
+
+def debugPrintIntent(*args):
+    if settings["debug"] and settings["show_intent"]:
+        print(*args)
+
+def debugPrintReturn(*args):
+    if settings["debug"] and settings["returning_values"]:
+        print(*args)
+
+def debugPrintOutput(*args):
+    if settings["debug"] and settings["output_lines"]:
+        print(*args)

modules/evaulator.py

@@ -0,0 +1,156 @@
+import re
+from .parser import compute_action
+from .tokens import lib_number_tokens, lib_syntax, lib_operators, lib_nest_up, lib_nest_down, lib_nest_ambiguous
+from .SETTINGS import debugPrint, debugPrintOutput, settings
+
+def callout_error(line, collumn, reason):
+    raise SyntaxError(f"Syntax error at ({line}:{collumn}): {reason}")
+
+class Ev:
+
+    def __init__(self):
+        self.current_line = 0
+        self.current_collumn = 0
+        self.current_nest_level = 0
+
+        self.variables = {}
+        
+        self.nest_info = []
+        self.loop_labels = []
+        
+        self.recall_labels = []
+
+    def get_nest(self, converted_total):
+        nest = []
+        level = 0
+
+        for line_num, line in enumerate(converted_total):
+            line_info = {
+                "value": level,
+                "columns": {}
+            }
+
+            for col, token in enumerate(line):
+                if token in lib_nest_ambiguous:
+                    level -= 1
+                    if level < 0:
+                        callout_error(line_num + 1, col + 1, f"Unexpected '{token}.'")
+
+                    line_info["columns"][col] = {"value": level}
+
+                    level += 1
+                    line_info["columns"][col + 1] = {"value": level}
+
+                elif token in lib_nest_up:
+                    level += 1
+                    line_info["columns"][col + 1] = {"value": level}
+
+                elif token in lib_nest_down:
+                    level -= 1
+                    if level < 0:
+                        callout_error(line_num + 1, col + 1, f"Unexpected '{token}.'")
+
+                    line_info["columns"][col] = {"value": level}
+
+            nest.append(line_info)
+
+        if level != 0:
+            raise callout_error(0, 0, f"One or more nesting blocks weren't closed properly.")
+
+        return nest
+
+    def map_syntax(self, token, use_new_parser=False):
+        if token in lib_number_tokens:
+            return lib_number_tokens[token]
+        
+        if token in lib_syntax:
+            return lib_syntax[token]
+
+        if token in lib_operators:
+            return lib_operators[token]
+        return None
+
+    def convert_token(self, tokens):
+        result = []
+        i = 0
+
+        while i < len(tokens):
+            output = None
+
+            # Try a three-token match
+            if i + 2 < len(tokens):
+                triple = f"{tokens[i]} {tokens[i + 1]} {tokens[i + 2]}"
+                output = self.map_syntax(triple)
+
+                if output is not None:
+                    result.append(output)
+                    i += 3
+                    continue
+
+            # Try a two-token match
+            if i + 1 < len(tokens):
+                pair = f"{tokens[i]} {tokens[i + 1]}"
+                output = self.map_syntax(pair)
+
+                if output is not None:
+                    result.append(output)
+                    i += 2
+                    continue
+
+            # Try a one-token match
+            output = self.map_syntax(tokens[i])
+            if output is not None:
+                result.append(output)
+                i += 1
+                continue
+
+            # Welp im all out of options..
+            raise callout_error(self.current_line, i, f"{tokens[i]} is not a valid token!")
+
+        return result
+
+    def ev(self, s: str):
+        lines = [x.strip() for x in re.split(r"\n|murrp", s) if x.strip()]
+        lines = [line for line in lines if not line.startswith("//")]
+
+        # hardmode
+        i = 0
+        for line in lines:
+            if not line.endswith("~"):
+                raise callout_error(len(line) - 1, i, "Expected a '~' at end of declaration.")
+            lines[i] = line[:-1]
+            i += 1
+
+        converted_lines = [] # Only used once wow how useful
+        for line in lines:
+            converted_lines.append(self.convert_token(line.split()))
+
+        if settings["show_tokenized_code"]:
+            debugPrint("Tokenized code:")
+            for line in converted_lines:
+                debugPrint(line)
+        
+        self.nest_info = self.get_nest(converted_lines)
+        self.current_line = 0
+
+        while self.current_line < len(lines):
+            self.ev_expr(lines[self.current_line], lines)
+            self.current_line += 1
+        
+        debugPrint("Code finished executing.")
+        debugPrint("Variables:", self.variables)
+        debugPrint("Nest data:", self.nest_info)
+        debugPrint("Loop data:", self.loop_labels)
+
+    def ev_expr(self, line: str, whole_code: str):
+        words = line.split()
+        token_array = self.convert_token(words)
+        
+        debugPrintOutput(f"Line {self.current_collumn}:", token_array)
+        self.current_collumn = 0
+
+        while self.current_collumn < len(token_array):
+            token = token_array[self.current_collumn]
+            changed_collumn = compute_action(self, token, token_array, whole_code)
+            if changed_collumn != "IGNORE":
+                self.current_collumn = changed_collumn

modules/functions/pointer_related.py

@@ -0,0 +1,147 @@
+from ..tokens import lib_operators, lib_reverse_search, lib_nest_down, lib_nest_ambiguous
+from ..SETTINGS import debugPrintOutput, debugPrintReturn, debugPrint
+from .variable_parsing import return_variable_referenced
+
+def get_nest_at(nest_info, line, column):
+    if not (0 <= line < len(nest_info)):
+        return 0
+
+    line_info = nest_info[line]
+    nesting = line_info["value"]
+
+    for col in sorted(line_info["columns"]):
+        if col > column:
+            break
+        nesting = line_info["columns"][col]["value"]
+
+    return nesting
+
+def find_next_else_or_end(self, total):
+    converted_lines = [
+        self.convert_token(line.split())
+        for line in total
+    ]
+
+    current_nest = get_nest_at(
+        self.nest_info,
+        self.current_line,
+        self.current_collumn
+    )
+
+    pointer_line = self.current_line
+    pointer_collumn = self.current_collumn
+
+    while pointer_line < len(converted_lines):
+
+        # Move to next token
+        if pointer_collumn + 1 < len(converted_lines[pointer_line]):
+            pointer_collumn += 1
+        else:
+            pointer_line += 1
+            pointer_collumn = 0
+
+            if pointer_line >= len(converted_lines):
+                break
+
+        if pointer_collumn >= len(converted_lines[pointer_line]):
+            continue
+
+        statement = converted_lines[pointer_line][pointer_collumn]
+
+        statement_nest = get_nest_at(
+            self.nest_info,
+            pointer_line,
+            pointer_collumn
+        )
+
+        debugPrint(
+            f"{pointer_line}:{pointer_collumn}",
+            statement,
+            "nest:",
+            statement_nest
+        )
+
+        if statement_nest == current_nest:
+            if statement in lib_nest_down or statement in lib_nest_ambiguous:
+                return pointer_line, pointer_collumn
+
+    raise SyntaxError("Could not find matching else/end.")
+
+def parse_if_statement(self, tokenized_text, total):
+    if len(tokenized_text) <= self.current_collumn + 1:
+        raise SyntaxError("Expected a value or variable.")
+
+    value = return_variable_referenced(
+        self,
+        tokenized_text[self.current_collumn + 1]
+    )
+
+    if value > 0:
+        debugPrintReturn("check passed!")
+
+        self.current_nest_level += 1
+        return self.current_collumn + 1
+
+    debugPrintReturn("check failed!")
+
+    line, col = find_next_else_or_end(self, total)
+
+    self.current_line = line
+    self.current_collumn = col + 1
+
+    return "IGNORE"
+
+def recall_back_to_start_of_loop(self, tokenized_text, total):
+    debugPrintOutput("currently recalling last loop in line", self.current_line, "collumn", self.current_collumn)
+
+    statement_nest = get_nest_at(
+        self.nest_info,
+        self.current_line,
+        self.current_collumn
+    )
+
+    advanceAmount = 1
+    if len(tokenized_text) >= 1:
+        advanceAmount = return_variable_referenced(self, tokenized_text[1])
+
+    debugPrintOutput("Tokenized text:", tokenized_text)
+    debugPrintOutput("current statement level:", statement_nest)
+
+    while self.loop_labels:
+        latest_loop = self.loop_labels[-1]
+        data = latest_loop["data"]
+
+        if "var_check" in data:
+            check_value = return_variable_referenced(self, data["var_check"])
+            if check_value <= 0:
+                # This loop is finished
+                self.loop_labels.pop()
+                self.current_nest_level -= 1
+            else:
+                self.current_line = latest_loop["line"]
+                self.current_collumn = latest_loop["collumn"]
+
+            break
+        
+        if data["current"] < data["end"]:
+            data["current"] = min(data["current"] + advanceAmount, data["end"])
+
+            self.variables[data["var_name"]] = data["current"]
+            self.current_line = latest_loop["line"]
+            self.current_collumn = latest_loop["collumn"]
+
+            break
+        else:
+            # This loop is finished
+            self.loop_labels.pop()
+            self.current_nest_level -= 1
+
+    return self.current_collumn + 1
+
+def skip_parts_of_code(self, tokenized_text, total):
+    line, col = find_next_else_or_end(self, total)
+
+    self.current_line = line
+    self.current_collumn = col + 1
+
+    return "IGNORE"

modules/functions/variable_parsing.py

@@ -0,0 +1,220 @@
+from ..tokens import lib_operators, lib_reverse_search
+from ..SETTINGS import debugPrintOutput, debugPrintReturn
+
+def get_type(self, var_name):
+    if var_name not in self.variables:
+        return None
+
+    value = self.variables[var_name]
+
+    # Empty strings are treated as None
+    if isinstance(value, str) and len(value) == 0:
+        return None
+
+    return type(value)
+
+def parse_statement(value1, value2, type):
+    # Strings are compared by their length
+    if isinstance(value1, str):
+        value1 = len(value1)
+
+    if isinstance(value2, str):
+        value2 = len(value2)
+
+    if type == lib_reverse_search["equal_to"]:
+        return 1 if value1 == value2 else 0
+
+    elif type == lib_reverse_search["more_than"]:
+        return 1 if value1 > value2 else 0
+
+    elif type == lib_reverse_search["less_than"]:
+        return 1 if value1 < value2 else 0
+
+    elif type == lib_reverse_search["more_or_equal_to"]:
+        return 1 if value1 >= value2 else 0
+
+    elif type == lib_reverse_search["less_or_equal_to"]:
+        return 1 if value1 <= value2 else 0
+
+    return 0
+
+def parse_number(value):
+    # Already a number
+    if isinstance(value, (int, float)):
+        return value
+
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        pass
+
+    try:
+        return float(value)
+    except (ValueError, TypeError):
+        pass
+
+    return value
+
+def convert_to_literal(value):
+    if value == "null":
+
+        debugPrintReturn("returning as null")
+        return None
+    else:
+        new = parse_number(value)
+
+        debugPrintReturn("returning as", type(new))
+        return new
+
+def return_variable_referenced(self, value):
+    if value in self.variables:
+        old = self.variables[value]
+
+        debugPrintReturn("borrowing the value", old, "for", value)
+        return old
+
+    debugPrintReturn("returning literal", value)
+    # Convert literals if possible
+    value = convert_to_literal(value)
+    return value
+
+def compute_variable(self, tokenized_text):
+    operators = lib_operators.values()
+
+    # Find the operator
+    operator_index = None
+    for j in range(self.current_collumn + 1, len(tokenized_text)):
+        if tokenized_text[j] in operators:
+            operator_index = j
+            break
+
+    if operator_index is None:
+        raise SyntaxError("Expected an assignment operator.")
+
+    # Everything before the operator is the variable name
+    var_name = "".join(tokenized_text[self.current_collumn + 1:operator_index])
+
+    # Find the separator
+    separator_index = None
+    for j in range(operator_index + 1, len(tokenized_text)):
+        if tokenized_text[j] == lib_reverse_search["add"]: # :3 would be more of a seperator
+            separator_index = j
+            break
+
+    if separator_index is None:
+        # No separator found
+        value = "".join(tokenized_text[operator_index + 1:])
+        value2 = ""
+    else:
+        value = "".join(tokenized_text[operator_index + 1:separator_index])
+        value2 = "".join(tokenized_text[separator_index + 1:])
+
+    # Variable reference
+    value = return_variable_referenced(self, value)
+    value2 = return_variable_referenced(self, value2)
+
+    operator = tokenized_text[operator_index]
+    travelled_index = len(tokenized_text)
+
+    # Get its existing type
+    existing_type = get_type(self, var_name)
+    debugPrintReturn("Existing type:", existing_type)
+    debugPrintReturn("Value1:", value, type(value))
+    debugPrintReturn("Value2:", value2, type(value2))
+ 
+    if operator == lib_reverse_search["equal_to"]:
+        self.variables[var_name] = parse_statement(value, value2, operator)
+        return travelled_index
+    
+    elif operator == lib_reverse_search["more_than"]:
+        self.variables[var_name] = parse_statement(value, value2, operator)
+        return travelled_index
+    
+    elif operator == lib_reverse_search["less_than"]:
+        self.variables[var_name] = parse_statement(value, value2, operator)
+        return travelled_index
+    
+    elif operator == lib_reverse_search["more_or_equal_to"]:
+        self.variables[var_name] = parse_statement(value, value2, operator)
+        return travelled_index
+    
+    elif operator == lib_reverse_search["less_or_equal_to"]:
+        self.variables[var_name] = parse_statement(value, value2, operator)
+        return travelled_index
+
+    # Assignment
+    if operator == lib_reverse_search["equal"]:
+        self.variables[var_name] = value
+        debugPrintOutput("setting", var_name, "to", value)
+
+        return travelled_index
+
+    # Addition
+    if operator == lib_reverse_search["add"]:
+        if var_name not in self.variables:
+            raise NameError(f"Variable '{var_name}' does not exist.")
+
+        current = self.variables[var_name]
+
+        # Number + Number
+        if isinstance(current, (int, float)):
+            debugPrintOutput("Adding", value, "to", var_name, "(current value:", current, ")")
+            
+            try:
+                if not isinstance(value, (int, float)):
+                    value = parse_number(value)
+
+                self.variables[var_name] = current + value
+            except Exception:
+                # Fall back to string concatenation
+
+                debugPrintOutput(f"Failed to add as numbers, falling back to string concatenation for {var_name}.")
+                self.variables[var_name] = str(current) + str(value)
+
+        # String + Anything
+        elif isinstance(current, str):
+            self.variables[var_name] = current + str(value)
+
+        else:
+            raise TypeError(
+                f"Unsupported type '{type(current).__name__}' for variable '{var_name}'."
+            )
+        
+        return travelled_index
+
+    # Type checking because this is number special only...
+    if (existing_type is not None) and type(value) is not existing_type:
+        raise TypeError(
+            f"Expected {existing_type.__name__}, got {type(value).__name__}"
+        )
+    
+    # Subtraction
+    elif operator == lib_reverse_search["subtract"]:
+        if not isinstance(value, (int, float)):
+            raise TypeError("Subtraction only works with numbers.")
+
+        debugPrintOutput(f"Subtracting {value} from {var_name} (current value: {self.variables.get(var_name, 0)})")
+        self.variables[var_name] -= value
+
+    # Multiplication
+    elif operator == lib_reverse_search["multiply"]:
+        if not isinstance(value, (int, float)):
+            raise TypeError("Multiplication only works with numbers.")
+
+        debugPrintOutput(f"Multiplying {var_name} by {value} (current value: {self.variables.get(var_name, 0)})")
+        self.variables[var_name] *= value
+
+    # Division
+    elif operator == lib_reverse_search["divide"]:
+        if not isinstance(value, (int, float)):
+            raise TypeError("Division only works with numbers.")
+        if value == 0:
+            raise ZeroDivisionError("Division by zero.")
+
+        debugPrintOutput(f"Dividing {var_name} by {value} (current value: {self.variables.get(var_name, 0)})")
+        self.variables[var_name] /= value
+
+    else:
+        raise SyntaxError("Not a valid operator.")
+
+    return travelled_index

modules/parser.py

@@ -0,0 +1,135 @@
+from .tokens import lib_operators, lib_reverse_search, lib_nest_up, lib_nest_down, lib_nest_ambiguous
+from .SETTINGS import debugPrint, debugPrintOutput, debugPrintReturn
+
+from .functions.pointer_related import parse_if_statement, recall_back_to_start_of_loop, skip_parts_of_code, find_next_else_or_end
+from .functions.variable_parsing import convert_to_literal, return_variable_referenced, compute_variable
+
+def print_object(self, tokenized_text):
+    variable = "".join(tokenized_text[self.current_collumn + 1:])
+
+    # Specifically prints whatevers in the variable, or <None> if it doesn't exist
+    if variable in self.variables:
+        print(self.variables[variable])
+    else:
+        print("<None>")
+
+    return len(tokenized_text)
+
+def read_input(self, tokenized_text):
+    # Make sure there are enough tokens
+    if len(tokenized_text) < 2:
+        raise SyntaxError("Expected a variable name.")
+
+    left = tokenized_text[0]
+    right = tokenized_text[1]
+
+    # Ensure both sides exist
+    if not left or not right:
+        raise SyntaxError("Invalid input statement.")
+
+    value = input("")
+
+    self.variables[right] = convert_to_literal(value if len(value) > 0 else None)
+
+    # Return the next token index
+    return self.current_collumn + 2
+
+def handle_loop_statement(self, tokenized_text, total, type="for_loop"):
+    add_token = lib_reverse_search["add"]
+
+    parts = []
+    current = []
+
+    # Skip the LOOP_STATEMENT token
+    for token in tokenized_text[1:]:
+        if token == add_token:
+            if current:
+                parts.append("".join(current))
+                current = []
+        else:
+            current.append(token)
+
+    if current:
+        parts.append("".join(current))
+
+    if type == "while_loop":
+        if len(parts) > 1:
+            raise SyntaxError("While loops only accept a single condition.")
+        
+        check_value = return_variable_referenced(self, parts[0])
+        if check_value <= 0:
+
+            debugPrintOutput("while loop condition failed, skipping...")
+
+            line, col = find_next_else_or_end(self, total)
+
+            self.current_line = line
+            self.current_collumn = col + 1
+
+            return "IGNORE"
+
+        debugPrintOutput("while loop condition passed, continuing...")
+
+        self.loop_labels.append(
+            {
+                "line": self.current_line,
+                "collumn": self.current_collumn,
+                "data": {
+                    "var_check": parts[0],
+                }
+            }
+        )
+        
+        return self.current_collumn + 2
+    
+    if len(parts) < 2:
+        raise SyntaxError("Expected a start and end value.")
+
+    start = return_variable_referenced(self, parts[0])
+    end = return_variable_referenced(self, parts[1])
+    var = parts[2] if len(parts) > 2 else None
+
+    debugPrintOutput("Making a loop statement with the given values:")
+    debugPrintOutput("  start:", start)
+    debugPrintOutput("  end:  ", end)
+    debugPrintOutput("  var:  ", var)
+
+    self.variables[var] = start
+
+    print(self.loop_labels)
+
+    self.loop_labels.append(
+        {
+            "line": self.current_line,
+            "collumn": self.current_collumn,
+            "data": {
+                "start": start,
+                "end": end,
+                "var_name": var,
+                "current": start
+            }
+        }
+    )
+
+    return self.current_collumn + (3 if var is not None else 2)
+
+def compute_action(self, converted_token, tokenized_text, total):
+    if converted_token == lib_reverse_search["set_var"]:
+        return compute_variable(self, tokenized_text)
+    elif converted_token == lib_reverse_search["print"]:
+        return print_object(self, tokenized_text)
+    elif converted_token == lib_reverse_search["input"]:
+        return read_input(self, tokenized_text)
+    elif converted_token == lib_reverse_search["if"]:
+        return parse_if_statement(self, tokenized_text, total)
+    elif converted_token == lib_reverse_search["else"]:
+        return skip_parts_of_code(self, tokenized_text, total)
+    elif converted_token == lib_reverse_search["loop"]:
+        return handle_loop_statement(self, tokenized_text, total, type="for_loop")
+    elif converted_token == lib_reverse_search["while"]:
+        return handle_loop_statement(self, tokenized_text, total, type="while_loop")
+    elif converted_token == lib_reverse_search["next"]:
+        return recall_back_to_start_of_loop(self, tokenized_text, total)
+
+    # Basically does NOTHING
+    return self.current_collumn + 1

modules/tokens.py

@@ -0,0 +1,176 @@
+this_special_identifier = "@1209310239_"
+
+lib_number_tokens = {
+    "mrrm mrrp": '0',
+    "mrrm meow": '1',
+    "mrrm mrow": '2',
+    "mrrm merow": '3',
+    "mrrm maow": '4',
+    "mrrm miau": '5',
+    "mrrm meww": '6',
+    "mrrm mrau": '7',
+    "mrrm myraa": '8',
+    "mrrp mrrm": '9',
+    "mrrp meow": 'a',
+    "mrrp mrow": 'b',
+    "mrrp merow": 'c',
+    "mrrp maow": 'd',
+    "mrrp miau": 'e',
+    "mrrp meww": 'f',
+    "mrrp mrau": 'g',
+    "mrrp myraa": 'h',
+    "meow mrrm": 'i',
+    "meow mrrp": 'j',
+    "meow mrow": 'k',
+    "meow merow": 'l',
+    "meow maow": 'm',
+    "meow miau": 'n',
+    "meow meww": 'o',
+    "meow mrau": 'p',
+    "meow myraa": 'q',
+    "mrow mrrm": 'r',
+    "mrow mrrp": 's',
+    "mrow meow": 't',
+    "mrow merow": 'u',
+    "mrow maow": 'v',
+    "mrow miau": 'w',
+    "mrow meww": 'x',
+    "mrow mrau": 'y',
+    "mrow myraa": 'z',
+    "merow mrrm": 'A',
+    "merow mrrp": 'B',
+    "merow meow": 'C',
+    "merow mrow": 'D',
+    "merow maow": 'E',
+    "merow miau": 'F',
+    "merow meww": 'G',
+    "merow mrau": 'H',
+    "merow myraa": 'I',
+    "maow mrrm": 'J',
+    "maow mrrp": 'K',
+    "maow meow": 'L',
+    "maow mrow": 'M',
+    "maow merow": 'N',
+    "maow miau": 'O',
+    "maow meww": 'P',
+    "maow mrau": 'Q',
+    "maow myraa": 'R',
+    "miau mrrm": 'S',
+    "miau mrrp": 'T',
+    "miau meow": 'U',
+    "miau mrow": 'V',
+    "miau merow": 'W',
+    "miau maow": 'X',
+    "miau meww": 'Y',
+    "miau mrau": 'Z',
+    "miau myraa": '!',
+    "meww mrrm": '"',
+    "meww mrrp": '#',
+    "meww meow": '$',
+    "meww mrow": '%',
+    "meww merow": '&',
+    "meww maow": "'",
+    "meww miau": '(',
+    "meww mrau": ')',
+    "meww myraa": '*',
+    "mrau mrrm": '+',
+    "mrau mrrp": ',',
+    "mrau meow": '-',
+    "mrau mrow": '.',
+    "mrau merow": '/',
+    "mrau maow": ':',
+    "mrau miau": ';',
+    "mrau meww": '<',
+    "mrau myraa": '=',
+    "myraa mrrm": '>',
+    "myraa mrrp": '?',
+    "myraa meow": '@',
+    "myraa mrow": '[',
+    "myraa merow": '\\',
+    "myraa maow": ']',
+    "myraa miau": '^',
+    "myraa meww": '_',
+    "myraa mrau": '`',
+
+    "mya": " ", # whitespace
+
+    # special characters
+    "purrr":        "BUFFER1",
+    "purrrr":       "BUFFER2",
+    "purrrrr":      "BUFFER3",
+    "purrrrrr":     "BUFFER4",
+    "purrrrrrr":    "BUFFER5"
+}
+
+lib_reverse_search = {
+    "set_var":  this_special_identifier + "CODE_SET_VAR",
+    "equal":    this_special_identifier + "CODE_EQUAL",
+    "add":      this_special_identifier + "CODE_ADD",
+    "subtract": this_special_identifier + "CODE_SUBTRACT",
+    "multiply": this_special_identifier + "CODE_MULTIPLY",
+    "divide":   this_special_identifier + "CODE_DIVIDE",
+
+    "equal_to":             this_special_identifier + "CODE_IS_EQUAL",
+    "more_than":            this_special_identifier + "CODE_MORE_THAN",
+    "less_than":            this_special_identifier + "CODE_LESS_THAN",
+    "more_or_equal_to":     this_special_identifier + "CODE_MORE_OR_EQUAL",
+    "less_or_equal_to":     this_special_identifier + "CODE_LESS_OR_EQUAL",
+    
+    "print":    this_special_identifier + "CODE_PRINT",
+    "input":    this_special_identifier + "CODE_INPUT",
+
+    "if": this_special_identifier + "CODE_IF_STATEMENT",
+    "while": this_special_identifier + "CODE_WHILE_STATEMENT",
+    "loop": this_special_identifier + "CODE_LOOP_STATEMENT",
+
+    "end": this_special_identifier + "CODE_END",
+    "next": this_special_identifier + "CODE_LOOP_NEXT",
+    
+    "new_line": this_special_identifier + "CODE_NEW_LINE",
+    "else": this_special_identifier + "CODE_ELSE"
+}
+
+lib_syntax = {
+    "mrrauu": lib_reverse_search["set_var"],
+    "murrp": lib_reverse_search["new_line"],
+
+    "mryau meow": lib_reverse_search["input"],
+    "mryau mrrp": lib_reverse_search["print"],
+    "mryau miau": lib_reverse_search["end"],
+    "mryau meww": lib_reverse_search["else"],
+
+    "mryau mrow": lib_reverse_search["if"],
+
+    "mryau merow mew": lib_reverse_search["while"],
+    "mryau merow maow": lib_reverse_search["loop"],
+    "mryau merow meew": lib_reverse_search["next"]
+}
+
+lib_nest_up = [
+    lib_reverse_search["if"],
+    lib_reverse_search["while"],
+    lib_reverse_search["loop"]
+]
+
+lib_nest_ambiguous = [
+    lib_reverse_search["else"],
+]
+
+lib_nest_down = [
+    lib_reverse_search["end"],
+    lib_reverse_search["next"]
+]
+
+lib_operators = {
+    ":3c":  lib_reverse_search["equal"],
+    ":3":   lib_reverse_search["add"],
+    "3:":   lib_reverse_search["subtract"],
+    ">:3":  lib_reverse_search["multiply"],
+    "3:<":  lib_reverse_search["divide"],
+
+    ":3c?":  lib_reverse_search["equal_to"],
+    ":3?":   lib_reverse_search["more_than"],
+    "3:?":   lib_reverse_search["less_than"],
+    ">:3?":  lib_reverse_search["more_or_equal_to"],
+    "3:<?":  lib_reverse_search["less_or_equal_to"],
+}