From 30b15ec78390c31b4456e9b600ccabe7481cc5ea Mon Sep 17 00:00:00 2001 From: Vincent Rischmann Date: Mon, 26 Dec 2022 11:00:59 +0100 Subject: fix for latest zig --- helpers.zig | 2 +- sqlite.zig | 30 +++++++++++++------------- vtab.zig | 70 ++++++++++++++++++++++++++++++------------------------------- 3 files changed, 51 insertions(+), 51 deletions(-) diff --git a/helpers.zig b/helpers.zig index aa04f54..7bcbabe 100644 --- a/helpers.zig +++ b/helpers.zig @@ -84,5 +84,5 @@ fn sliceFromValue(sqlite_value: *c.sqlite3_value) []const u8 { const value = c.sqlite3_value_text(sqlite_value); debug.assert(value != null); // TODO(vincent): how do we handle this properly ? - return value.?[0..size]; + return value[0..size]; } diff --git a/sqlite.zig b/sqlite.zig index d39f44b..db6ce0d 100644 --- a/sqlite.zig +++ b/sqlite.zig @@ -640,19 +640,19 @@ pub const Db = struct { .Fn => |fn_info| fn_info, else => @compileError("cannot use func, expecting a function"), }; - if (finalize_fn_info.args.len != 1) @compileError("finalize function must take exactly one argument"); + if (finalize_fn_info.params.len != 1) @compileError("finalize function must take exactly one argument"); if (finalize_fn_info.is_generic) @compileError("finalize function can't be generic"); if (finalize_fn_info.is_var_args) @compileError("finalize function can't be variadic"); - if (step_fn_info.args[0].arg_type.? != finalize_fn_info.args[0].arg_type.?) { + if (step_fn_info.params[0].type.? != finalize_fn_info.params[0].type.?) { @compileError("both step and finalize functions must have the same first argument and it must be a FunctionContext"); } - if (step_fn_info.args[0].arg_type.? != FunctionContext) { + if (step_fn_info.params[0].type.? != FunctionContext) { @compileError("both step and finalize functions must have a first argument of type FunctionContext"); } // subtract the context argument - const real_args_len = step_fn_info.args.len - 1; + const real_args_len = step_fn_info.params.len - 1; // @@ -669,7 +669,7 @@ pub const Db = struct { fn xStep(ctx: ?*c.sqlite3_context, argc: c_int, argv: [*c]?*c.sqlite3_value) callconv(.C) void { debug.assert(argc == real_args_len); - const sqlite_args = argv.?[0..real_args_len]; + const sqlite_args = argv[0..real_args_len]; var args: std.meta.ArgsTuple(@TypeOf(step_func)) = undefined; @@ -679,14 +679,14 @@ pub const Db = struct { comptime var i: usize = 0; inline while (i < real_args_len) : (i += 1) { // Remember the firt argument is always the function context - const arg = step_fn_info.args[i + 1]; + const arg = step_fn_info.params[i + 1]; const arg_ptr = &args[i + 1]; - const ArgType = arg.arg_type.?; + const ArgType = arg.type.?; helpers.setTypeFromValue(ArgType, arg_ptr, sqlite_args[i].?); } - @call(.{}, step_func, args); + @call(.auto, step_func, args); } }.xStep, struct { @@ -696,7 +696,7 @@ pub const Db = struct { // Pass the function context args[0] = FunctionContext{ .ctx = ctx }; - const result = @call(.{}, finalize_func, args); + const result = @call(.auto, finalize_func, args); helpers.setResult(ctx, result); } @@ -738,22 +738,22 @@ pub const Db = struct { const result = c.sqlite3_create_function_v2( self.db, func_name, - fn_info.args.len, + fn_info.params.len, flags, null, struct { fn xFunc(ctx: ?*c.sqlite3_context, argc: c_int, argv: [*c]?*c.sqlite3_value) callconv(.C) void { - debug.assert(argc == fn_info.args.len); + debug.assert(argc == fn_info.params.len); - const sqlite_args = argv.?[0..fn_info.args.len]; + const sqlite_args = argv[0..fn_info.params.len]; var fn_args: ArgTuple = undefined; - inline for (fn_info.args) |arg, i| { - const ArgType = arg.arg_type.?; + inline for (fn_info.params) |arg, i| { + const ArgType = arg.type.?; helpers.setTypeFromValue(ArgType, &fn_args[i], sqlite_args[i].?); } - const result = @call(.{}, func, fn_args); + const result = @call(.auto, func, fn_args); helpers.setResult(ctx, result); } diff --git a/vtab.zig b/vtab.zig index 2c3e329..aef1b40 100644 --- a/vtab.zig +++ b/vtab.zig @@ -315,9 +315,9 @@ fn validateCursorType(comptime Table: type) void { const info = @typeInfo(@TypeOf(Cursor.init)).Fn; - if (info.args.len != 2) @compileError(error_message); - if (info.args[0].arg_type.? != mem.Allocator) @compileError(error_message); - if (info.args[1].arg_type.? != *Table) @compileError(error_message); + if (info.params.len != 2) @compileError(error_message); + if (info.params[0].type.? != mem.Allocator) @compileError(error_message); + if (info.params[1].type.? != *Table) @compileError(error_message); if (info.return_type.? != Cursor.InitError!*Cursor) @compileError(error_message); } @@ -333,8 +333,8 @@ fn validateCursorType(comptime Table: type) void { const info = @typeInfo(@TypeOf(Cursor.deinit)).Fn; - if (info.args.len != 1) @compileError(error_message); - if (info.args[0].arg_type.? != *Cursor) @compileError(error_message); + if (info.params.len != 1) @compileError(error_message); + if (info.params[0].type.? != *Cursor) @compileError(error_message); if (info.return_type.? != void) @compileError(error_message); } @@ -354,9 +354,9 @@ fn validateCursorType(comptime Table: type) void { const info = @typeInfo(@TypeOf(Cursor.next)).Fn; - if (info.args.len != 2) @compileError(error_message); - if (info.args[0].arg_type.? != *Cursor) @compileError(error_message); - if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message); + if (info.params.len != 2) @compileError(error_message); + if (info.params[0].type.? != *Cursor) @compileError(error_message); + if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message); if (info.return_type.? != Cursor.NextError!void) @compileError(error_message); } @@ -376,9 +376,9 @@ fn validateCursorType(comptime Table: type) void { const info = @typeInfo(@TypeOf(Cursor.hasNext)).Fn; - if (info.args.len != 2) @compileError(error_message); - if (info.args[0].arg_type.? != *Cursor) @compileError(error_message); - if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message); + if (info.params.len != 2) @compileError(error_message); + if (info.params[0].type.? != *Cursor) @compileError(error_message); + if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message); if (info.return_type.? != Cursor.HasNextError!bool) @compileError(error_message); } @@ -398,11 +398,11 @@ fn validateCursorType(comptime Table: type) void { const info = @typeInfo(@TypeOf(Cursor.filter)).Fn; - if (info.args.len != 4) @compileError(error_message); - if (info.args[0].arg_type.? != *Cursor) @compileError(error_message); - if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message); - if (info.args[2].arg_type.? != IndexIdentifier) @compileError(error_message); - if (info.args[3].arg_type.? != []FilterArg) @compileError(error_message); + if (info.params.len != 4) @compileError(error_message); + if (info.params[0].type.? != *Cursor) @compileError(error_message); + if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message); + if (info.params[2].type.? != IndexIdentifier) @compileError(error_message); + if (info.params[3].type.? != []FilterArg) @compileError(error_message); if (info.return_type.? != Cursor.FilterError!void) @compileError(error_message); } @@ -425,10 +425,10 @@ fn validateCursorType(comptime Table: type) void { const info = @typeInfo(@TypeOf(Cursor.column)).Fn; - if (info.args.len != 3) @compileError(error_message); - if (info.args[0].arg_type.? != *Cursor) @compileError(error_message); - if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message); - if (info.args[2].arg_type.? != i32) @compileError(error_message); + if (info.params.len != 3) @compileError(error_message); + if (info.params[0].type.? != *Cursor) @compileError(error_message); + if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message); + if (info.params[2].type.? != i32) @compileError(error_message); if (info.return_type.? != Cursor.ColumnError!Cursor.Column) @compileError(error_message); } @@ -448,9 +448,9 @@ fn validateCursorType(comptime Table: type) void { const info = @typeInfo(@TypeOf(Cursor.rowId)).Fn; - if (info.args.len != 2) @compileError(error_message); - if (info.args[0].arg_type.? != *Cursor) @compileError(error_message); - if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message); + if (info.params.len != 2) @compileError(error_message); + if (info.params[0].type.? != *Cursor) @compileError(error_message); + if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message); if (info.return_type.? != Cursor.RowIDError!i64) @compileError(error_message); } } @@ -473,11 +473,11 @@ fn validateTableType(comptime Table: type) void { const info = @typeInfo(@TypeOf(Table.init)).Fn; - if (info.args.len != 3) @compileError(error_message); - if (info.args[0].arg_type.? != mem.Allocator) @compileError(error_message); - if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message); - // TODO(vincent): maybe allow a signature without the args since a table can do withoout them - if (info.args[2].arg_type.? != []const ModuleArgument) @compileError(error_message); + if (info.params.len != 3) @compileError(error_message); + if (info.params[0].type.? != mem.Allocator) @compileError(error_message); + if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message); + // TODO(vincent): maybe allow a signature without the params since a table can do withoout them + if (info.params[2].type.? != []const ModuleArgument) @compileError(error_message); if (info.return_type.? != Table.InitError!*Table) @compileError(error_message); } @@ -493,9 +493,9 @@ fn validateTableType(comptime Table: type) void { const info = @typeInfo(@TypeOf(Table.deinit)).Fn; - if (info.args.len != 2) @compileError(error_message); - if (info.args[0].arg_type.? != *Table) @compileError(error_message); - if (info.args[1].arg_type.? != mem.Allocator) @compileError(error_message); + if (info.params.len != 2) @compileError(error_message); + if (info.params[0].type.? != *Table) @compileError(error_message); + if (info.params[1].type.? != mem.Allocator) @compileError(error_message); if (info.return_type.? != void) @compileError(error_message); } @@ -515,10 +515,10 @@ fn validateTableType(comptime Table: type) void { const info = @typeInfo(@TypeOf(Table.buildBestIndex)).Fn; - if (info.args.len != 3) @compileError(error_message); - if (info.args[0].arg_type.? != *Table) @compileError(error_message); - if (info.args[1].arg_type.? != *VTabDiagnostics) @compileError(error_message); - if (info.args[2].arg_type.? != *BestIndexBuilder) @compileError(error_message); + if (info.params.len != 3) @compileError(error_message); + if (info.params[0].type.? != *Table) @compileError(error_message); + if (info.params[1].type.? != *VTabDiagnostics) @compileError(error_message); + if (info.params[2].type.? != *BestIndexBuilder) @compileError(error_message); if (info.return_type.? != Table.BuildBestIndexError!void) @compileError(error_message); } -- cgit v1.2.3 From c61f3fb2a36105159f4c6e4a1cdffba7c0611ed1 Mon Sep 17 00:00:00 2001 From: Vincent Rischmann Date: Sun, 5 Feb 2023 13:06:56 +0100 Subject: fix build.zig file --- build.zig | 98 ++++++++++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 65 insertions(+), 33 deletions(-) diff --git a/build.zig b/build.zig index a217191..fe9a77e 100644 --- a/build.zig +++ b/build.zig @@ -182,16 +182,19 @@ pub fn build(b: *std.build.Builder) !void { const use_bundled = b.option(bool, "use_bundled", "Use the bundled sqlite3 source instead of linking the system library (default false)"); const target = b.standardTargetOptions(.{}); - const mode = b.standardReleaseOptions(); + const optimize = b.standardOptimizeOption(.{}); // Tool to preprocess the sqlite header files. // // Due to limitations of translate-c the standard header files can't be used for building loadable extensions // so we have this tool which creates usable header files. - const preprocess_files_tool = b.addExecutable("preprocess-files", "tools/preprocess_files.zig"); - preprocess_files_tool.setBuildMode(mode); - preprocess_files_tool.setTarget(getTarget(target, true)); + const preprocess_files_tool = b.addExecutable(.{ + .name = "preprocess-files", + .root_source_file = .{ .path = "tools/preprocess_files.zig" }, + .target = getTarget(target, true), + .optimize = optimize, + }); // Add a top-level step to run the preprocess-files tool const preprocess_files_run = b.step("preprocess-files", "Run the preprocess-files tool"); @@ -220,32 +223,38 @@ pub fn build(b: *std.build.Builder) !void { const bundled = use_bundled orelse test_target.bundled; const cross_target = getTarget(test_target.target, bundled); - const tests = b.addTest("sqlite.zig"); + const tests = b.addTest(.{ + .target = cross_target, + .root_source_file = .{ .path = "sqlite.zig" }, + }); if (bundled) { - const lib = b.addStaticLibrary("sqlite", null); + const lib = b.addStaticLibrary(.{ + .name = "sqlite", + .target = cross_target, + .optimize = optimize, + }); lib.addCSourceFile("c/sqlite3.c", &[_][]const u8{"-std=c99"}); lib.linkLibC(); - lib.setTarget(cross_target); - lib.setBuildMode(mode); sqlite3 = lib; } - const lib = b.addStaticLibrary("zig-sqlite", "sqlite.zig"); + const lib = b.addStaticLibrary(.{ + .name = "zig-sqlite", + .root_source_file = .{ .path = "sqlite.zig" }, + .target = cross_target, + .optimize = optimize, + }); if (bundled) lib.addIncludePath("c"); linkSqlite(lib); - lib.setTarget(cross_target); - lib.setBuildMode(mode); const single_threaded_txt = if (test_target.single_threaded) "single" else "multi"; tests.setNamePrefix(b.fmt("{s}-{s}-{s} ", .{ try cross_target.zigTriple(b.allocator), - @tagName(mode), + @tagName(optimize), single_threaded_txt, })); tests.single_threaded = test_target.single_threaded; - tests.setBuildMode(mode); - tests.setTarget(cross_target); if (bundled) tests.addIncludePath("c"); linkSqlite(tests); @@ -260,22 +269,29 @@ pub fn build(b: *std.build.Builder) !void { // Fuzzing - const lib = b.addStaticLibrary("sqlite", null); + const lib = b.addStaticLibrary(.{ + .name = "sqlite", + .target = getTarget(target, true), + .optimize = optimize, + }); lib.addCSourceFile("c/sqlite3.c", &[_][]const u8{"-std=c99"}); lib.addIncludePath("c"); lib.linkLibC(); - lib.setBuildMode(mode); - lib.setTarget(getTarget(target, true)); // The library - const fuzz_lib = b.addStaticLibrary("fuzz-lib", "fuzz/main.zig"); + const fuzz_lib = b.addStaticLibrary(.{ + .name = "fuzz-lib", + .root_source_file = .{ .path = "fuzz/main.zig" }, + .target = getTarget(target, true), + .optimize = optimize, + }); fuzz_lib.addIncludePath("c"); - fuzz_lib.setBuildMode(mode); - fuzz_lib.setTarget(getTarget(target, true)); fuzz_lib.linkLibrary(lib); fuzz_lib.want_lto = true; fuzz_lib.bundle_compiler_rt = true; - fuzz_lib.addPackagePath("sqlite", "sqlite.zig"); + fuzz_lib.addAnonymousModule("sqlite", .{ + .source_file = .{ .path = "sqlite.zig" }, + }); // Setup the output name const fuzz_executable_name = "fuzz"; @@ -296,12 +312,17 @@ pub fn build(b: *std.build.Builder) !void { fuzz_compile_run.dependOn(&fuzz_install.step); // Compile a companion exe for debugging crashes - const fuzz_debug_exe = b.addExecutable("fuzz-debug", "fuzz/main.zig"); + const fuzz_debug_exe = b.addExecutable(.{ + .name = "fuzz-debug", + .root_source_file = .{ .path = "fuzz/main.zig" }, + .target = getTarget(target, true), + .optimize = optimize, + }); fuzz_debug_exe.addIncludePath("c"); - fuzz_debug_exe.setBuildMode(mode); - fuzz_debug_exe.setTarget(getTarget(target, true)); fuzz_debug_exe.linkLibrary(lib); - fuzz_debug_exe.addPackagePath("sqlite", "sqlite.zig"); + fuzz_debug_exe.addAnonymousModule("sqlite", .{ + .source_file = .{ .path = "sqlite.zig" }, + }); // Only install fuzz-debug when the fuzz step is run const install_fuzz_debug_exe = b.addInstallArtifact(fuzz_debug_exe); @@ -315,21 +336,32 @@ pub fn build(b: *std.build.Builder) !void { // // This builds an example shared library with the extension and a binary that tests it. - const zigcrypto_loadable_ext = b.addSharedLibrary("zigcrypto", "examples/zigcrypto.zig", .unversioned); + const zigcrypto_loadable_ext = b.addSharedLibrary(.{ + .name = "zigcrypto", + .root_source_file = .{ .path = "examples/zigcrypto.zig" }, + .version = null, + .target = getTarget(target, true), + .optimize = optimize, + }); zigcrypto_loadable_ext.force_pic = true; zigcrypto_loadable_ext.addIncludePath("c"); - zigcrypto_loadable_ext.setBuildMode(mode); - zigcrypto_loadable_ext.setTarget(getTarget(target, true)); - zigcrypto_loadable_ext.addPackagePath("sqlite", "sqlite.zig"); + zigcrypto_loadable_ext.addAnonymousModule("sqlite", .{ + .source_file = .{ .path = "sqlite.zig" }, + }); zigcrypto_loadable_ext.linkLibrary(lib); const install_zigcrypto_loadable_ext = b.addInstallArtifact(zigcrypto_loadable_ext); - const zigcrypto_test = b.addExecutable("zigcrypto-test", "examples/zigcrypto_test.zig"); + const zigcrypto_test = b.addExecutable(.{ + .name = "zigcrypto-test", + .root_source_file = .{ .path = "examples/zigcrypto_test.zig" }, + .target = getTarget(target, true), + .optimize = optimize, + }); zigcrypto_test.addIncludePath("c"); - zigcrypto_test.setBuildMode(mode); - zigcrypto_test.setTarget(getTarget(target, true)); - zigcrypto_test.addPackagePath("sqlite", "sqlite.zig"); + zigcrypto_test.addAnonymousModule("sqlite", .{ + .source_file = .{ .path = "sqlite.zig" }, + }); zigcrypto_test.linkLibrary(lib); const install_zigcrypto_test = b.addInstallArtifact(zigcrypto_test); -- cgit v1.2.3 From b1ad24a10f5715f7ca9df7daeaae82ea013e9bb1 Mon Sep 17 00:00:00 2001 From: Vincent Rischmann Date: Sun, 5 Feb 2023 13:19:13 +0100 Subject: fix all C prototypes --- c/loadable_extension.zig | 94 ++++++++++++++++++++++++------------------------ 1 file changed, 47 insertions(+), 47 deletions(-) diff --git a/c/loadable_extension.zig b/c/loadable_extension.zig index 95fd215..0b95806 100644 --- a/c/loadable_extension.zig +++ b/c/loadable_extension.zig @@ -25,7 +25,7 @@ pub const sqlite3_str_vappendf = @compileError("sqlite3_str_vappendf can't be im pub export fn sqlite3_aggregate_context(p: ?*c.sqlite3_context, nBytes: c_int) callconv(.C) ?*anyopaque { return sqlite3_api.*.aggregate_context.?(p, nBytes); } -pub export fn sqlite3_bind_blob(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) c_int { +pub export fn sqlite3_bind_blob(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int { return sqlite3_api.*.bind_blob.?(pStmt, i, zData, nData, xDel); } pub export fn sqlite3_bind_double(pStmt: ?*c.sqlite3_stmt, i: c_int, rValue: f64) callconv(.C) c_int { @@ -49,16 +49,16 @@ pub export fn sqlite3_bind_parameter_index(pStmt: ?*c.sqlite3_stmt, zName: [*c]c pub export fn sqlite3_bind_parameter_name(pStmt: ?*c.sqlite3_stmt, i: c_int) [*c]const u8 { return sqlite3_api.*.bind_parameter_name.?(pStmt, i); } -pub export fn sqlite3_bind_text(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: [*c]const u8, nData: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) c_int { +pub export fn sqlite3_bind_text(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: [*c]const u8, nData: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int { return sqlite3_api.*.bind_text.?(pStmt, i, zData, nData, xDel); } -pub export fn sqlite3_bind_text16(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) c_int { +pub export fn sqlite3_bind_text16(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int { return sqlite3_api.*.bind_text16.?(pStmt, i, zData, nData, xDel); } pub export fn sqlite3_bind_value(pStmt: ?*c.sqlite3_stmt, i: c_int, pValue: ?*const c.sqlite3_value) c_int { return sqlite3_api.*.bind_value.?(pStmt, i, pValue); } -pub export fn sqlite3_busy_handler(db: ?*c.sqlite3, xBusy: ?fn (?*anyopaque, c_int) callconv(.C) c_int, pArg: ?*anyopaque) c_int { +pub export fn sqlite3_busy_handler(db: ?*c.sqlite3, xBusy: ?*const fn (?*anyopaque, c_int) callconv(.C) c_int, pArg: ?*anyopaque) c_int { return sqlite3_api.*.busy_handler.?(db, xBusy, pArg); } pub export fn sqlite3_busy_timeout(db: ?*c.sqlite3, ms: c_int) c_int { @@ -70,10 +70,10 @@ pub export fn sqlite3_changes(db: ?*c.sqlite3) c_int { pub export fn sqlite3_close(db: ?*c.sqlite3) c_int { return sqlite3_api.*.close.?(db); } -pub export fn sqlite3_collation_needed(db: ?*c.sqlite3, pCollNeededArg: ?*anyopaque, xCollNeeded: ?fn (?*anyopaque, ?*c.sqlite3, c_int, [*c]const u8) callconv(.C) void) c_int { +pub export fn sqlite3_collation_needed(db: ?*c.sqlite3, pCollNeededArg: ?*anyopaque, xCollNeeded: ?*const fn (?*anyopaque, ?*c.sqlite3, c_int, [*c]const u8) callconv(.C) void) c_int { return sqlite3_api.*.collation_needed.?(db, pCollNeededArg, xCollNeeded); } -pub export fn sqlite3_collation_needed16(db: ?*c.sqlite3, pCollNeededArg: ?*anyopaque, xCollNeeded16: ?fn (?*anyopaque, ?*c.sqlite3, c_int, ?*const anyopaque) callconv(.C) void) c_int { +pub export fn sqlite3_collation_needed16(db: ?*c.sqlite3, pCollNeededArg: ?*anyopaque, xCollNeeded16: ?*const fn (?*anyopaque, ?*c.sqlite3, c_int, ?*const anyopaque) callconv(.C) void) c_int { return sqlite3_api.*.collation_needed16.?(db, pCollNeededArg, xCollNeeded16); } pub export fn sqlite3_column_blob(pStmt: ?*c.sqlite3_stmt, iCol: c_int) ?*const anyopaque { @@ -139,7 +139,7 @@ pub export fn sqlite3_column_type(pStmt: ?*c.sqlite3_stmt, iCol: c_int) c_int { pub export fn sqlite3_column_value(pStmt: ?*c.sqlite3_stmt, iCol: c_int) ?*c.sqlite3_value { return sqlite3_api.*.column_value.?(pStmt, iCol); } -pub export fn sqlite3_commit_hook(db: ?*c.sqlite3, xCallback: ?fn (?*anyopaque) callconv(.C) c_int, pArg: ?*anyopaque) ?*anyopaque { +pub export fn sqlite3_commit_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque) callconv(.C) c_int, pArg: ?*anyopaque) ?*anyopaque { return sqlite3_api.*.commit_hook.?(db, xCallback, pArg); } pub export fn sqlite3_complete(sql: [*c]const u8) c_int { @@ -148,22 +148,22 @@ pub export fn sqlite3_complete(sql: [*c]const u8) c_int { pub export fn sqlite3_complete16(sql: ?*const anyopaque) c_int { return sqlite3_api.*.complete16.?(sql); } -pub export fn sqlite3_create_collation(db: ?*c.sqlite3, zName: [*c]const u8, eTextRep: c_int, pArg: ?*anyopaque, xCompare: ?fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int) c_int { +pub export fn sqlite3_create_collation(db: ?*c.sqlite3, zName: [*c]const u8, eTextRep: c_int, pArg: ?*anyopaque, xCompare: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int) c_int { return sqlite3_api.*.create_collation.?(db, zName, eTextRep, pArg, xCompare); } -pub export fn sqlite3_create_collation16(db: ?*c.sqlite3, zName: ?*const anyopaque, eTextRep: c_int, pArg: ?*anyopaque, xCompare: ?fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int) c_int { +pub export fn sqlite3_create_collation16(db: ?*c.sqlite3, zName: ?*const anyopaque, eTextRep: c_int, pArg: ?*anyopaque, xCompare: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int) c_int { return sqlite3_api.*.create_collation16.?(db, zName, eTextRep, pArg, xCompare); } -pub export fn sqlite3_create_function(db: ?*c.sqlite3, zFunctionName: [*c]const u8, nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, xFunc: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xStep: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xFinal: ?fn (?*c.sqlite3_context) callconv(.C) void) c_int { +pub export fn sqlite3_create_function(db: ?*c.sqlite3, zFunctionName: [*c]const u8, nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, xFunc: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xFinal: ?*const fn (?*c.sqlite3_context) callconv(.C) void) c_int { return sqlite3_api.*.create_function.?(db, zFunctionName, nArg, eTextRep, pApp, xFunc, xStep, xFinal); } -pub export fn sqlite3_create_function16(db: ?*c.sqlite3, zFunctionName: ?*const anyopaque, nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, xFunc: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xStep: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xFinal: ?fn (?*c.sqlite3_context) callconv(.C) void) c_int { +pub export fn sqlite3_create_function16(db: ?*c.sqlite3, zFunctionName: ?*const anyopaque, nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, xFunc: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xFinal: ?*const fn (?*c.sqlite3_context) callconv(.C) void) c_int { return sqlite3_api.*.create_function16.?(db, zFunctionName, nArg, eTextRep, pApp, xFunc, xStep, xFinal); } pub export fn sqlite3_create_module(db: ?*c.sqlite3, zName: [*c]const u8, pModule: [*c]const c.sqlite3_module, pAux: ?*anyopaque) c_int { return sqlite3_api.*.create_module.?(db, zName, pModule, pAux); } -pub export fn sqlite3_create_module_v2(db: ?*c.sqlite3, zName: [*c]const u8, pModule: [*c]const c.sqlite3_module, pAux: ?*anyopaque, xDestroy: ?fn (?*anyopaque) callconv(.C) void) c_int { +pub export fn sqlite3_create_module_v2(db: ?*c.sqlite3, zName: [*c]const u8, pModule: [*c]const c.sqlite3_module, pAux: ?*anyopaque, xDestroy: ?*const fn (?*anyopaque) callconv(.C) void) c_int { return sqlite3_api.*.create_module_v2.?(db, zName, pModule, pAux, xDestroy); } pub export fn sqlite3_data_count(pStmt: ?*c.sqlite3_stmt) c_int { @@ -188,7 +188,7 @@ pub export fn sqlite3_errmsg(db: ?*c.sqlite3) [*c]const u8 { pub export fn sqlite3_errmsg16(db: ?*c.sqlite3) ?*const anyopaque { return sqlite3_api.*.errmsg16.?(db); } -pub export fn sqlite3_exec(db: ?*c.sqlite3, zSql: [*c]const u8, xCallback: ?fn (?*anyopaque, c_int, [*c][*c]u8, [*c][*c]u8) callconv(.C) c_int, pArg: ?*anyopaque, pzErrMsg: [*c][*c]u8) c_int { +pub export fn sqlite3_exec(db: ?*c.sqlite3, zSql: [*c]const u8, xCallback: ?*const fn (?*anyopaque, c_int, [*c][*c]u8, [*c][*c]u8) callconv(.C) c_int, pArg: ?*anyopaque, pzErrMsg: [*c][*c]u8) c_int { return sqlite3_api.*.exec.?(db, zSql, xCallback, pArg, pzErrMsg); } pub export fn sqlite3_finalize(pStmt: ?*c.sqlite3_stmt) c_int { @@ -242,10 +242,10 @@ pub export fn sqlite3_prepare_v2(db: ?*c.sqlite3, zSql: [*c]const u8, nByte: c_i pub export fn sqlite3_prepare16_v2(db: ?*c.sqlite3, zSql: ?*const anyopaque, nByte: c_int, ppStmt: [*c]?*c.sqlite3_stmt, pzTail: [*c]?*const anyopaque) c_int { return sqlite3_api.*.prepare16_v2.?(db, zSql, nByte, ppStmt, pzTail); } -pub export fn sqlite3_profile(db: ?*c.sqlite3, xProfile: ?fn (?*anyopaque, [*c]const u8, c.sqlite3_uint64) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque { +pub export fn sqlite3_profile(db: ?*c.sqlite3, xProfile: ?*const fn (?*anyopaque, [*c]const u8, c.sqlite3_uint64) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque { return sqlite3_api.*.profile.?(db, xProfile, pArg); } -pub export fn sqlite3_progress_handler(db: ?*c.sqlite3, nOps: c_int, xProgress: ?fn (?*anyopaque) callconv(.C) c_int, pArg: ?*anyopaque) void { +pub export fn sqlite3_progress_handler(db: ?*c.sqlite3, nOps: c_int, xProgress: ?*const fn (?*anyopaque) callconv(.C) c_int, pArg: ?*anyopaque) void { return sqlite3_api.*.progress_handler.?(db, nOps, xProgress, pArg); } pub export fn sqlite3_realloc(pOld: ?*anyopaque, n: c_int) ?*anyopaque { @@ -254,7 +254,7 @@ pub export fn sqlite3_realloc(pOld: ?*anyopaque, n: c_int) ?*anyopaque { pub export fn sqlite3_reset(pStmt: ?*c.sqlite3_stmt) c_int { return sqlite3_api.*.reset.?(pStmt); } -pub export fn sqlite3_result_blob(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) void { +pub export fn sqlite3_result_blob(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void { return sqlite3_api.*.result_blob.?(pCtx, z, n, xDel); } @@ -277,28 +277,28 @@ pub export fn sqlite3_result_int64(pCtx: ?*c.sqlite3_context, iVal: c.sqlite3_in pub export fn sqlite3_result_null(pCtx: ?*c.sqlite3_context) void { return sqlite3_api.*.result_null.?(pCtx); } -pub export fn sqlite3_result_text(pCtx: ?*c.sqlite3_context, z: [*c]const u8, n: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) void { +pub export fn sqlite3_result_text(pCtx: ?*c.sqlite3_context, z: [*c]const u8, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void { return sqlite3_api.*.result_text.?(pCtx, z, n, xDel); } -pub export fn sqlite3_result_text16(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) void { +pub export fn sqlite3_result_text16(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void { return sqlite3_api.*.result_text16.?(pCtx, z, n, xDel); } -pub export fn sqlite3_result_text16be(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) void { +pub export fn sqlite3_result_text16be(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void { return sqlite3_api.*.result_text16be.?(pCtx, z, n, xDel); } -pub export fn sqlite3_result_text16le(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) void { +pub export fn sqlite3_result_text16le(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void { return sqlite3_api.*.result_text16le.?(pCtx, z, n, xDel); } pub export fn sqlite3_result_value(pCtx: ?*c.sqlite3_context, pValue: ?*c.sqlite3_value) void { return sqlite3_api.*.result_value.?(pCtx, pValue); } -pub export fn sqlite3_rollback_hook(db: ?*c.sqlite3, xCallback: ?fn (?*anyopaque) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque { +pub export fn sqlite3_rollback_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque { return sqlite3_api.*.rollback_hook.?(db, xCallback, pArg); } -pub export fn sqlite3_set_authorizer(db: ?*c.sqlite3, xAuth: ?fn (?*anyopaque, c_int, [*c]const u8, [*c]const u8, [*c]const u8, [*c]const u8) callconv(.C) c_int, pArg: ?*anyopaque) c_int { +pub export fn sqlite3_set_authorizer(db: ?*c.sqlite3, xAuth: ?*const fn (?*anyopaque, c_int, [*c]const u8, [*c]const u8, [*c]const u8, [*c]const u8) callconv(.C) c_int, pArg: ?*anyopaque) c_int { return sqlite3_api.*.set_authorizer.?(db, xAuth, pArg); } -pub export fn sqlite3_set_auxdata(pCtx: ?*c.sqlite3_context, iArg: c_int, pAux: ?*anyopaque, xDelete: ?fn (?*anyopaque) callconv(.C) void) void { +pub export fn sqlite3_set_auxdata(pCtx: ?*c.sqlite3_context, iArg: c_int, pAux: ?*anyopaque, xDelete: ?*const fn (?*anyopaque) callconv(.C) void) void { return sqlite3_api.*.set_auxdata.?(pCtx, iArg, pAux, xDelete); } pub export fn sqlite3_step(pStmt: ?*c.sqlite3_stmt) c_int { @@ -313,10 +313,10 @@ pub export fn sqlite3_thread_cleanup() void { pub export fn sqlite3_total_changes(db: ?*c.sqlite3) c_int { return sqlite3_api.*.total_changes.?(db); } -pub export fn sqlite3_trace(db: ?*c.sqlite3, xTrace: ?fn (?*anyopaque, [*c]const u8) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque { +pub export fn sqlite3_trace(db: ?*c.sqlite3, xTrace: ?*const fn (?*anyopaque, [*c]const u8) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque { return sqlite3_api.*.trace.?(db, xTrace, pArg); } -pub export fn sqlite3_update_hook(db: ?*c.sqlite3, xCallback: ?fn (?*anyopaque, c_int, [*c]const u8, [*c]const u8, c.sqlite3_int64) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque { +pub export fn sqlite3_update_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque, c_int, [*c]const u8, [*c]const u8, c.sqlite3_int64) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque { return sqlite3_api.*.update_hook.?(db, xCallback, pArg); } pub export fn sqlite3_user_data(pCtx: ?*c.sqlite3_context) ?*anyopaque { @@ -382,7 +382,7 @@ pub export fn sqlite3_blob_read(pBlob: ?*c.sqlite3_blob, z: ?*anyopaque, n: c_in pub export fn sqlite3_blob_write(pBlob: ?*c.sqlite3_blob, z: ?*const anyopaque, n: c_int, iOffset: c_int) c_int { return sqlite3_api.*.blob_write.?(pBlob, z, n, iOffset); } -pub export fn sqlite3_create_collation_v2(db: ?*c.sqlite3, zName: [*c]const u8, eTextRep: c_int, pCtx: ?*anyopaque, xCompare: ?fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int, xDel: ?fn (?*anyopaque) callconv(.C) void) c_int { +pub export fn sqlite3_create_collation_v2(db: ?*c.sqlite3, zName: [*c]const u8, eTextRep: c_int, pCtx: ?*anyopaque, xCompare: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int { return sqlite3_api.*.create_collation_v2.?(db, zName, eTextRep, pCtx, xCompare, xDel); } pub export fn sqlite3_file_control(db: ?*c.sqlite3, zDbName: [*c]const u8, op: c_int, pArg: ?*anyopaque) c_int { @@ -493,10 +493,10 @@ pub export fn sqlite3_create_function_v2( nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, - xFunc: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, - xStep: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, - xFinal: ?fn (?*c.sqlite3_context) callconv(.C) void, - xDestroy: ?fn (?*anyopaque) callconv(.C) void, + xFunc: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, + xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, + xFinal: ?*const fn (?*c.sqlite3_context) callconv(.C) void, + xDestroy: ?*const fn (?*anyopaque) callconv(.C) void, ) c_int { return sqlite3_api.*.create_function_v2.?(db, zFunctionName, nArg, eTextRep, pApp, xFunc, xStep, xFinal, xDestroy); } @@ -521,7 +521,7 @@ pub export fn sqlite3_stmt_status(pStmt: ?*c.sqlite3_stmt, op: c_int, resetFlag: pub export fn sqlite3_strnicmp(zLeft: [*c]const u8, zRight: [*c]const u8, N: c_int) c_int { return sqlite3_api.*.strnicmp.?(zLeft, zRight, N); } -pub export fn sqlite3_unlock_notify(pBlocked: ?*c.sqlite3, xNotify: ?fn ([*c]?*anyopaque, c_int) callconv(.C) void, pNotifyArg: ?*anyopaque) c_int { +pub export fn sqlite3_unlock_notify(pBlocked: ?*c.sqlite3, xNotify: ?*const fn ([*c]?*anyopaque, c_int) callconv(.C) void, pNotifyArg: ?*anyopaque) c_int { return sqlite3_api.*.unlock_notify.?(pBlocked, xNotify, pNotifyArg); } pub export fn sqlite3_wal_autocheckpoint(db: ?*c.sqlite3, N: c_int) c_int { @@ -530,7 +530,7 @@ pub export fn sqlite3_wal_autocheckpoint(db: ?*c.sqlite3, N: c_int) c_int { pub export fn sqlite3_wal_checkpoint(db: ?*c.sqlite3, zDb: [*c]const u8) c_int { return sqlite3_api.*.wal_checkpoint.?(db, zDb); } -pub export fn sqlite3_wal_hook(db: ?*c.sqlite3, xCallback: ?fn (?*anyopaque, ?*c.sqlite3, [*c]const u8, c_int) callconv(.C) c_int, pArg: ?*anyopaque) ?*anyopaque { +pub export fn sqlite3_wal_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque, ?*c.sqlite3, [*c]const u8, c_int) callconv(.C) c_int, pArg: ?*anyopaque) ?*anyopaque { return sqlite3_api.*.wal_hook.?(db, xCallback, pArg); } pub export fn sqlite3_blob_reopen(pBlob: ?*c.sqlite3_blob, iRow: c.sqlite3_int64) c_int { @@ -575,16 +575,16 @@ pub export fn sqlite3_uri_parameter(zFilename: [*c]const u8, zParam: [*c]const u pub export fn sqlite3_wal_checkpoint_v2(db: ?*c.sqlite3, zDb: [*c]const u8, eMode: c_int, pnLog: [*c]c_int, pnCkpt: [*c]c_int) c_int { return sqlite3_api.*.wal_checkpoint_v2.?(db, zDb, eMode, pnLog, pnCkpt); } -pub export fn sqlite3_auto_extension(xEntryPoint: ?fn () callconv(.C) void) c_int { +pub export fn sqlite3_auto_extension(xEntryPoint: ?*const fn () callconv(.C) void) c_int { return sqlite3_api.*.auto_extension.?(xEntryPoint); } -pub export fn sqlite3_bind_blob64(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c.sqlite3_uint64, xDel: ?fn (?*anyopaque) callconv(.C) void) c_int { +pub export fn sqlite3_bind_blob64(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int { return sqlite3_api.*.bind_blob64.?(pStmt, i, zData, nData, xDel); } -pub export fn sqlite3_bind_text64(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: [*c]const u8, nData: c.sqlite3_uint64, xDel: ?fn (?*anyopaque) callconv(.C) void, encoding: u8) c_int { +pub export fn sqlite3_bind_text64(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: [*c]const u8, nData: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.C) void, encoding: u8) c_int { return sqlite3_api.*.bind_text64.?(pStmt, i, zData, nData, xDel, encoding); } -pub export fn sqlite3_cancel_auto_extension(xEntryPoint: ?fn () callconv(.C) void) c_int { +pub export fn sqlite3_cancel_auto_extension(xEntryPoint: ?*const fn () callconv(.C) void) c_int { return sqlite3_api.*.cancel_auto_extension.?(xEntryPoint); } pub export fn sqlite3_load_extension(db: ?*c.sqlite3, zFile: [*c]const u8, zProc: [*c]const u8, pzErrMsg: [*c][*c]u8) c_int { @@ -602,10 +602,10 @@ pub export fn sqlite3_realloc64(pOld: ?*anyopaque, n: c.sqlite3_uint64) ?*anyopa pub export fn sqlite3_reset_auto_extension() void { return sqlite3_api.*.reset_auto_extension.?(); } -pub export fn sqlite3_result_blob64(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c.sqlite3_uint64, xDel: ?fn (?*anyopaque) callconv(.C) void) void { +pub export fn sqlite3_result_blob64(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void { return sqlite3_api.*.result_blob64.?(pCtx, z, n, xDel); } -pub export fn sqlite3_result_text64(pCtx: ?*c.sqlite3_context, z: [*c]const u8, n: c.sqlite3_uint64, xDel: ?fn (?*anyopaque) callconv(.C) void, encoding: u8) void { +pub export fn sqlite3_result_text64(pCtx: ?*c.sqlite3_context, z: [*c]const u8, n: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.C) void, encoding: u8) void { return sqlite3_api.*.result_text64.?(pCtx, z, n, xDel, encoding); } pub export fn sqlite3_strglob(zGlob: [*c]const u8, zStr: [*c]const u8) c_int { @@ -641,7 +641,7 @@ pub export fn sqlite3_db_cacheflush(db: ?*c.sqlite3) c_int { pub export fn sqlite3_system_errno(db: ?*c.sqlite3) c_int { return sqlite3_api.*.system_errno.?(db); } -pub export fn sqlite3_trace_v2(db: ?*c.sqlite3, uMask: c_uint, xCallback: ?fn (c_uint, ?*anyopaque, ?*anyopaque, ?*anyopaque) callconv(.C) c_int, pCtx: ?*anyopaque) c_int { +pub export fn sqlite3_trace_v2(db: ?*c.sqlite3, uMask: c_uint, xCallback: ?*const fn (c_uint, ?*anyopaque, ?*anyopaque, ?*anyopaque) callconv(.C) c_int, pCtx: ?*anyopaque) c_int { return sqlite3_api.*.trace_v2.?(db, uMask, xCallback, pCtx); } pub export fn sqlite3_expanded_sql(pStmt: ?*c.sqlite3_stmt) [*c]u8 { @@ -656,10 +656,10 @@ pub export fn sqlite3_prepare_v3(db: ?*c.sqlite3, zSql: [*c]const u8, nByte: c_i pub export fn sqlite3_prepare16_v3(db: ?*c.sqlite3, zSql: ?*const anyopaque, nByte: c_int, prepFlags: c_uint, ppStmt: [*c]?*c.sqlite3_stmt, pzTail: [*c]?*const anyopaque) c_int { return sqlite3_api.*.prepare16_v3.?(db, zSql, nByte, prepFlags, ppStmt, pzTail); } -pub export fn sqlite3_bind_pointer(pStmt: ?*c.sqlite3_stmt, i: c_int, pPtr: ?*anyopaque, zPTtype: [*c]const u8, xDestructor: ?fn (?*anyopaque) callconv(.C) void) c_int { +pub export fn sqlite3_bind_pointer(pStmt: ?*c.sqlite3_stmt, i: c_int, pPtr: ?*anyopaque, zPTtype: [*c]const u8, xDestructor: ?*const fn (?*anyopaque) callconv(.C) void) c_int { return sqlite3_api.*.bind_pointer.?(pStmt, i, pPtr, zPTtype, xDestructor); } -pub export fn sqlite3_result_pointer(pCtx: ?*c.sqlite3_context, pPtr: ?*anyopaque, zPType: [*c]const u8, xDestructor: ?fn (?*anyopaque) callconv(.C) void) void { +pub export fn sqlite3_result_pointer(pCtx: ?*c.sqlite3_context, pPtr: ?*anyopaque, zPType: [*c]const u8, xDestructor: ?*const fn (?*anyopaque) callconv(.C) void) void { return sqlite3_api.*.result_pointer.?(pCtx, pPtr, zPType, xDestructor); } pub export fn sqlite3_value_pointer(pVal: ?*c.sqlite3_value, zPType: [*c]const u8) ?*anyopaque { @@ -716,11 +716,11 @@ pub export fn sqlite3_create_window_function( nArg: c_int, eTextRep: c_int, pArg: ?*anyopaque, - xStep: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, - xFinal: ?fn (?*c.sqlite3_context) callconv(.C) void, - xValue: ?fn (?*c.sqlite3_context) callconv(.C) void, - xInverse: ?fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, - xDestroy: ?fn (?*anyopaque) callconv(.C) void, + xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, + xFinal: ?*const fn (?*c.sqlite3_context) callconv(.C) void, + xValue: ?*const fn (?*c.sqlite3_context) callconv(.C) void, + xInverse: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, + xDestroy: ?*const fn (?*anyopaque) callconv(.C) void, ) c_int { return sqlite3_api.*.create_window_function.?( db, @@ -777,7 +777,7 @@ pub export fn sqlite3_changes64(db: ?*c.sqlite3) c.sqlite3_int64 { pub export fn sqlite3_total_changes64(db: ?*c.sqlite3) c.sqlite3_int64 { return sqlite3_api.*.total_changes64.?(db); } -pub export fn sqlite3_autovacuum_pages(db: ?*c.sqlite3, xCallback: ?fn (?*anyopaque, [*c]const u8, c_uint, c_uint, c_uint) callconv(.C) c_uint, pArg: ?*anyopaque, xDestructor: ?fn (?*anyopaque) callconv(.C) void) c_int { +pub export fn sqlite3_autovacuum_pages(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque, [*c]const u8, c_uint, c_uint, c_uint) callconv(.C) c_uint, pArg: ?*anyopaque, xDestructor: ?*const fn (?*anyopaque) callconv(.C) void) c_int { return sqlite3_api.*.autovacuum_pages.?(db, xCallback, pArg, xDestructor); } pub export fn sqlite3_error_offset(db: ?*c.sqlite3) c_int { -- cgit v1.2.3 From d16e5ca7fc308510444105915dcdc602beb80838 Mon Sep 17 00:00:00 2001 From: Vincent Rischmann Date: Thu, 16 Feb 2023 08:41:45 +0100 Subject: fix build --- build.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.zig b/build.zig index fe9a77e..592055b 100644 --- a/build.zig +++ b/build.zig @@ -295,7 +295,7 @@ pub fn build(b: *std.build.Builder) !void { // Setup the output name const fuzz_executable_name = "fuzz"; - const fuzz_exe_path = try std.fs.path.join(b.allocator, &.{ b.cache_root, fuzz_executable_name }); + const fuzz_exe_path = try b.cache_root.join(b.allocator, &.{fuzz_executable_name}); // We want `afl-clang-lto -o path/to/output path/to/library` const fuzz_compile = b.addSystemCommand(&.{ "afl-clang-lto", "-o", fuzz_exe_path }); -- cgit v1.2.3 From 2385ed767c37c07856f128b3f3541ae5774a4b69 Mon Sep 17 00:00:00 2001 From: Vincent Rischmann Date: Thu, 16 Feb 2023 08:46:00 +0100 Subject: fix tests --- sqlite.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sqlite.zig b/sqlite.zig index db6ce0d..1b39a04 100644 --- a/sqlite.zig +++ b/sqlite.zig @@ -2623,7 +2623,7 @@ test "sqlite: read a single text value" { const res = mem.sliceTo(&name.?, sentinel); try testing.expectEqualStrings("Vincent", res); } else { - const res = mem.span(&name.?); + const res: []const u8 = &name.?; try testing.expectEqualStrings("Vincent", res); }, else => @compileError("invalid type " ++ @typeName(typ)), -- cgit v1.2.3 From 1333830fcf6b8e99bb0d9497ceaea79251e5195c Mon Sep 17 00:00:00 2001 From: Vincent Rischmann Date: Wed, 22 Feb 2023 23:20:14 +0100 Subject: fix for latest zig by running 'zig fmt' --- sqlite.zig | 24 ++++++++++++------------ vtab.zig | 12 ++++++------ 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/sqlite.zig b/sqlite.zig index 1b39a04..77c30fc 100644 --- a/sqlite.zig +++ b/sqlite.zig @@ -748,7 +748,7 @@ pub const Db = struct { const sqlite_args = argv[0..fn_info.params.len]; var fn_args: ArgTuple = undefined; - inline for (fn_info.params) |arg, i| { + inline for (fn_info.params, 0..) |arg, i| { const ArgType = arg.type.?; helpers.setTypeFromValue(ArgType, &fn_args[i], sqlite_args[i].?); } @@ -1395,7 +1395,7 @@ pub fn Iterator(comptime Type: type) type { var value: Type = undefined; - inline for (@typeInfo(Type).Struct.fields) |field, _i| { + inline for (@typeInfo(Type).Struct.fields, 0..) |field, _i| { const i = @as(usize, _i); const ret = try self.readField(field.type, options, i); @@ -1721,7 +1721,7 @@ pub const DynamicStatement = struct { switch (@typeInfo(Type)) { .Struct => |StructTypeInfo| { - inline for (StructTypeInfo.fields) |struct_field, struct_field_i| { + inline for (StructTypeInfo.fields, 0..) |struct_field, struct_field_i| { const field_value = @field(values, struct_field.name); const i = sqlite3BindParameterIndex(self.stmt, struct_field.name); @@ -1735,7 +1735,7 @@ pub const DynamicStatement = struct { .Pointer => |PointerTypeInfo| { switch (PointerTypeInfo.size) { .Slice => { - for (values) |value_to_bind, index| { + for (values, 0..) |value_to_bind, index| { try self.bindField(PointerTypeInfo.child, options, "unknown", @intCast(c_int, index), value_to_bind); } }, @@ -1743,7 +1743,7 @@ pub const DynamicStatement = struct { } }, .Array => |ArrayTypeInfo| { - for (values) |value_to_bind, index| { + for (values, 0..) |value_to_bind, index| { try self.bindField(ArrayTypeInfo.child, options, "unknown", @intCast(c_int, index), value_to_bind); } }, @@ -2025,7 +2025,7 @@ pub fn Statement(comptime opts: StatementOptions, comptime query: anytype) type })); } - inline for (StructTypeInfo.fields) |struct_field, _i| { + inline for (StructTypeInfo.fields, 0..) |struct_field, _i| { const bind_marker = query.bind_markers[_i]; if (bind_marker.typed) |typ| { const FieldTypeInfo = @typeInfo(struct_field.type); @@ -2497,7 +2497,7 @@ test "sqlite: read all users into a struct" { var rows = try stmt.all(TestUser, allocator, .{}, .{}); try testing.expectEqual(@as(usize, 3), rows.len); - for (rows) |row, i| { + for (rows, 0..) |row, i| { const exp = test_users[i]; try testing.expectEqual(exp.id, row.id); try testing.expectEqualStrings(exp.name, row.name); @@ -2828,7 +2828,7 @@ test "sqlite: bind pointer" { var stmt = try db.prepare(query); defer stmt.deinit(); - for (test_users) |test_user, i| { + for (test_users, 0..) |test_user, i| { stmt.reset(); const name = try stmt.oneAlloc([]const u8, allocator, .{}, .{&test_user.id}); @@ -2864,7 +2864,7 @@ test "sqlite: read pointers" { ); try testing.expectEqual(@as(usize, 3), rows.len); - for (rows) |row, i| { + for (rows, 0..) |row, i| { const exp = test_users[i]; try testing.expectEqual(exp.id, row.id.*); try testing.expectEqualStrings(exp.name, row.name.*); @@ -2998,7 +2998,7 @@ test "sqlite: statement iterator" { // Check the data try testing.expectEqual(expected_rows.items.len, rows.items.len); - for (rows.items) |row, j| { + for (rows.items, 0..) |row, j| { const exp_row = expected_rows.items[j]; try testing.expectEqualStrings(exp_row.name, mem.sliceTo(&row.name, 0)); try testing.expectEqual(exp_row.age, row.age); @@ -3025,7 +3025,7 @@ test "sqlite: statement iterator" { // Check the data try testing.expectEqual(expected_rows.items.len, rows.items.len); - for (rows.items) |row, j| { + for (rows.items, 0..) |row, j| { const exp_row = expected_rows.items[j]; try testing.expectEqualStrings(exp_row.name, row.name.data); try testing.expectEqual(exp_row.age, row.age); @@ -3386,7 +3386,7 @@ test "sqlite: bind custom type" { const rows = try stmt.all(Article, arena.allocator(), .{}, .{}); try testing.expectEqual(@as(usize, 20), rows.len); - for (rows) |row, i| { + for (rows, 0..) |row, i| { var exp_data: MyData = undefined; mem.set(u8, &exp_data.data, @intCast(u8, i)); diff --git a/vtab.zig b/vtab.zig index aef1b40..a7645c3 100644 --- a/vtab.zig +++ b/vtab.zig @@ -207,7 +207,7 @@ pub const BestIndexBuilder = struct { .id = .{}, }; - for (res.constraints) |*constraint, i| { + for (res.constraints, 0..) |*constraint, i| { const raw_constraint = index_info.aConstraint[i]; constraint.column = @intCast(isize, raw_constraint.iColumn); @@ -233,7 +233,7 @@ pub const BestIndexBuilder = struct { // Populate the constraint usage var constraint_usage: []c.sqlite3_index_constraint_usage = index_info.aConstraintUsage[0..self.constraints.len]; - for (self.constraints) |constraint, i| { + for (self.constraints, 0..) |constraint, i| { constraint_usage[i].argvIndex = constraint.usage.argv_index; constraint_usage[i].omit = if (constraint.usage.omit) 1 else 0; } @@ -541,7 +541,7 @@ fn parseModuleArguments(allocator: mem.Allocator, argc: c_int, argv: [*c]const [ var res = try allocator.alloc(ModuleArgument, @intCast(usize, argc)); errdefer allocator.free(res); - for (res) |*marg, i| { + for (res, 0..) |*marg, i| { // The documentation of sqlite says each string in argv is null-terminated const arg = mem.sliceTo(argv[i], 0); @@ -840,7 +840,7 @@ pub fn VirtualTable( const size = @intCast(usize, argc); var res = try allocator.alloc(FilterArg, size); - for (res) |*item, i| { + for (res, 0..) |*item, i| { item.* = .{ .value = argv[i], }; @@ -1276,7 +1276,7 @@ test "parse module arguments" { const allocator = arena.allocator(); var args = try allocator.alloc([*c]const u8, 20); - for (args) |*arg, i| { + for (args, 0..) |*arg, i| { const tmp = try fmt.allocPrintZ(allocator, "arg={d}", .{i}); arg.* = @ptrCast([*c]const u8, tmp); } @@ -1288,7 +1288,7 @@ test "parse module arguments" { ); try testing.expectEqual(@as(usize, 20), res.len); - for (res) |arg, i| { + for (res, 0..) |arg, i| { try testing.expectEqualStrings("arg", arg.kv.key); try testing.expectEqual(i, try fmt.parseInt(usize, arg.kv.value, 10)); } -- cgit v1.2.3