Merge branch 'riiz'

Author: natecraddock

.clang-format

@@ -1,6 +1,2 @@
-*build*/
-.cache/
-CMakeFiles
-.vscode
-CMakeCache.txt
-*.o
+zig-cache/
+zig-out/

.gitignore

@@ -0,0 +1,44 @@
+const std = @import("std");
+
+pub fn build(b: *std.build.Builder) void {
+    const target = b.standardTargetOptions(.{});
+    const mode = b.standardReleaseOptions();
+
+    const exe = b.addExecutable("reckless-drivin", "src/main.zig");
+
+    exe.linkLibC();
+    exe.addIncludeDir("src/c/");
+    exe.addCSourceFile("src/c/lzrw.c", &.{
+        // The default is to enable undefined behavior detection in C code. I have
+        // verified that the packs are all decompressed fine, so there is no need
+        // to sanitize. See https://github.com/ziglang/zig/wiki/FAQ#why-do-i-get-illegal-instruction-when-using-with-zig-cc-to-build-c-code
+        // for more details.
+        "-fno-sanitize=undefined",
+    });
+
+    exe.setTarget(target);
+    exe.setBuildMode(mode);
+    exe.install();
+
+    const run_cmd = exe.run();
+    run_cmd.step.dependOn(b.getInstallStep());
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    const run_step = b.step("run", "Run Reckless Drivin'");
+    run_step.dependOn(&run_cmd.step);
+
+    const exe_tests = b.addTest("src/main.zig");
+    exe_tests.linkLibC();
+    exe_tests.addIncludeDir("src/c/");
+    exe_tests.addCSourceFile("src/c/lzrw.c", &.{
+        "-fno-sanitize=undefined",
+    });
+
+    exe_tests.setTarget(target);
+    exe_tests.setBuildMode(mode);
+
+    const test_step = b.step("test", "Run tests");
+    test_step.dependOn(&exe_tests.step);
+}

README.md

@@ -102,19 +102,26 @@ static struct compress_identity identity = {
     "Public Domain"         /* Vendor of algorithm.             */
 };
 
