main

Classes:

• ArxMain –

Functions:

• get_module_name_from_file_path –

ArxMain dataclass

ArxMain(
    input_files: list[str] = list(),
    output_file: str = "",
    is_lib: bool = False,
    link_mode: Literal["auto", "pie", "no-pie"] = "auto",
)

Methods:

• compile –
• run –
• run_binary –
• run_shell –
• show_ast –
• show_llvm_ir –
• show_tokens –

compile

compile(show_llvm_ir: bool = False) -> bool

Source code in src/arx/main.py

def compile(self, show_llvm_ir: bool = False) -> bool:
    """
    title: Compile the given input file.
    parameters:
      show_llvm_ir:
        type: bool
    returns:
      type: bool
    """
    tree_ast = self._get_codegen_astx()
    ir = LLVMLiteIR()
    self.output_file = self._resolve_output_file()
    emits_executable = not self.is_lib and self._has_main_entry(tree_ast)
    ir.build(
        tree_ast,
        output_file=self.output_file,
        link=emits_executable,
        link_mode=self.link_mode,
    )
    return emits_executable

run

run(**kwargs: Any) -> None

Source code in src/arx/main.py

def run(self, **kwargs: Any) -> None:
    """
    title: Compile the given source code.
    parameters:
      kwargs:
        type: Any
        variadic: keyword
    """
    self.input_files = kwargs.get("input_files", [])
    output_file = kwargs.get("output_file")
    self.output_file = output_file.strip() if output_file else ""
    self.is_lib = kwargs.get("is_lib", False)
    link_mode = str(kwargs.get("link_mode", "auto")).strip().lower()
    if link_mode not in {"auto", "pie", "no-pie"}:
        raise ValueError(
            "Invalid link mode. Expected one of: auto, pie, no-pie."
        )
    self.link_mode = cast(
        Literal["auto", "pie", "no-pie"],
        link_mode,
    )

    if kwargs.get("show_ast"):
        return self.show_ast()

    if kwargs.get("show_tokens"):
        return self.show_tokens()

    if kwargs.get("show_llvm_ir"):
        return self.show_llvm_ir()

    if kwargs.get("shell"):
        return self.run_shell()

    emits_executable = self.compile()
    if kwargs.get("run"):
        if emits_executable is False:
            raise ValueError(
                "`--run` requires `fn main` (or disable `--lib`)."
            )
        self.run_binary()

run_binary

run_binary() -> None

Source code in src/arx/main.py

def run_binary(self) -> None:
    """
    title: Run the generated binary.
    """
    binary_path = Path(self.output_file)
    if not binary_path.is_absolute():
        binary_path = Path.cwd() / binary_path
    result = subprocess.run([str(binary_path)], check=False)
    if result.returncode != 0:
        raise SystemExit(result.returncode)

run_shell

run_shell() -> None

Source code in src/arx/main.py

def run_shell(self) -> None:
    """
    title: Open arx in shell mode.
    """
    raise Exception("Arx Shell is not implemented yet.")

show_ast

show_ast() -> None

Source code in src/arx/main.py

def show_ast(self) -> None:
    """
    title: Print the AST for the given input file.
    """
    tree_ast = self._get_astx()
    try:
        print(repr(tree_ast))
    except Exception:
        try:
            if hasattr(tree_ast, "to_json"):
                print(tree_ast.to_json())
                return
        except Exception:
            pass

        if isinstance(tree_ast, astx.AST):
            print(self._format_ast_fallback(tree_ast))
            return

        # Fallback for nodes whose repr visualizer path is not supported.
        print(str(tree_ast))

show_llvm_ir

show_llvm_ir() -> None

Source code in src/arx/main.py

def show_llvm_ir(self) -> None:
    """
    title: Compile into LLVM IR the given input file.
    """
    tree_ast = self._get_codegen_astx()
    ir = LLVMLiteIR()
    print(ir.translator.translate(tree_ast))

show_tokens

show_tokens() -> None

Source code in src/arx/main.py

def show_tokens(self) -> None:
    """
    title: Print the AST for the given input file.
    """
    lexer = Lexer()

    for input_file in self.input_files:
        ArxIO.file_to_buffer(input_file)
        tokens = lexer.lex()
        for token in tokens:
            print(token)

get_module_name_from_file_path

get_module_name_from_file_path(filepath: str) -> str

Source code in src/arx/main.py

def get_module_name_from_file_path(filepath: str) -> str:
    """
    title: Return the module name from the source file name.
    parameters:
      filepath:
        type: str
    returns:
      type: str
    """
    return filepath.rsplit(os.sep, maxsplit=1)[-1].replace(".x", "")