Add C bindings

.github/workflows/artifact.yml

@@ -0,0 +1,56 @@
+on: [push]
+
+name: Artifacts
+
+jobs:
+  x64:
+    name: Build 64 bit C Libraries
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+      - name: Build cgenie libraries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --release -p cgenie-drs -p cgenie-hki -p cgenie-lang -p cgenie-scx -p cgenie
+      - name: Prepare artifact
+        run: |
+          mkdir -p artifact/libs/
+          cp target/release/*.dll artifact/libs/
+          cp target/release/*.lib artifact/libs/
+          cp -R c/include artifact/
+      - uses: actions/upload-artifact@v1
+        with:
+          name: cgenie-x64-win
+          path: artifact
+  x86:
+    name: Build 32 bit C Libraries
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          target: i686-pc-windows-msvc
+          override: true
+      - name: Build cgenie libraries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --target i686-pc-windows-msvc --release -p cgenie-drs -p cgenie-hki -p cgenie-lang -p cgenie-scx -p cgenie
+      - name: Prepare artifact
+        run: |
+          mkdir -p artifact/libs/
+          cp target/i686-pc-windows-msvc/release/*.dll artifact/libs/
+          cp target/i686-pc-windows-msvc/release/*.lib artifact/libs/
+          cp -R c/include artifact/
+      - uses: actions/upload-artifact@v1
+        with:
+          name: cgenie-x86-win
+          path: artifact

Cargo.toml

@@ -34,5 +34,13 @@ members = [
   "crates/genie-rec",
   "crates/genie-scx",
   "crates/genie-support",
-  "crates/jascpal"
+  "crates/jascpal",
+
+  "c/cgenie",
+  # need to figure out FFI generics to make this work
+  # "c/cgenie-cpx",
+  "c/cgenie-drs",
+  "c/cgenie-hki",
+  "c/cgenie-lang",
+  "c/cgenie-scx",
 ]

c/cgenie-cpx/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "cgenie-cpx"
+version = "0.1.0"
+authors = ["Renée Kooi <[email protected]>"]
+edition = "2018"
+license = "GPL-3.0"
+description = "C-compatible APIs for the genie-cpx library"
+homepage = "https://github.com/SiegeEngineers/genie-rs"
+repository = "https://github.com/SiegeEngineers/genie-rs"
+
+[lib]
+crate-type = ["cdylib", "staticlib", "rlib"]
+
+[dependencies]
+ffi-support = "^0.3.5"
+genie-cpx = { path = "../../crates/genie-cpx" }

c/cgenie-cpx/src/lib.rs

@@ -0,0 +1,31 @@
+use ffi_support::FfiStr;
+use genie_cpx::Campaign;
+use std::{fs::File, io::{Read, Seek, Cursor}, ptr};
+
+/// Open and read a campaign file.
+#[no_mangle]
+pub extern "C" fn cgcpx_load(path: FfiStr) -> *mut Campaign {
+    if let Some(path) = path.as_opt_str() {
+        if let Ok(mut file) = File::open(path) {
+            Campaign::from(&mut file)
+                .map(Box::new)
+                .map(Box::into_raw)
+                .unwrap_or(ptr::null_mut())
+        } else {
+            ptr::null_mut()
+        }
+    } else {
+        ptr::null_mut()
+    }
+}
+
+/// Read a campaign file from a byte array.
+#[no_mangle]
+pub extern "C" fn cgcpx_load_mem(input: *const u8, size: usize) -> *mut Campaign {
+    let slice = unsafe { std::slice::from_raw_parts(input, size) };
+    let mut cursor = Cursor::new(slice);
+    Campaign::from(&mut cursor)
+        .map(Box::new)
+        .map(Box::into_raw)
+        .unwrap_or(ptr::null_mut())
+}

c/cgenie-drs/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "cgenie-drs"
+version = "0.1.0"
+authors = ["Renée Kooi <[email protected]>"]
+edition = "2018"
+license = "GPL-3.0"
+description = "C-compatible APIs for the genie-drs library"
+homepage = "https://github.com/SiegeEngineers/genie-rs"
+repository = "https://github.com/SiegeEngineers/genie-rs"
+
+[lib]
+crate-type = ["cdylib", "staticlib", "rlib"]
+
+[dependencies]
+ffi-support = "^0.3.5"
+genie-drs = { path = "../../crates/genie-drs" }

c/cgenie-drs/src/lib.rs

@@ -0,0 +1,31 @@
+use ffi_support::FfiStr;
+use genie_drs::{DRSReader, DRSWriter};
+use std::{fs::File, ptr};
+
+type DRSR = (File, DRSReader);
+
+/// Open a drs archive.
+#[no_mangle]
+pub extern "C" fn cgdrs_load(path: FfiStr) -> *mut DRSR {
+    if let Some(path) = path.as_opt_str() {
+        if let Ok(mut file) = File::open(path) {
+            DRSReader::new(&mut file)
+                .map(move |drs| (file, drs))
+                .map(Box::new)
+                .map(Box::into_raw)
+                .unwrap_or(ptr::null_mut())
+        } else {
+            ptr::null_mut()
+        }
+    } else {
+        ptr::null_mut()
+    }
+}
+
+/// Close a drs archive.
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "C" fn cgdrs_free(drs: *mut DRSR) {
+    let pair = unsafe { Box::from_raw(drs) };
+    drop(pair);
+}

c/cgenie-hki/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "cgenie-hki"
+version = "0.1.0"
+authors = ["Renée Kooi <[email protected]>"]
+edition = "2018"
+license = "GPL-3.0"
+description = "C-compatible APIs for the genie-hki library"
+homepage = "https://github.com/SiegeEngineers/genie-rs"
+repository = "https://github.com/SiegeEngineers/genie-rs"
+
+[lib]
+crate-type = ["cdylib", "staticlib", "rlib"]
+
+[dependencies]
+ffi-support = "^0.3.5"
+genie-hki = { path = "../../crates/genie-hki" }

c/cgenie-hki/src/lib.rs

@@ -0,0 +1,51 @@
+use ffi_support::FfiStr;
+use genie_hki::HotkeyInfo;
+use std::{fs::File, io::Cursor, ptr};
+
+/// Open and read a hotkey file.
+#[no_mangle]
+pub extern "C" fn cghki_load(path: FfiStr) -> *mut HotkeyInfo {
+    if let Some(path) = path.as_opt_str() {
+        if let Ok(mut file) = File::open(path) {
+            HotkeyInfo::from(&mut file)
+                .map(Box::new)
+                .map(Box::into_raw)
+                .unwrap_or(ptr::null_mut())
+        } else {
+            ptr::null_mut()
+        }
+    } else {
+        ptr::null_mut()
+    }
+}
+
+/// Read a hotkey file from a byte array.
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "C" fn cghki_load_mem(input: *const u8, size: usize) -> *mut HotkeyInfo {
+    let slice = unsafe { std::slice::from_raw_parts(input, size) };
+    let mut cursor = Cursor::new(slice);
+    HotkeyInfo::from(&mut cursor)
+        .map(Box::new)
+        .map(Box::into_raw)
+        .unwrap_or(ptr::null_mut())
+}
+
+/// Save the hotkeys to a file.
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "C" fn cghki_save(hki: *mut HotkeyInfo, path: FfiStr) -> u32 {
+    if let Some(path) = path.as_opt_str() {
+        if let Ok(mut file) = File::create(path) {
+            if unsafe { &*hki }.write_to(&mut file).is_ok() {
+                0
+            } else {
+                3
+            }
+        } else {
+            2
+        }
+    } else {
+        1
+    }
+}

c/cgenie-lang/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "cgenie-lang"
+version = "0.1.0"
+authors = ["Renée Kooi <[email protected]>"]
+edition = "2018"
+license = "GPL-3.0"
+description = "C-compatible API for the genie-lang library"
+homepage = "https://github.com/SiegeEngineers/genie-rs"
+repository = "https://github.com/SiegeEngineers/genie-rs"
+
+[lib]
+crate-type = ["cdylib", "staticlib", "rlib"]
+
+[dependencies]
+ffi-support = "^0.3.5"
+genie-lang = { path = "../../crates/genie-lang" }

c/cgenie-lang/src/lib.rs

@@ -0,0 +1,113 @@
+use ffi_support::FfiStr;
+use genie_lang::{LangFile, LangFileType, StringKey};
+use std::{fs::File, ptr};
+
+fn try_read_file(t: LangFileType, path: FfiStr) -> *mut LangFile {
+    if let Some(path) = path.as_opt_str() {
+        if let Ok(file) = File::open(path) {
+            t.read_from(file)
+                .map(Box::new)
+                .map(Box::into_raw)
+                .unwrap_or(ptr::null_mut())
+        } else {
+            ptr::null_mut()
+        }
+    } else {
+        ptr::null_mut()
+    }
+}
+
+fn try_create_file(path: FfiStr) -> Option<File> {
+    path.as_opt_str().and_then(|path| File::create(path).ok())
+}
+
+/// Load a .ini language file.
+#[no_mangle]
+pub extern "C" fn cglang_load_ini(path: FfiStr) -> *mut LangFile {
+    try_read_file(LangFileType::Ini, path)
+}
+
+/// Load an HD Edition key-value.txt language file.
+#[no_mangle]
+pub extern "C" fn cglang_load_keyval(path: FfiStr) -> *mut LangFile {
+    try_read_file(LangFileType::KeyValue, path)
+}
+
+/// Load a classic DLL language file.
+#[no_mangle]
+pub extern "C" fn cglang_load_dll(path: FfiStr) -> *mut LangFile {
+    try_read_file(LangFileType::Dll, path)
+}
+
+/// Get an integer-indexed string.
+///
+/// The returned string is owned by the `cgenie_lang` pointer.
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "C" fn cglang_get(file: *const LangFile, index: u32) -> *const u8 {
+    if file.is_null() {
+        ptr::null()
+    } else {
+        unsafe { &*file }
+            .get(&StringKey::from(index))
+            .map(|s| s.as_ptr())
+            .unwrap_or(ptr::null())
+    }
+}
+
+/// Get a name-indexed string.
+///
+/// The returned string is owned by the `cgenie_lang` pointer.
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "C" fn cglang_get_named(file: *const LangFile, index: FfiStr) -> *const u8 {
+    match (file.is_null(), index.as_opt_str()) {
+        (true, Some(index)) => {
+            unsafe { &*file }
+                .get(&StringKey::from(index))
+                .map(|s| s.as_ptr())
+                .unwrap_or(ptr::null())
+        }
+        _ => ptr::null(),
+    }
+}
+
+/// Save a .ini language file.
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "C" fn cglang_save_ini(file: *mut LangFile, path: FfiStr) -> u32 {
+    let mut output = match try_create_file(path) {
+        Some(output) => output,
+        _ => return 1,
+    };
+    if unsafe { &*file }.write_to_ini(&mut output).is_ok() {
+        0
+    } else {
+        2
+    }
+}
+
+/// Save an HD Edition key-value.txt language file.
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "C" fn cglang_save_keyval(file: *mut LangFile, path: FfiStr) -> u32 {
+    let mut output = match try_create_file(path) {
+        Some(output) => output,
+        _ => return 1,
+    };
+    if unsafe { &*file }.write_to_keyval(&mut output).is_ok() {
+        0
+    } else {
+        2
+    }
+}
+
+/// Free all language file resources.
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "C" fn cglang_free(file: *mut LangFile) {
+    if !file.is_null() {
+        let file = unsafe { Box::from_raw(file) };
+        drop(file);
+    }
+}

c/cgenie-scx/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "cgenie-scx"
+version = "0.1.0"
+authors = ["Renée Kooi <[email protected]>"]
+edition = "2018"
+license = "GPL-3.0"
+description = "C-compatible APIs for the genie-scx library"
+homepage = "https://github.com/SiegeEngineers/genie-rs"
+repository = "https://github.com/SiegeEngineers/genie-rs"
+
+[lib]
+crate-type = ["cdylib", "staticlib", "rlib"]
+
+[dependencies]
+ffi-support = "^0.3.5"
+genie-scx = { path = "../../crates/genie-scx" }