feat: support arbitrary pointer literals and expand CLI build options (#275)

This commit enhances the handling of pointer literals in the LLVM backend
and introduces new CLI capabilities for building object files and
executables.

Changes:
- **Pointer Literal Enhancements**:
  - Relaxed the restriction on pointer literals. Previously, only `0`
    was allowed as a null pointer.
  - Now supports arbitrary numeric literals by parsing them as integers
    and using `build_int_to_ptr` to cast them to the target pointer type.
  - Added a panic check to prevent negative numeric literals from being
    used as pointers.
- **CLI & Command Expansion**:
  - **`run` command**: Added a `--img` flag to trigger an image-based
    build-and-run flow.
  - **`build` command**:
    - Added a `-o` flag to compile source files into machine object
      files (`.o`).
    - The default build command now compiles and links files into a
      final binary inside the `target/` directory.
- **Runner & Pipeline Refactoring**:
  - Implemented `object_build_wave_file` to handle the full compilation
    pipeline (lexing, parsing, IR generation, and object code emission)
    with detailed debug support for tokens, AST, and hex dumps.
  - Implemented `build_wave_file` to orchestrate the linking of
    generated object files into executable binaries.
- **Library API**:
  - Exported `compile_and_build` and `compile_and_build_obj` in `lib.rs`
    to provide programmatic access to the new build workflows.

These changes provide more flexibility for system-level programming and
improve the developer experience when managing build artifacts.

Author: LunaStev

llvm_temporary/src/llvm_temporary/expression/rvalue/literals.rs

@@ -55,11 +55,24 @@ pub(crate) fn gen<'ctx, 'a>(
             }
 
             Some(BasicTypeEnum::PointerType(ptr_ty)) => {
-                if is_zero_decimal(v.as_str()) {
-                    ptr_ty.const_null().as_basic_value_enum()
-                } else {
-                    panic!("Only 0 can be used as null pointer literal");
+                let s = v.as_str();
+                let (neg, raw) = parse_signed_decimal(s);
+                let (radix, digits) = parse_int_radix(raw);
+
+                if neg {
+                    panic!("negative pointer literal not allowed: {}", s);
                 }
+
+                let int_val = env
+                    .context
+                    .i64_type()
+                    .const_int_from_string(digits, radix)
+                    .unwrap_or_else(|| panic!("invalid pointer literal: {}", s));
+
+                env.builder
+                    .build_int_to_ptr(int_val, ptr_ty, "int_to_ptr")
+                    .unwrap()
+                    .as_basic_value_enum()
             }
 
             Some(BasicTypeEnum::FloatType(ft)) => {

src/lib.rs

@@ -14,6 +14,14 @@ pub unsafe fn compile_and_run(path: &Path, opt_flag: &str, debug: &DebugFlags) {
     runner::run_wave_file(path, opt_flag, debug);
 }
 
+pub unsafe fn compile_and_build(path: &Path, opt_flag: &str, debug: &DebugFlags) {
+    runner::build_wave_file(path, opt_flag, debug);
+}
+
+pub unsafe fn compile_and_build_obj(path: &Path, opt_flag: &str, debug: &DebugFlags) {
+    runner::object_build_wave_file(path, opt_flag, debug);
+}
+
 pub unsafe fn compile_and_img(path: &Path) {
     runner::img_wave_file(path);
 }

src/main.rs

@@ -4,7 +4,7 @@ use std::{env, process};
 use utils::colorex::*;
 use wavec::commands::{handle_build, handle_install_std, handle_run, handle_update_std, DebugFlags};
 use wavec::errors::CliError;
-use wavec::version_wave;
+use wavec::{compile_and_build, compile_and_build_obj, version_wave};
 
 fn main() {
     if let Err(e) = run() {
@@ -51,23 +51,44 @@ fn run() -> Result<(), CliError> {
         }
 
         "run" => {
-            let file = iter.next().ok_or(CliError::MissingArgument {
+            let next = iter.next().ok_or(CliError::MissingArgument {
                 command: "run",
-                expected: "<file>",
+                expected: "<file | --img>",
             })?;
 
-            handle_run(Path::new(&file), &opt_flag, &debug_flags)?;
+            if next == "--img" {
+                let file = iter.next().ok_or(CliError::MissingArgument {
+                    command: "run --img",
+                    expected: "<file>",
+                })?;
+
+                handle_build(Path::new(&file), &opt_flag, &debug_flags)?;
+            } else {
+                handle_run(Path::new(&next), &opt_flag, &debug_flags)?;
+            }
         }
 
         "build" => {
-            let file = iter.next().ok_or(CliError::MissingArgument {
+            let next = iter.next().ok_or(CliError::MissingArgument {
                 command: "build",
-                expected: "<file>",
+                expected: "<file | -o>",
             })?;
 
-            handle_build(Path::new(&file), &opt_flag, &debug_flags)?;
+            unsafe {
+                if next == "-o" {
+                    let file = iter.next().ok_or(CliError::MissingArgument {
+                        command: "build -o",
+                        expected: "<file>",
+                    })?;
+
+                    compile_and_build_obj(Path::new(&file), &opt_flag, &debug_flags);
+                } else {
+                    compile_and_build(Path::new(&next), &opt_flag, &debug_flags);
+                }
+            }
         }
 
+
         "install" => {
             let target = iter.next().ok_or(CliError::MissingArgument {
                 command: "install",

src/runner.rs

@@ -163,6 +163,109 @@ pub(crate) unsafe fn run_wave_file(file_path: &Path, opt_flag: &str, debug: &Deb
     }
 }
 
+pub(crate) unsafe fn object_build_wave_file(
+    file_path: &Path,
+    opt_flag: &str,
+    debug: &DebugFlags,
+) -> String {
+    let code = fs::read_to_string(file_path).unwrap_or_else(|_| {
+        WaveError::new(
+            WaveErrorKind::FileReadError(file_path.display().to_string()),
+            format!("failed to read file `{}`", file_path.display()),
+            file_path.display().to_string(),
+            0,
+            0,
+        )
+            .display();
+        process::exit(1);
+    });
+
+    let mut lexer = Lexer::new(&code);
+    let tokens = lexer.tokenize();
+
+    let ast = parse(&tokens).unwrap_or_else(|| {
+        WaveError::new(
+            WaveErrorKind::SyntaxError("failed to parse Wave code".to_string()),
+            "failed to parse Wave code",
+            file_path.display().to_string(),
+            0,
+            0,
+        )
+            .display();
+        process::exit(1);
+    });
+
+    if debug.tokens {
+        println!("\n===== Tokens =====");
+        for token in &tokens {
+            println!("{:?}", token);
+        }
+    }
+
+    if debug.ast {
+        println!("\n===== AST =====\n{:#?}", ast);
+    }
+
+    let ast = expand_imports_for_codegen(file_path, ast).unwrap_or_else(|e| {
+        e.display();
+        process::exit(1);
+    });
+
+    let ir = generate_ir(&ast);
+
+    if debug.ir {
+        println!("\n===== LLVM IR =====\n{}", ir);
+    }
+
+    let file_stem = file_path.file_stem().unwrap().to_str().unwrap();
+    let object_path = compile_ir_to_object(&ir, file_stem, opt_flag);
+
+    if debug.mc {
+        println!("\n===== MACHINE CODE PATH =====");
+        println!("{}", object_path);
+    }
+
+    if debug.hex {
+        println!("\n===== HEX DUMP =====");
+        let data = fs::read(&object_path).unwrap();
+        for (i, b) in data.iter().enumerate() {
+            if i % 16 == 0 {
+                print!("\n{:04x}: ", i);
+            }
+            print!("{:02x} ", b);
+        }
+        println!();
+    }
+
+    object_path
+}
+
+pub(crate) unsafe fn build_wave_file(
+    file_path: &Path,
+    opt_flag: &str,
+    debug: &DebugFlags,
+) {
+    let object_path = object_build_wave_file(file_path, opt_flag, debug);
+
+    let file_stem = file_path.file_stem().unwrap().to_str().unwrap();
+    let exe_path = format!("target/{}", file_stem);
+
+    let link_libs: Vec<String> = Vec::new();
+    let link_lib_paths: Vec<String> = Vec::new();
+
+    link_objects(
+        &[object_path],
+        &exe_path,
+        &link_libs,
+        &link_lib_paths,
+    );
+
+    if debug.mc {
+        println!("\n===== OUTPUT BINARY =====");
+        println!("{}", exe_path);
+    }
+}
+
 pub(crate) unsafe fn img_wave_file(file_path: &Path) {
     let code = fs::read_to_string(file_path).expect("Failed to read file");