it.txt

        ultranLang:
        {
            if (!tests.isEnabled("ultran_lang")) break ultranLang;
            SpiKt.setShouldLogInternalErrors(false);
            SpiKt.setShouldLogScope(false);
            SpiKt.setShouldLogStack(false);
            SpiKt.setShouldLogTokens(false);

            String text = """
                    program Main;

                    function Alpha(a: integer; b: integer) {
                        function Beta(a: integer; b: integer) {
                            var x: integer;
                            x = a * 10 + b * 2;
                        };
                        var x: integer;
                        x = (a + b ) * 2;
                        Beta(5, 10);      [ function call ]
                    };

                    Alpha(3 + 5, 7);  [ function call ]
                    var x: integer;
                    x = 300;
                    var startX: integer;
                    var startY: integer;
                    startX = 10;
                    startY = 20;

                    function PrintHelloWorld() {
                        log("info", "Hello World from an UltranLang script.");
                    };

                    PrintHelloWorld();

                    log("info", "Hello World! Number: " + randInt(startX, startY));
                    """;

            NativeCalls calls = new NativeCalls();
            registerNativeFunctions(calls);

            var lexer = new Lexer(text);
            Program tree;
            try {
                var parser = new Parser(lexer);
                tree = parser.parse();
            } catch (LexerException | ParserException e) {
                if (SpiKt.getShouldLogInternalErrors()) e.printStackTrace();
                LOGGER.error("Error parsing file: {}", e.getMessage());
                break ultranLang;
            } catch (RuntimeException e) {
                var cause = e.getCause();
                while (cause instanceof InvocationTargetException || cause instanceof RuntimeException) {
                    cause = cause.getCause();
                }
                if (cause instanceof LexerException) {
                    if (SpiKt.getShouldLogInternalErrors()) cause.printStackTrace();
                    LOGGER.error("Error parsing file: {}", cause.getMessage());
                } else if (cause instanceof ParserException) {
                    if (SpiKt.getShouldLogInternalErrors()) cause.printStackTrace();
                    LOGGER.error("Error parsing file: {}", cause.getMessage());
                } else {
                    throw e;
                }
                break ultranLang;
            }

            var semanticAnalyzer = new SemanticAnalyzer(calls);

            try {
                semanticAnalyzer.visit(tree);
            } catch (SemanticException e) {
                if (SpiKt.getShouldLogInternalErrors()) e.printStackTrace();
                LOGGER.error("Error analyzing file: {}", e.getMessage());
                break ultranLang;
            } catch (RuntimeException e) {
                var cause = e.getCause();
                while (cause instanceof InvocationTargetException || cause instanceof RuntimeException) {
                    cause = cause.getCause();
                }
                if (cause instanceof SemanticException) {
                    if (SpiKt.getShouldLogInternalErrors()) cause.printStackTrace();
                    ULTRAN_LANG_LOGGER.error("Error analyzing file: {}", cause.getMessage());
                } else {
                    throw e;
                }
                break ultranLang;
            }

            try {
                var interpreter = new Interpreter(tree);
                interpreter.interpret();
            } catch (Exception e) {
                if (SpiKt.getShouldLogInternalErrors()) e.printStackTrace();
                LOGGER.error("Error interpreting file: {}", e.getMessage());
            }
        }
    }

    private static void registerNativeFunctions(NativeCalls calls) {
        calls.register("log", SpiKt.params()
                .add("level", BuiltinTypeSymbol.STRING)
                .add("message", BuiltinTypeSymbol.STRING), ar -> {
            Object level = ar.get("level");
            if (level instanceof String levelName) {
                Object message = ar.get("message");
                if (message == null) message = "null";

                switch (levelName.toLowerCase(Locale.ROOT)) {
                    case "warn" -> ULTRAN_LANG_LOGGER.warn(message.toString());
                    case "error" -> ULTRAN_LANG_LOGGER.error(message.toString());
                    case "debug" -> ULTRAN_LANG_LOGGER.debug(message.toString());
                    case "trace" -> ULTRAN_LANG_LOGGER.trace(message.toString());
                    default -> ULTRAN_LANG_LOGGER.info(message.toString());
                }
            } else {
                throw new IllegalArgumentException("Invalid level of type " + (level == null ? "null" : level.getClass().getName()));
            }
            return null;
        });
    }