Refactor build system: add file generation from templates, update Makefile, and enhance README. No more hardcoded ../../.. that needs manual adjusting, better portability.

Author: IntegralPilot

.gitignore

@@ -13,4 +13,8 @@
 **/*.txt
 
 # Crash logs generated by the JVM
-**/*.log
+**/*.log
+
+# Generated by GenerateFiles.py
+jvm-unknown-unknown.json
+config.toml

GenerateFiles.py

@@ -0,0 +1,31 @@
+import os
+import platform
+
+# get the absolute path of the current working directory
+current_directory = os.path.dirname(os.path.abspath(__file__))
+
+# find .template files in this current directory
+template_files = []
+for root, dirs, files in os.walk(current_directory):
+    for file in files:
+        if file.endswith(".template"):
+            template_files.append(os.path.join(root, file))
+
+# copy them, removing the .template extension
+# replace all instances of "../../.." with the absolute path of the current working directory
+# Determine the appropriate dynamic library extension for the host platform
+if platform.system() == "Windows":
+    lib_extension = ".dll"
+elif platform.system() == "Darwin":  # macOS
+    lib_extension = ".dylib"
+else:  # Assume Linux or other Unix-like systems
+    lib_extension = ".so"
+
+for template_file in template_files:
+    with open(template_file, 'r') as f:
+        content = f.read()
+    content = content.replace("../../..", current_directory)
+    content = content.replace(".dylib", lib_extension)
+    new_file_path = os.path.splitext(template_file)[0]
+    with open(new_file_path, 'w') as f:
+        f.write(content)

Makefile

@@ -1,16 +1,22 @@
 # === Phony Targets ===
-.PHONY: all clean help rust clean-rust java-linker clean-java-linker \
-        shim-metadata-gen clean-shim-metadata-gen \
-        asm-processor clean-asm-processor \
-        library clean-library
+.PHONY: all help clean rust-components rust clean-rust java-linker clean-java-linker \
+        shim-metadata-gen clean-shim-metadata-gen asm-processor clean-asm-processor \
+        library clean-library gen-files clean-gen-files
 
 # === Terminal Colors ===
 GREEN  := \033[1;32m
 CYAN   := \033[1;36m
 RESET  := \033[0m
 
+# === Directory Variables ===
+JAVA_LINKER_DIR := java-linker
+SHIM_METADATA_GEN_DIR := shim-metadata-gen
+ASM_PROCESSOR_DIR := asm-processor
+LIBRARY_DIR := library
+LIBRARY_JAR := $(LIBRARY_DIR)/build/libs/library-0.1.0.jar
+
 # === Default Target ===
-all: rust java-linker asm-processor
+all: rust gen-files java-linker asm-processor
 	@echo "$(GREEN)✨ Build complete! ✨$(RESET)"
 
 # === Help ===
@@ -20,15 +26,22 @@ help:
 	@echo "Available targets:"
 	@echo "  make all                  - Build all components"
 	@echo "  make clean                - Clean all components"
+	@echo "  make rust-components      - Install needed Rust components"
 	@echo "  make rust                 - Build the Rust root project"
 	@echo "  make java-linker          - Build the Java Linker subproject"
 	@echo "  make shim-metadata-gen    - Generate library shim metadata"
 	@echo "  make asm-processor        - Build the ASM processor"
 	@echo "  make library              - Build the standard library shim"
+	@echo "  make gen-files            - Generate necessary files from templates"
 	@echo "  make clean-*              - Clean individual components"
 
+# === Needed rust components ===
+rust-components:
+	@echo "$(CYAN)🔧 Installing Rust components...$(RESET)"
+	rustup component add rust-src rustc-dev llvm-tools-preview
+
 # === Rust root project (Cargo) ===
-rust: shim-metadata-gen
+rust: $(SHIM_METADATA_GEN_DIR)/core.json rust-components
 	@echo "$(CYAN)📦 Building Rust root project...$(RESET)"
 	cargo build
 
@@ -39,40 +52,52 @@ clean-rust:
 # === Java Linker Subproject ===
 java-linker:
 	@echo "$(CYAN)📦 Building Java Linker...$(RESET)"
-	cd java-linker && cargo build
+	cd $(JAVA_LINKER_DIR) && cargo build
 
 clean-java-linker:
 	@echo "$(CYAN)🧹 Cleaning Java Linker...$(RESET)"
-	cd java-linker && cargo clean
+	cd $(JAVA_LINKER_DIR) && cargo clean
 
-# === Library shim metadata generator ===
-# needs to clean first so unzip doesn't prompt for overwrite
-shim-metadata-gen: clean-library library
-	@echo "$(CYAN)🔧 Generating shim metadata...$(RESET)"
-	cd shim-metadata-gen && rm -f core.json && cargo run -- ../library/build/libs/library-0.1.0.jar ./core.json
+# === Library Shim Metadata Generator ===
+$(SHIM_METADATA_GEN_DIR)/core.json: library
+	@echo "$(CYAN)🛠️  Generating library shim metadata...$(RESET)"
+	cd $(SHIM_METADATA_GEN_DIR) && cargo run -- ../$(LIBRARY_JAR) ./core.json
 
 clean-shim-metadata-gen:
 	@echo "$(CYAN)🧹 Cleaning shim-metadata-gen...$(RESET)"
-	cd shim-metadata-gen && cargo clean
+	cd $(SHIM_METADATA_GEN_DIR) && cargo clean
+	rm -f $(SHIM_METADATA_GEN_DIR)/core.json
 
 # === ASM Processor (Gradle) ===
 asm-processor:
 	@echo "$(CYAN)⚙️  Building ASM processor...$(RESET)"
-	cd asm-processor && gradle shadowJar
+	cd $(ASM_PROCESSOR_DIR) && gradle shadowJar
 
 clean-asm-processor:
 	@echo "$(CYAN)🧹 Cleaning ASM processor...$(RESET)"
-	cd asm-processor && gradle clean
+	cd $(ASM_PROCESSOR_DIR) && gradle clean
 
 # === Standard Library Shim (Gradle) ===
-library:
+library: $(LIBRARY_JAR)
+
+$(LIBRARY_JAR):
 	@echo "$(CYAN)📚 Building standard library shim...$(RESET)"
-	cd library && gradle build && cd build/distributions && unzip library-0.1.0.zip
+	cd $(LIBRARY_DIR) && gradle build && cd build/distributions && unzip -o library-0.1.0.zip
 
 clean-library:
 	@echo "$(CYAN)🧹 Cleaning library shim...$(RESET)"
-	cd library && gradle clean
+	cd $(LIBRARY_DIR) && gradle clean
+
+# === Generate files from templates ==
+gen-files: clean-gen-files
+	@echo "$(CYAN)🛠️  Generating files from templates...$(RESET)"
+	python3 GenerateFiles.py
+	@echo "$(CYAN)🛠️  Files generated!$(RESET)"
+
+clean-gen-files:
+	@echo "$(CYAN)🧹 Cleaning template generated files...$(RESET)"
+	rm -f jvm-unknown-unknown.json config.toml
 
 # === Clean All ===
-clean: clean-rust clean-java-linker clean-asm-processor clean-library clean-shim-metadata-gen
-	@echo "$(GREEN)🧼 All clean!$(RESET)"
+clean: clean-rust clean-java-linker clean-asm-processor clean-library clean-shim-metadata-gen clean-gen-files
+	@echo "$(GREEN)🧼 All clean!$(RESET)"

Readme.md

@@ -2,7 +2,7 @@
 
 [![License: MIT OR Apache-2.0](https://img.shields.io/badge/License-MIT%20OR%20Apache--2.0-blue.svg)](https://opensource.org/licenses/MIT)
 
-Welcome! This project provides a custom Rust compiler backend (`rustc_codegen_jvm`) that compiles Rust code into Java Virtual Machine (JVM) bytecode. This allows Rust programs to run on the JVM. Currently, the generated bytecode supports JRE 8 and later versions.
+Welcome! This project provides a custom Rust compiler backend (`rustc_codegen_jvm`) that compiles Rust code into Java Virtual Machine (JVM) bytecode. This allows Rust programs to run on the JVM. Currently, the generated bytecode supports JVM 8 and later versions.
 
 ## How It Works
 
@@ -34,67 +34,49 @@ This backend currently supports a subset of Rust features:
     *   Checked addition and subtraction (`checked_add`, `checked_sub`) returning `(result, overflowed_bool)` tuples.
 *   ✅ Comparisons (`==`, `!=`, `<`, `<=`, `>`, `>=`).
 *   ✅ Bitwise operations (`&`, `|`, `^`, `<<`, `>>`).
-*   ✅ Basic control flow: `if`/`else` statements, `panic!` / `assert!` (with simple string messages).
+*   ✅ Basic control flow: `if`/`else` statements, `panic!` / `assert!` (including multiple arguments and formatting (`{}`) of most rust primitives)
 *   ✅ Calling other `static` functions within the same crate (including recursion).
 *   ✅ Basic variable assignment (`let x = y;`).
 *   ✅ Arrays and slices.
+*   ✅ Floats (`f32`, `f64`).
 *   ✅ Generating executable `.jar` files for binary crates.
 
 ### Next Milestone:
 🚧 **Full support for the `core` crate** is the next major goal.
 
 ## Prerequisites
 
-*   **Rust Nightly:** Ensure you are using the latest **nightly** Rust toolchain. You can set this up with `rustup default nightly`.
-*   **Rust Components:** Install necessary components:
-    ```bash
-    rustup component add rust-src rustc-dev llvm-tools-preview
-    ```
-    *(Note: The `rust-toolchain.toml` file in the repository should handle this automatically if you use `cargo` within the project.)*
+*   **Rust Nightly:** Ensure you are using the latest **nightly** Rust toolchain. You can set this up with `rustup default nightly`. Some rust components are needed but will be automatically installed by the Makefile.
 *   **Java Development Kit (JDK):** A working JDK (version 8 or later recommended) is required to run the generated `.jar` files and the `asm-processor`. Make sure `java` is in your PATH.
 *   **Gradle:** Required to build the `asm-processor` Kotlin project. Make sure `gradle` is in your PATH.
+*  **Python 3:** Required to run the integration tests and generate files from templates. Make sure `python3` is in your PATH.
 
 ## Building the Toolchain
 
-1.  **Run Setup Script (if needed):**
-    *   The `setup.sh` script mainly adds rustup components, which `rust-toolchain.toml` might already handle. Ensure the components listed in Prerequisites are installed.
-2.  **Build All Components:**
+1.  **Build All Components:**
     *   You can use the provided Makefile or build script:
       ```bash
       # Using Make
       make all
       ```
     *   This will:
-        *   Build the main `rustc_codegen_jvm` library (`target/debug/librustc_codegen_jvm.dylib`).
+        *   Build the main `rustc_codegen_jvm` library (`target/debug/librustc_codegen_jvm.[dll/dylib/so]`).
         *   Build the `java-linker` (`java-linker/target/debug/java-linker`).
         *   Build the `asm-processor` (`asm-processor/build/libs/asm-processor-*.jar`).
+        *   Build the Kotlin shim of the Rust core library (`library`).
+        *   Generate the `config.toml` and `jvm-unknown-unknown.json` files from their templates.
+
 
 ## Using the Toolchain (Compiling Another Rust Project)
 
 To compile *your own* Rust project using this backend:
 
-1.  **Get the Toolchain:** Clone this repository and build it as described above. Let's assume you cloned it to `/path/to/rustc_codegen_jvm`. Ensure you build the toolchain first, as described in the previous section.
+1.  **Get the Toolchain:** Clone this repository and build it as described above. Ensure you build the toolchain first, as described in the previous section, by running `make all`. You will need to re-run `make gen-files` if you change the absolute path of where this repository is stored since building.
 
 
 2.  **Configure Your Rust Project:**
     *   In your *own* Rust project's directory, create a `.cargo/config.toml` file (if it doesn't exist).
-    *   Add the following content to the file:
-        ```toml
-        [build]
-        rustflags = [
-          "-Z", "codegen-backend=/path/to/rustc_codegen_jvm/target/debug/librustc_codegen_jvm.dylib",
-          "-C", "linker=/path/to/rustc_codegen_jvm/java-linker/target/debug/java-linker",
-          "-C", "link-args=/path/to/rustc_codegen_jvm/library/build/distributions/library-0.1.0/lib/library-0.1.0.jar /path/to/rustc_codegen_jvm/library/build/distributions/library-0.1.0/lib/kotlin-stdlib-2.1.20.jar --asm-processor /path/to/rustc_codegen_jvm/asm-processor/build/libs/asm-processor-1.0-SNAPSHOT-all.jar --known-good kotlin-stdlib"
-        ]
-
-        # Throwing a JVM exception will unwind and give a stack trace, no need for rust to handle unwinding.
-        [profile.debug]
-        panic = "abort"
-
-        [profile.release]
-        panic = "abort"
-        ```
-    *   **Important:** Replace `/path/to/rustc_codegen_jvm/...` with the path to where you cloned the repository. If you're not on macOS, changed `.dylib` to `.so` for Linux or `.dll` for Windows.
+    * Copy the contents from the `config.toml` file generated specifically for your system, that can be found in the root of this project after running `make all`. If since running make, you've moved this repo to a different directory, you'll need to run at least `make gen-files`.
 
 3.  **Build Your Project:**
     *   Run the standard Cargo build command, targeting the host target (using the `jvm-unknown-unknown` target is an emerging feature and means you can't even use `core`, for now, so not recommended). Cargo will read the `.cargo/config.toml` and use the specified target and flags automatically.
@@ -117,15 +99,14 @@ To compile *your own* Rust project using this backend:
 
 This project includes integration tests managed by a Python script.
 
-1.  **Ensure Toolchain is Built:** Build the project using `make all`.
-2.  **Check Target JSON:** Make sure the `jvm-unknown-unknown.json` file in the *root* of this repository has the **relative paths** starting with `/path/to/rustc_codegen_jvm/` for the linker and backend, as the tester expects this structure when running tests from subdirectories. If you changed them to absolute paths for external use, change them back temporarily.
-3.  **Run the Tester:**
+1.  **Ensure Toolchain is Built:** Build the project using `make all`. If you've changed the path of the repository, run `make gen-files` to regenerate the configuration files.
+2.  **Run the Tester:**
     ```bash
     python3 Tester.py
     # For release mode tests:
     # python3 Tester.py --release
     ```
-4.  **Check Output:** Look for the final "✅ All tests passed!" message. If tests fail, the script will generate `.generated` files in the respective test directories (`tests/binary/*`) containing error details or output diffs.
+3.  **Check Output:** Look for the final "✅ All tests passed!" message. If tests fail, the script will generate `.generated` files in the respective test directories (`tests/binary/*`) containing error details or output diffs.
 
 ## Project Structure
 
@@ -141,8 +122,10 @@ This project includes integration tests managed by a Python script.
 *   `library/`: Source code for a minimal Kotlin-based implementation of the Rust core library. This serves as a temporary substitute to bootstrap the project until the backend can fully compile the Rust core library itself.
 *   `shim-metadata-gen`: A tool for generating metadata for the Kotlin core library, called at compiletime to provide nessecary info (descriptors) to the codegen backend. It's generated metadata is embedded in the generated library, so not needed at runtime.
     *   `core.json`: Metadata for the core library, generated by this tool.
-*   `jvm-unknown-unknown.json`: The Rust target specification file.
+*   `jvm-unknown-unknown.json.template`: The template for Rust target specification file (currently experimental & not recommended, use `config.toml` in your project instead).
+*  `config.toml.template`: The template for the Cargo configuration file for the toolchain.
 *   `Tester.py`: Python script for running integration tests.
+*   `GenerateFiles.py` : Python script for generating the `config.toml` file and the `jvm-unknown-unknown.json` file from their templates, making them suited to your system.
 *   `Makefile` Scripts for building the entire toolchain.
 *   `setup.sh`: Script to install Rust components.
 *   `Cargo.toml`, `Cargo.lock`: Rust package definition and dependencies for the backend.

config.toml.template

@@ -0,0 +1,13 @@
+[build]
+rustflags = [
+  "-Z", "codegen-backend=../../../target/debug/librustc_codegen_jvm.dylib",
+  "-C", "linker=../../../java-linker/target/debug/java-linker",
+  "-C", "link-args=../../../library/build/distributions/library-0.1.0/lib/library-0.1.0.jar ../../../library/build/distributions/library-0.1.0/lib/kotlin-stdlib-2.1.20.jar --asm-processor ../../../asm-processor/build/libs/asm-processor-1.0-SNAPSHOT-all.jar --known-good kotlin-stdlib"
+]
+
+# Throwing a JVM exception will unwind and give a stack trace, no need for rust to handle unwinding.
+[profile.debug]
+panic = "abort"
+
+[profile.release]
+panic = "abort"

jvm-unknown-unknown.json renamed to jvm-unknown-unknown.json.template

@@ -1,3 +1,3 @@
 [toolchain]
 channel = "nightly"
-components = ["rustc-dev", "llvm-tools-preview"]
+components = ["rustc-dev", "rust-src", "llvm-tools-preview"]

rust-toolchain.toml

@@ -1,30 +1,30 @@
 {
-  "arguments_new_const": {
-    "descriptor": "([Ljava/lang/String;)Ljava/lang/String;",
+  "panic_fmt": {
+    "descriptor": "(Ljava/lang/String;)V",
     "is_static": true
   },
-  "core_fmt_rt_argument_new_display_i32": {
-    "descriptor": "(I)Ljava/lang/String;",
+  "arguments_new_const": {
+    "descriptor": "([Ljava/lang/String;)Ljava/lang/String;",
     "is_static": true
   },
   "core_fmt_rt_argument_new_display": {
     "descriptor": "(Ljava/lang/Object;)Ljava/lang/String;",
     "is_static": true
   },
-  "core_fmt_rt_argument_new_display_f64": {
-    "descriptor": "(D)Ljava/lang/String;",
+  "core_fmt_rt_argument_new_display_i32": {
+    "descriptor": "(I)Ljava/lang/String;",
     "is_static": true
   },
-  "core_fmt_rt_argument_new_display_bool": {
-    "descriptor": "(Z)Ljava/lang/String;",
+  "core_fmt_rt_argument_new_display_f64": {
+    "descriptor": "(D)Ljava/lang/String;",
     "is_static": true
   },
   "arguments_new_v1": {
     "descriptor": "([Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;",
     "is_static": true
   },
-  "panic_fmt": {
-    "descriptor": "(Ljava/lang/String;)V",
+  "core_fmt_rt_argument_new_display_bool": {
+    "descriptor": "(Z)Ljava/lang/String;",
     "is_static": true
   }
 }