-static void lzrw3a_compress_compress(uint8_t *, uint8_t *, uint32_t, uint8_t *,
+static void lzrw3a_compress_compress(uint8_t *, const uint8_t *, uint32_t, uint8_t *,
                                      uint64_t *);
-static void lzrw3a_compress_decompress(uint8_t *, uint8_t *, uint32_t,
+static void lzrw3a_compress_decompress(uint8_t *, const uint8_t *, uint32_t,
                                        uint8_t *, uint64_t *);
 
+
+/******************************************************************************/
+
+struct compress_identity lzrw_identity() {
+  return identity;
+}
+
 /******************************************************************************/
 
 /* This function is the only function exported by this module.                */
 /* Depending on its first parameter, the function can be requested to         */
 /* compress a block of memory, decompress a block of memory, or to identify   */
 /* itself. For more information, see the specification file "compress.h".     */
 
-void lzrw3a_compress(uint16_t action, uint8_t *wrk_mem, uint8_t *src_adr,
+void lzrw3a_compress(uint16_t action, uint8_t *wrk_mem, const uint8_t *src_adr,
                      uint32_t src_len, uint8_t *dst_adr, uint64_t *p_dst_len) {
   switch (action) {
     case COMPRESS_ACTION_COMPRESS:
@@ -386,7 +393,7 @@ void lzrw3a_compress(uint16_t action, uint8_t *wrk_mem, uint8_t *src_adr,
 
 /******************************************************************************/
 
-static void lzrw3a_compress_compress(uint8_t *p_wrk_mem, uint8_t *p_src_first,
+static void lzrw3a_compress_compress(uint8_t *p_wrk_mem, const uint8_t *p_src_first,
                                      uint32_t src_len, uint8_t *p_dst_first,
                                      uint64_t *p_dst_len)
 /* Input  : Hand over the required amount of working memory in p_wrk_mem.     */
@@ -680,7 +687,7 @@ static void lzrw3a_compress_compress(uint8_t *p_wrk_mem, uint8_t *p_src_first,
 
 /******************************************************************************/
 
-static void lzrw3a_compress_decompress(uint8_t *p_wrk_mem, uint8_t *p_src_first,
+static void lzrw3a_compress_decompress(uint8_t *p_wrk_mem, const uint8_t *p_src_first,
                                        uint32_t src_len, uint8_t *p_dst_first,
                                        uint64_t *p_dst_len)
 /* Input  : Hand over the required amount of working memory in p_wrk_mem.     */
@@ -738,11 +745,10 @@ static void lzrw3a_compress_decompress(uint8_t *p_wrk_mem, uint8_t *p_src_first,
 
   /* Check the leading copy flag to see if the compressor chose to use a copy */
   /* operation instead of a compression operation. If a copy operation was */
-  /* used, then all we need to do is copy the data over, set the output length
-   */
+  /* used, then all we need to do is copy the data over, set the output length */
   /* and return. */
   if (*p_src_first == FLAG_COPY) {
-    memcpy(p_src_first, p_src_first + FLAG_BYTES, src_len - FLAG_BYTES);
+    memcpy(p_dst_first, p_src_first + FLAG_BYTES, src_len - FLAG_BYTES);
     *p_dst_len = src_len - FLAG_BYTES;
     return;
   }
@@ -873,12 +879,9 @@ static void lzrw3a_compress_decompress(uint8_t *p_wrk_mem, uint8_t *p_src_first,
 /*                              End of LZRW3-A.C                              */
 /******************************************************************************/
 
-#include <stdio.h>
-
-#include "resource.h"
-
+/*
 void LZRWDecodeHandle(Handle *handle) {
-  /* Need the handle size to properly decompress. */
+  // Need the handle size to properly decompress.
   uint32_t handle_len = GetHandleSize(*handle);
 
   unsigned char *working_mem = malloc(sizeof *working_mem * identity.memory);
@@ -897,13 +900,14 @@ void LZRWDecodeHandle(Handle *handle) {
                   handle_len - 4, dst_mem, &dst_len);
   free(working_mem);
 
-  /* Reallocate the dst block to be exactly the right size. */
+  // Reallocate the dst block to be exactly the right size.
   dst_mem = realloc(dst_mem, dst_len);
   if (!dst_mem) {
     return;
   }
 
   **handle = dst_mem;
-  /* Store the new handle length. */
+  // Store the new handle length.
   SetHandleSize(*handle, dst_len);
 }
+*/

build.zig

@@ -122,6 +122,7 @@
 #ifndef LZRW_H
 #define LZRW_H
 
+#include <stdbool.h>
 #include <stdint.h>
 #include <string.h>
 
@@ -155,11 +156,14 @@ struct compress_identity {
   char *vendor;      /* Where the algorithm can be obtained.        */
 };
 
+/* returns id information for the compression algorithm */
+struct compress_identity lzrw_identity();
+
 void lzrw3a_compress(/* Single function interface to compression algorithm. */
                      uint16_t action,    /* Action to be performed.       */
                      uint8_t *wrk_mem,   /* Working memory temporarily given to
                                           routine to use. */
-                     uint8_t *src_adr,   /* Address of input  data.     */
+                     const uint8_t *src_adr,   /* Address of input  data.     */
                      uint32_t src_len,   /* Length  of input  data.   */
                      uint8_t *dst_adr,   /* Address of output data.     */
                      uint64_t *p_dst_len /* Pointer to a longword where routine
@@ -173,14 +177,4 @@ void lzrw3a_compress(/* Single function interface to compression algorithm. */
 /*                             End of COMPRESS.H                              */
 /******************************************************************************/
 
-#include "defines.h"
-
-/**
- * Decompress the bytes referenced by a handle.
- *
- * On success, the given Resource Handle is converted to a Memory Handle and
- * will need to be freed with DisposeHandle.
- */
-void LZRWDecodeHandle(Handle *handle);
-
 #endif /* LZRW_H */