compile cmph from source

src/main.zig

@@ -1,35 +1,15 @@
 const std = @import("std");
-const ArrayList = std.ArrayList;
 
 const c = @cImport({
     @cDefine("DEBUG", "1");
     @cInclude("stdio.h");
+    @cInclude("string.h");
     @cInclude("cmph.h");
 });
 
 const tempMph = "temp.mph";
 
-pub fn main() !void {
-
-    //    var hash: ?*c.cmph_t = c.cmph_new(config);
-    //    c.cmph_config_destroy(config);
-    //    _ = c.cmph_dump(hash, mphf_fd);
-    //    c.cmph_destroy(hash);
-    //    _ = c.fclose(mphf_fd);
-    //    mphf_fd = c.fopen("temp.mph", "r");
-    //    hash = c.cmph_load(mphf_fd);
-    //    while (i < nkeys) {
-    //        var key: [*c]const u8 = vector[i];
-    //        var id: c_uint = c.cmph_search(hash, key, @bitCast(c.cmph_uint32, @truncate(c_uint, 10)));
-    //        try stdout.print("key:{s} -- hash:{u}\n", key, id);
-    //        i +%= 1;
-    //    }
-    //    c.cmph_destroy(hash);
-    //    c.cmph_io_vector_adapter_destroy(source);
-    //    _ = c.fclose(mphf_fd);
-    //    return 0;
-    //}
-}
+pub fn main() !void {}
 
 test "simple cmph usage" {
     var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
@@ -38,28 +18,26 @@ test "simple cmph usage" {
     const stderr = std.io.getStdErr().writer();
 
     _ = stdout;
-    var vector = ArrayList([*:0]const u8).init(arena);
-    try vector.append("aaaaaaaaaa");
-    try vector.append("bbbbbbbbbb");
-    try vector.append("cccccccccc");
-    try vector.append("dddddddddd");
-    try vector.append("eeeeeeeeee");
-    try vector.append("ffffffffff");
-    try vector.append("gggggggggg");
-    try vector.append("hhhhhhhhhh");
-    try vector.append("iiiiiiiiii");
-    try vector.append("jjjjjjjjjj");
+    var vector = std.ArrayList([*:0]const u8).init(arena);
+    try vector.appendSlice(&.{
+        "aaaaaaaaaa",
+        "bbbbbbbbbb",
+        "cccccccccc",
+        "dddddddddd",
+        "eeeeeeeeee",
+        "ffffffffff",
+        "gggggggggg",
+        "hhhhhhhhhh",
+        "iiiiiiiiii",
+        "jjjjjjjjjj",
+    });
+    var vector2 = try vector.clone();
+    var nkeys = @truncate(c_uint, vector.items.len);
 
-    var mphf_fh = try std.fs.cwd().createFile(tempMph, .{});
-    defer {
-        std.fs.cwd().deleteFile(tempMph) catch |err| {
-            stderr.print("error removing file: {s}\n", .{@errorName(err)}) catch {};
-        };
-    }
-    var mphf_fd = c.fdopen(mphf_fh.handle, "w");
-    var vector_len = @truncate(c_uint, vector.items.len);
+    var mphf_fd = c.fopen(tempMph, "w");
     var cvector = @ptrCast([*c][*c]u8, vector.toOwnedSlice().ptr);
-    var source = c.cmph_io_vector_adapter(cvector, vector_len);
+    var source = c.cmph_io_vector_adapter(cvector, nkeys);
+    defer c.cmph_io_vector_adapter_destroy(source);
     var config: *c.cmph_config_t = c.cmph_config_new(source) orelse return error.OutOfMemory;
     c.cmph_config_set_algo(config, c.CMPH_BRZ);
     c.cmph_config_set_mphf_fd(config, mphf_fd);
@@ -67,11 +45,10 @@ test "simple cmph usage" {
     c.cmph_config_destroy(config);
     _ = c.cmph_dump(hash, mphf_fd);
     c.cmph_destroy(hash);
-    mphf_fh.close();
+    try closeCFile(mphf_fd);
 
-    mphf_fh = try std.fs.cwd().openFile(tempMph, .{ .mode = .read_only });
-    mphf_fd = c.fdopen(mphf_fh.handle, "r");
-    defer mphf_fh.close();
+    mphf_fd = c.fopen(tempMph, "r");
+    defer _ = c.fclose(mphf_fd);
 
     var got_hash: ?*c.cmph_t = c.cmph_load(mphf_fd);
     if (got_hash) |real_hash| {
@@ -79,6 +56,20 @@ test "simple cmph usage" {
     } else {
         try stderr.print("failed to unwrap hash\n", .{});
     }
+    defer c.cmph_destroy(hash);
+
+    try stderr.print("\n", .{});
+    for (vector2.items) |key| {
+        var id = c.cmph_search(hash, key, @truncate(c_uint, c.strlen(key)));
+        try stderr.print("key: {s}, id: {d}\n", .{ key, id });
+    }
+}
+
+fn closeCFile(f: *c.FILE) !void {
+    var close_code = c.fclose(f);
+    if (close_code != 0) {
+        return std.os.unexpectedErrno(std.os.errno(close_code));
+    }
 }
 
 const expectEqual = std.testing.expectEqual;
@@ -87,7 +78,7 @@ test "char**" {
     var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     const arena = arena_instance.allocator();
 
-    var arrl = ArrayList([*:0]const u8).init(arena);
+    var arrl = std.ArrayList([*:0]const u8).init(arena);
     try arrl.append("foo");
     try arrl.append("bar");